From 93a5b3f457c1211676296840c285759007a55500 Mon Sep 17 00:00:00 2001
From: Fabio Berger <me@fabioberger.com>
Date: Tue, 30 Jan 2018 13:21:01 +0100
Subject: Fix prettier

---
 .../website/ts/pages/documentation/comment.tsx     |  16 +-
 .../website/ts/pages/documentation/custom_enum.tsx |  34 +-
 .../website/ts/pages/documentation/docs_info.ts    | 198 +++----
 .../ts/pages/documentation/documentation.tsx       | 648 ++++++++++-----------
 packages/website/ts/pages/documentation/enum.tsx   |  26 +-
 .../ts/pages/documentation/event_definition.tsx    | 132 ++---
 .../website/ts/pages/documentation/interface.tsx   |  98 ++--
 .../ts/pages/documentation/method_block.tsx        | 238 ++++----
 .../ts/pages/documentation/method_signature.tsx    | 148 ++---
 .../website/ts/pages/documentation/source_link.tsx |  38 +-
 packages/website/ts/pages/documentation/type.tsx   | 354 +++++------
 .../ts/pages/documentation/type_definition.tsx     | 194 +++---
 12 files changed, 1062 insertions(+), 1062 deletions(-)

(limited to 'packages/website/ts/pages/documentation')

diff --git a/packages/website/ts/pages/documentation/comment.tsx b/packages/website/ts/pages/documentation/comment.tsx
index 23cfd96bd..6be39f586 100644
--- a/packages/website/ts/pages/documentation/comment.tsx
+++ b/packages/website/ts/pages/documentation/comment.tsx
@@ -4,20 +4,20 @@ import * as ReactMarkdown from 'react-markdown';
 import { MarkdownCodeBlock } from 'ts/pages/shared/markdown_code_block';
 
 interface CommentProps {
-    comment: string;
-    className?: string;
+	comment: string;
+	className?: string;
 }
 
 const defaultProps = {
-    className: '',
+	className: '',
 };
 
 export const Comment: React.SFC<CommentProps> = (props: CommentProps) => {
-    return (
-        <div className={`${props.className} comment`}>
-            <ReactMarkdown source={props.comment} renderers={{ CodeBlock: MarkdownCodeBlock }} />
-        </div>
-    );
+	return (
+		<div className={`${props.className} comment`}>
+			<ReactMarkdown source={props.comment} renderers={{ CodeBlock: MarkdownCodeBlock }} />
+		</div>
+	);
 };
 
 Comment.defaultProps = defaultProps;
diff --git a/packages/website/ts/pages/documentation/custom_enum.tsx b/packages/website/ts/pages/documentation/custom_enum.tsx
index 8d50a2f52..0006b8d7e 100644
--- a/packages/website/ts/pages/documentation/custom_enum.tsx
+++ b/packages/website/ts/pages/documentation/custom_enum.tsx
@@ -6,27 +6,27 @@ import { utils } from 'ts/utils/utils';
 const STRING_ENUM_CODE_PREFIX = ' strEnum(';
 
 interface CustomEnumProps {
-    type: CustomType;
+	type: CustomType;
 }
 
 // This component renders custom string enums that was a work-around for versions of
 // TypeScript <2.4.0 that did not support them natively. We keep it around to support
 // older versions of 0x.js <0.9.0
 export function CustomEnum(props: CustomEnumProps) {
-    const type = props.type;
-    if (!_.startsWith(type.defaultValue, STRING_ENUM_CODE_PREFIX)) {
-        utils.consoleLog('We do not yet support `Variable` types that are not strEnums');
-        return null;
-    }
-    // Remove the prefix and postfix, leaving only the strEnum values without quotes.
-    const enumValues = type.defaultValue.slice(10, -3).replace(/'/g, '');
-    return (
-        <span>
-            {`{`}
-            {'\t'}
-            {enumValues}
-            <br />
-            {`}`}
-        </span>
-    );
+	const type = props.type;
+	if (!_.startsWith(type.defaultValue, STRING_ENUM_CODE_PREFIX)) {
+		utils.consoleLog('We do not yet support `Variable` types that are not strEnums');
+		return null;
+	}
+	// Remove the prefix and postfix, leaving only the strEnum values without quotes.
+	const enumValues = type.defaultValue.slice(10, -3).replace(/'/g, '');
+	return (
+		<span>
+			{`{`}
+			{'\t'}
+			{enumValues}
+			<br />
+			{`}`}
+		</span>
+	);
 }
diff --git a/packages/website/ts/pages/documentation/docs_info.ts b/packages/website/ts/pages/documentation/docs_info.ts
index 4b1ec122a..e1080f3a0 100644
--- a/packages/website/ts/pages/documentation/docs_info.ts
+++ b/packages/website/ts/pages/documentation/docs_info.ts
@@ -1,111 +1,111 @@
 import compareVersions = require('compare-versions');
 import * as _ from 'lodash';
 import {
-    DocAgnosticFormat,
-    DocsInfoConfig,
-    DocsMenu,
-    DoxityDocObj,
-    MenuSubsectionsBySection,
-    SectionsMap,
-    TypeDocNode,
+	DocAgnosticFormat,
+	DocsInfoConfig,
+	DocsMenu,
+	DoxityDocObj,
+	MenuSubsectionsBySection,
+	SectionsMap,
+	TypeDocNode,
 } from 'ts/types';
 
 export class DocsInfo {
-    public displayName: string;
-    public packageUrl: string;
-    public subPackageName?: string;
-    public websitePath: string;
-    public docsJsonRoot: string;
-    public menu: DocsMenu;
-    public sections: SectionsMap;
-    public sectionNameToMarkdown: { [sectionName: string]: string };
-    private _docsInfo: DocsInfoConfig;
-    constructor(config: DocsInfoConfig) {
-        this.displayName = config.displayName;
-        this.packageUrl = config.packageUrl;
-        this.subPackageName = config.subPackageName;
-        this.websitePath = config.websitePath;
-        this.docsJsonRoot = config.docsJsonRoot;
-        this.sections = config.sections;
-        this.sectionNameToMarkdown = config.sectionNameToMarkdown;
-        this._docsInfo = config;
-    }
-    public isPublicType(typeName: string): boolean {
-        if (_.isUndefined(this._docsInfo.publicTypes)) {
-            return false;
-        }
-        const isPublic = _.includes(this._docsInfo.publicTypes, typeName);
-        return isPublic;
-    }
-    public getModulePathsIfExists(sectionName: string): string[] {
-        const modulePathsIfExists = this._docsInfo.sectionNameToModulePath[sectionName];
-        return modulePathsIfExists;
-    }
-    public getMenu(selectedVersion?: string): { [section: string]: string[] } {
-        if (_.isUndefined(selectedVersion) || _.isUndefined(this._docsInfo.menuSubsectionToVersionWhenIntroduced)) {
-            return this._docsInfo.menu;
-        }
+	public displayName: string;
+	public packageUrl: string;
+	public subPackageName?: string;
+	public websitePath: string;
+	public docsJsonRoot: string;
+	public menu: DocsMenu;
+	public sections: SectionsMap;
+	public sectionNameToMarkdown: { [sectionName: string]: string };
+	private _docsInfo: DocsInfoConfig;
+	constructor(config: DocsInfoConfig) {
+		this.displayName = config.displayName;
+		this.packageUrl = config.packageUrl;
+		this.subPackageName = config.subPackageName;
+		this.websitePath = config.websitePath;
+		this.docsJsonRoot = config.docsJsonRoot;
+		this.sections = config.sections;
+		this.sectionNameToMarkdown = config.sectionNameToMarkdown;
+		this._docsInfo = config;
+	}
+	public isPublicType(typeName: string): boolean {
+		if (_.isUndefined(this._docsInfo.publicTypes)) {
+			return false;
+		}
+		const isPublic = _.includes(this._docsInfo.publicTypes, typeName);
+		return isPublic;
+	}
+	public getModulePathsIfExists(sectionName: string): string[] {
+		const modulePathsIfExists = this._docsInfo.sectionNameToModulePath[sectionName];
+		return modulePathsIfExists;
+	}
+	public getMenu(selectedVersion?: string): { [section: string]: string[] } {
+		if (_.isUndefined(selectedVersion) || _.isUndefined(this._docsInfo.menuSubsectionToVersionWhenIntroduced)) {
+			return this._docsInfo.menu;
+		}
 
-        const finalMenu = _.cloneDeep(this._docsInfo.menu);
-        if (_.isUndefined(finalMenu.contracts)) {
-            return finalMenu;
-        }
+		const finalMenu = _.cloneDeep(this._docsInfo.menu);
+		if (_.isUndefined(finalMenu.contracts)) {
+			return finalMenu;
+		}
 
-        // TODO: refactor to include more sections then simply the `contracts` section
-        finalMenu.contracts = _.filter(finalMenu.contracts, (contractName: string) => {
-            const versionIntroducedIfExists = this._docsInfo.menuSubsectionToVersionWhenIntroduced[contractName];
-            if (!_.isUndefined(versionIntroducedIfExists)) {
-                const existsInSelectedVersion = compareVersions(selectedVersion, versionIntroducedIfExists) >= 0;
-                return existsInSelectedVersion;
-            } else {
-                return true;
-            }
-        });
-        return finalMenu;
-    }
-    public getMenuSubsectionsBySection(docAgnosticFormat?: DocAgnosticFormat): MenuSubsectionsBySection {
-        const menuSubsectionsBySection = {} as MenuSubsectionsBySection;
-        if (_.isUndefined(docAgnosticFormat)) {
-            return menuSubsectionsBySection;
-        }
+		// TODO: refactor to include more sections then simply the `contracts` section
+		finalMenu.contracts = _.filter(finalMenu.contracts, (contractName: string) => {
+			const versionIntroducedIfExists = this._docsInfo.menuSubsectionToVersionWhenIntroduced[contractName];
+			if (!_.isUndefined(versionIntroducedIfExists)) {
+				const existsInSelectedVersion = compareVersions(selectedVersion, versionIntroducedIfExists) >= 0;
+				return existsInSelectedVersion;
+			} else {
+				return true;
+			}
+		});
+		return finalMenu;
+	}
+	public getMenuSubsectionsBySection(docAgnosticFormat?: DocAgnosticFormat): MenuSubsectionsBySection {
+		const menuSubsectionsBySection = {} as MenuSubsectionsBySection;
+		if (_.isUndefined(docAgnosticFormat)) {
+			return menuSubsectionsBySection;
+		}
 
-        const docSections = _.keys(this.sections);
-        _.each(docSections, sectionName => {
-            const docSection = docAgnosticFormat[sectionName];
-            if (_.isUndefined(docSection)) {
-                return; // no-op
-            }
+		const docSections = _.keys(this.sections);
+		_.each(docSections, sectionName => {
+			const docSection = docAgnosticFormat[sectionName];
+			if (_.isUndefined(docSection)) {
+				return; // no-op
+			}
 
-            if (!_.isUndefined(this.sections.types) && sectionName === this.sections.types) {
-                const sortedTypesNames = _.sortBy(docSection.types, 'name');
-                const typeNames = _.map(sortedTypesNames, t => t.name);
-                menuSubsectionsBySection[sectionName] = typeNames;
-            } else {
-                let eventNames: string[] = [];
-                if (!_.isUndefined(docSection.events)) {
-                    const sortedEventNames = _.sortBy(docSection.events, 'name');
-                    eventNames = _.map(sortedEventNames, m => m.name);
-                }
-                const sortedMethodNames = _.sortBy(docSection.methods, 'name');
-                const methodNames = _.map(sortedMethodNames, m => m.name);
-                menuSubsectionsBySection[sectionName] = [...methodNames, ...eventNames];
-            }
-        });
-        return menuSubsectionsBySection;
-    }
-    public getTypeDefinitionsByName(docAgnosticFormat: DocAgnosticFormat) {
-        if (_.isUndefined(this.sections.types)) {
-            return {};
-        }
+			if (!_.isUndefined(this.sections.types) && sectionName === this.sections.types) {
+				const sortedTypesNames = _.sortBy(docSection.types, 'name');
+				const typeNames = _.map(sortedTypesNames, t => t.name);
+				menuSubsectionsBySection[sectionName] = typeNames;
+			} else {
+				let eventNames: string[] = [];
+				if (!_.isUndefined(docSection.events)) {
+					const sortedEventNames = _.sortBy(docSection.events, 'name');
+					eventNames = _.map(sortedEventNames, m => m.name);
+				}
+				const sortedMethodNames = _.sortBy(docSection.methods, 'name');
+				const methodNames = _.map(sortedMethodNames, m => m.name);
+				menuSubsectionsBySection[sectionName] = [...methodNames, ...eventNames];
+			}
+		});
+		return menuSubsectionsBySection;
+	}
+	public getTypeDefinitionsByName(docAgnosticFormat: DocAgnosticFormat) {
+		if (_.isUndefined(this.sections.types)) {
+			return {};
+		}
 
-        const typeDocSection = docAgnosticFormat[this.sections.types];
-        const typeDefinitionByName = _.keyBy(typeDocSection.types, 'name');
-        return typeDefinitionByName;
-    }
-    public isVisibleConstructor(sectionName: string): boolean {
-        return _.includes(this._docsInfo.visibleConstructors, sectionName);
-    }
-    public convertToDocAgnosticFormat(docObj: DoxityDocObj | TypeDocNode): DocAgnosticFormat {
-        return this._docsInfo.convertToDocAgnosticFormatFn(docObj, this);
-    }
+		const typeDocSection = docAgnosticFormat[this.sections.types];
+		const typeDefinitionByName = _.keyBy(typeDocSection.types, 'name');
+		return typeDefinitionByName;
+	}
+	public isVisibleConstructor(sectionName: string): boolean {
+		return _.includes(this._docsInfo.visibleConstructors, sectionName);
+	}
+	public convertToDocAgnosticFormat(docObj: DoxityDocObj | TypeDocNode): DocAgnosticFormat {
+		return this._docsInfo.convertToDocAgnosticFormatFn(docObj, this);
+	}
 }
diff --git a/packages/website/ts/pages/documentation/documentation.tsx b/packages/website/ts/pages/documentation/documentation.tsx
index 2315847ad..0fc41d775 100644
--- a/packages/website/ts/pages/documentation/documentation.tsx
+++ b/packages/website/ts/pages/documentation/documentation.tsx
@@ -19,17 +19,17 @@ import { NestedSidebarMenu } from 'ts/pages/shared/nested_sidebar_menu';
 import { SectionHeader } from 'ts/pages/shared/section_header';
 import { Dispatcher } from 'ts/redux/dispatcher';
 import {
-    AddressByContractName,
-    DocAgnosticFormat,
-    DoxityDocObj,
-    EtherscanLinkSuffixes,
-    Event,
-    Networks,
-    Property,
-    SolidityMethod,
-    Styles,
-    TypeDefinitionByName,
-    TypescriptMethod,
+	AddressByContractName,
+	DocAgnosticFormat,
+	DoxityDocObj,
+	EtherscanLinkSuffixes,
+	Event,
+	Networks,
+	Property,
+	SolidityMethod,
+	Styles,
+	TypeDefinitionByName,
+	TypescriptMethod,
 } from 'ts/types';
 import { colors } from 'ts/utils/colors';
 import { configs } from 'ts/utils/configs';
@@ -40,340 +40,340 @@ import { utils } from 'ts/utils/utils';
 const SCROLL_TOP_ID = 'docsScrollTop';
 
 const networkNameToColor: { [network: string]: string } = {
-    [Networks.kovan]: colors.purple,
-    [Networks.ropsten]: colors.red,
-    [Networks.mainnet]: colors.turquois,
+	[Networks.kovan]: colors.purple,
+	[Networks.ropsten]: colors.red,
+	[Networks.mainnet]: colors.turquois,
 };
 
 export interface DocumentationAllProps {
-    source: string;
-    location: Location;
-    dispatcher: Dispatcher;
-    docsVersion: string;
-    availableDocVersions: string[];
-    docsInfo: DocsInfo;
+	source: string;
+	location: Location;
+	dispatcher: Dispatcher;
+	docsVersion: string;
+	availableDocVersions: string[];
+	docsInfo: DocsInfo;
 }
 
 interface DocumentationState {
-    docAgnosticFormat?: DocAgnosticFormat;
+	docAgnosticFormat?: DocAgnosticFormat;
 }
 
 const styles: Styles = {
-    mainContainers: {
-        position: 'absolute',
-        top: 1,
-        left: 0,
-        bottom: 0,
-        right: 0,
-        overflowZ: 'hidden',
-        overflowY: 'scroll',
-        minHeight: 'calc(100vh - 1px)',
-        WebkitOverflowScrolling: 'touch',
-    },
-    menuContainer: {
-        borderColor: colors.grey300,
-        maxWidth: 330,
-        marginLeft: 20,
-    },
+	mainContainers: {
+		position: 'absolute',
+		top: 1,
+		left: 0,
+		bottom: 0,
+		right: 0,
+		overflowZ: 'hidden',
+		overflowY: 'scroll',
+		minHeight: 'calc(100vh - 1px)',
+		WebkitOverflowScrolling: 'touch',
+	},
+	menuContainer: {
+		borderColor: colors.grey300,
+		maxWidth: 330,
+		marginLeft: 20,
+	},
 };
 
 export class Documentation extends React.Component<DocumentationAllProps, DocumentationState> {
-    constructor(props: DocumentationAllProps) {
-        super(props);
-        this.state = {
-            docAgnosticFormat: undefined,
-        };
-    }
-    public componentWillMount() {
-        const pathName = this.props.location.pathname;
-        const lastSegment = pathName.substr(pathName.lastIndexOf('/') + 1);
-        const versions = findVersions(lastSegment);
-        const preferredVersionIfExists = versions.length > 0 ? versions[0] : undefined;
-        // tslint:disable-next-line:no-floating-promises
-        this._fetchJSONDocsFireAndForgetAsync(preferredVersionIfExists);
-    }
-    public render() {
-        const menuSubsectionsBySection = _.isUndefined(this.state.docAgnosticFormat)
-            ? {}
-            : this.props.docsInfo.getMenuSubsectionsBySection(this.state.docAgnosticFormat);
-        return (
-            <div>
-                <DocumentTitle title={`${this.props.docsInfo.displayName} Documentation`} />
-                <TopBar
-                    blockchainIsLoaded={false}
-                    location={this.props.location}
-                    docsVersion={this.props.docsVersion}
-                    availableDocVersions={this.props.availableDocVersions}
-                    menu={this.props.docsInfo.getMenu(this.props.docsVersion)}
-                    menuSubsectionsBySection={menuSubsectionsBySection}
-                    shouldFullWidth={true}
-                    docsInfo={this.props.docsInfo}
-                />
-                {_.isUndefined(this.state.docAgnosticFormat) ? (
-                    <div className="col col-12" style={styles.mainContainers}>
-                        <div
-                            className="relative sm-px2 sm-pt2 sm-m1"
-                            style={{ height: 122, top: '50%', transform: 'translateY(-50%)' }}
-                        >
-                            <div className="center pb2">
-                                <CircularProgress size={40} thickness={5} />
-                            </div>
-                            <div className="center pt2" style={{ paddingBottom: 11 }}>
-                                Loading documentation...
-                            </div>
-                        </div>
-                    </div>
-                ) : (
-                    <div className="mx-auto flex" style={{ color: colors.grey800, height: 43 }}>
-                        <div className="relative col md-col-3 lg-col-3 lg-pl0 md-pl1 sm-hide xs-hide">
-                            <div
-                                className="border-right absolute"
-                                style={{ ...styles.menuContainer, ...styles.mainContainers }}
-                            >
-                                <NestedSidebarMenu
-                                    selectedVersion={this.props.docsVersion}
-                                    versions={this.props.availableDocVersions}
-                                    topLevelMenu={this.props.docsInfo.getMenu(this.props.docsVersion)}
-                                    menuSubsectionsBySection={menuSubsectionsBySection}
-                                    docPath={this.props.docsInfo.websitePath}
-                                />
-                            </div>
-                        </div>
-                        <div className="relative col lg-col-9 md-col-9 sm-col-12 col-12">
-                            <div id="documentation" style={styles.mainContainers} className="absolute">
-                                <div id={SCROLL_TOP_ID} />
-                                <h1 className="md-pl2 sm-pl3">
-                                    <a href={this.props.docsInfo.packageUrl} target="_blank">
-                                        {this.props.docsInfo.displayName}
-                                    </a>
-                                </h1>
-                                {this._renderDocumentation()}
-                            </div>
-                        </div>
-                    </div>
-                )}
-            </div>
-        );
-    }
-    private _renderDocumentation(): React.ReactNode {
-        const subMenus = _.values(this.props.docsInfo.getMenu());
-        const orderedSectionNames = _.flatten(subMenus);
+	constructor(props: DocumentationAllProps) {
+		super(props);
+		this.state = {
+			docAgnosticFormat: undefined,
+		};
+	}
+	public componentWillMount() {
+		const pathName = this.props.location.pathname;
+		const lastSegment = pathName.substr(pathName.lastIndexOf('/') + 1);
+		const versions = findVersions(lastSegment);
+		const preferredVersionIfExists = versions.length > 0 ? versions[0] : undefined;
+		// tslint:disable-next-line:no-floating-promises
+		this._fetchJSONDocsFireAndForgetAsync(preferredVersionIfExists);
+	}
+	public render() {
+		const menuSubsectionsBySection = _.isUndefined(this.state.docAgnosticFormat)
+			? {}
+			: this.props.docsInfo.getMenuSubsectionsBySection(this.state.docAgnosticFormat);
+		return (
+			<div>
+				<DocumentTitle title={`${this.props.docsInfo.displayName} Documentation`} />
+				<TopBar
+					blockchainIsLoaded={false}
+					location={this.props.location}
+					docsVersion={this.props.docsVersion}
+					availableDocVersions={this.props.availableDocVersions}
+					menu={this.props.docsInfo.getMenu(this.props.docsVersion)}
+					menuSubsectionsBySection={menuSubsectionsBySection}
+					shouldFullWidth={true}
+					docsInfo={this.props.docsInfo}
+				/>
+				{_.isUndefined(this.state.docAgnosticFormat) ? (
+					<div className="col col-12" style={styles.mainContainers}>
+						<div
+							className="relative sm-px2 sm-pt2 sm-m1"
+							style={{ height: 122, top: '50%', transform: 'translateY(-50%)' }}
+						>
+							<div className="center pb2">
+								<CircularProgress size={40} thickness={5} />
+							</div>
+							<div className="center pt2" style={{ paddingBottom: 11 }}>
+								Loading documentation...
+							</div>
+						</div>
+					</div>
+				) : (
+					<div className="mx-auto flex" style={{ color: colors.grey800, height: 43 }}>
+						<div className="relative col md-col-3 lg-col-3 lg-pl0 md-pl1 sm-hide xs-hide">
+							<div
+								className="border-right absolute"
+								style={{ ...styles.menuContainer, ...styles.mainContainers }}
+							>
+								<NestedSidebarMenu
+									selectedVersion={this.props.docsVersion}
+									versions={this.props.availableDocVersions}
+									topLevelMenu={this.props.docsInfo.getMenu(this.props.docsVersion)}
+									menuSubsectionsBySection={menuSubsectionsBySection}
+									docPath={this.props.docsInfo.websitePath}
+								/>
+							</div>
+						</div>
+						<div className="relative col lg-col-9 md-col-9 sm-col-12 col-12">
+							<div id="documentation" style={styles.mainContainers} className="absolute">
+								<div id={SCROLL_TOP_ID} />
+								<h1 className="md-pl2 sm-pl3">
+									<a href={this.props.docsInfo.packageUrl} target="_blank">
+										{this.props.docsInfo.displayName}
+									</a>
+								</h1>
+								{this._renderDocumentation()}
+							</div>
+						</div>
+					</div>
+				)}
+			</div>
+		);
+	}
+	private _renderDocumentation(): React.ReactNode {
+		const subMenus = _.values(this.props.docsInfo.getMenu());
+		const orderedSectionNames = _.flatten(subMenus);
 
-        const typeDefinitionByName = this.props.docsInfo.getTypeDefinitionsByName(this.state.docAgnosticFormat);
-        const renderedSections = _.map(orderedSectionNames, this._renderSection.bind(this, typeDefinitionByName));
+		const typeDefinitionByName = this.props.docsInfo.getTypeDefinitionsByName(this.state.docAgnosticFormat);
+		const renderedSections = _.map(orderedSectionNames, this._renderSection.bind(this, typeDefinitionByName));
 
-        return renderedSections;
-    }
-    private _renderSection(typeDefinitionByName: TypeDefinitionByName, sectionName: string): React.ReactNode {
-        const markdownFileIfExists = this.props.docsInfo.sectionNameToMarkdown[sectionName];
-        if (!_.isUndefined(markdownFileIfExists)) {
-            return (
-                <MarkdownSection
-                    key={`markdown-section-${sectionName}`}
-                    sectionName={sectionName}
-                    markdownContent={markdownFileIfExists}
-                />
-            );
-        }
+		return renderedSections;
+	}
+	private _renderSection(typeDefinitionByName: TypeDefinitionByName, sectionName: string): React.ReactNode {
+		const markdownFileIfExists = this.props.docsInfo.sectionNameToMarkdown[sectionName];
+		if (!_.isUndefined(markdownFileIfExists)) {
+			return (
+				<MarkdownSection
+					key={`markdown-section-${sectionName}`}
+					sectionName={sectionName}
+					markdownContent={markdownFileIfExists}
+				/>
+			);
+		}
 
-        const docSection = this.state.docAgnosticFormat[sectionName];
-        if (_.isUndefined(docSection)) {
-            return null;
-        }
+		const docSection = this.state.docAgnosticFormat[sectionName];
+		if (_.isUndefined(docSection)) {
+			return null;
+		}
 
-        const sortedTypes = _.sortBy(docSection.types, 'name');
-        const typeDefs = _.map(sortedTypes, customType => {
-            return (
-                <TypeDefinition
-                    sectionName={sectionName}
-                    key={`type-${customType.name}`}
-                    customType={customType}
-                    docsInfo={this.props.docsInfo}
-                />
-            );
-        });
+		const sortedTypes = _.sortBy(docSection.types, 'name');
+		const typeDefs = _.map(sortedTypes, customType => {
+			return (
+				<TypeDefinition
+					sectionName={sectionName}
+					key={`type-${customType.name}`}
+					customType={customType}
+					docsInfo={this.props.docsInfo}
+				/>
+			);
+		});
 
-        const sortedProperties = _.sortBy(docSection.properties, 'name');
-        const propertyDefs = _.map(sortedProperties, this._renderProperty.bind(this, sectionName));
+		const sortedProperties = _.sortBy(docSection.properties, 'name');
+		const propertyDefs = _.map(sortedProperties, this._renderProperty.bind(this, sectionName));
 
-        const sortedMethods = _.sortBy(docSection.methods, 'name');
-        const methodDefs = _.map(sortedMethods, method => {
-            const isConstructor = false;
-            return this._renderMethodBlocks(method, sectionName, isConstructor, typeDefinitionByName);
-        });
+		const sortedMethods = _.sortBy(docSection.methods, 'name');
+		const methodDefs = _.map(sortedMethods, method => {
+			const isConstructor = false;
+			return this._renderMethodBlocks(method, sectionName, isConstructor, typeDefinitionByName);
+		});
 
-        const sortedEvents = _.sortBy(docSection.events, 'name');
-        const eventDefs = _.map(sortedEvents, (event: Event, i: number) => {
-            return (
-                <EventDefinition
-                    key={`event-${event.name}-${i}`}
-                    event={event}
-                    sectionName={sectionName}
-                    docsInfo={this.props.docsInfo}
-                />
-            );
-        });
-        return (
-            <div key={`section-${sectionName}`} className="py2 pr3 md-pl2 sm-pl3">
-                <div className="flex">
-                    <div style={{ marginRight: 7 }}>
-                        <SectionHeader sectionName={sectionName} />
-                    </div>
-                    {this._renderNetworkBadgesIfExists(sectionName)}
-                </div>
-                {docSection.comment && <Comment comment={docSection.comment} />}
-                {docSection.constructors.length > 0 &&
-                    this.props.docsInfo.isVisibleConstructor(sectionName) && (
-                        <div>
-                            <h2 className="thin">Constructor</h2>
-                            {this._renderConstructors(docSection.constructors, sectionName, typeDefinitionByName)}
-                        </div>
-                    )}
-                {docSection.properties.length > 0 && (
-                    <div>
-                        <h2 className="thin">Properties</h2>
-                        <div>{propertyDefs}</div>
-                    </div>
-                )}
-                {docSection.methods.length > 0 && (
-                    <div>
-                        <h2 className="thin">Methods</h2>
-                        <div>{methodDefs}</div>
-                    </div>
-                )}
-                {!_.isUndefined(docSection.events) &&
-                    docSection.events.length > 0 && (
-                        <div>
-                            <h2 className="thin">Events</h2>
-                            <div>{eventDefs}</div>
-                        </div>
-                    )}
-                {!_.isUndefined(typeDefs) &&
-                    typeDefs.length > 0 && (
-                        <div>
-                            <div>{typeDefs}</div>
-                        </div>
-                    )}
-            </div>
-        );
-    }
-    private _renderNetworkBadgesIfExists(sectionName: string) {
-        const networkToAddressByContractName = configs.CONTRACT_ADDRESS[this.props.docsVersion];
-        const badges = _.map(
-            networkToAddressByContractName,
-            (addressByContractName: AddressByContractName, networkName: string) => {
-                const contractAddress = addressByContractName[sectionName];
-                if (_.isUndefined(contractAddress)) {
-                    return null;
-                }
-                const linkIfExists = utils.getEtherScanLinkIfExists(
-                    contractAddress,
-                    constants.NETWORK_ID_BY_NAME[networkName],
-                    EtherscanLinkSuffixes.Address,
-                );
-                return (
-                    <a
-                        key={`badge-${networkName}-${sectionName}`}
-                        href={linkIfExists}
-                        target="_blank"
-                        style={{ color: colors.white, textDecoration: 'none' }}
-                    >
-                        <Badge title={networkName} backgroundColor={networkNameToColor[networkName]} />
-                    </a>
-                );
-            },
-        );
-        return badges;
-    }
-    private _renderConstructors(
-        constructors: SolidityMethod[] | TypescriptMethod[],
-        sectionName: string,
-        typeDefinitionByName: TypeDefinitionByName,
-    ): React.ReactNode {
-        const constructorDefs = _.map(constructors, constructor => {
-            return this._renderMethodBlocks(constructor, sectionName, constructor.isConstructor, typeDefinitionByName);
-        });
-        return <div>{constructorDefs}</div>;
-    }
-    private _renderProperty(sectionName: string, property: Property): React.ReactNode {
-        return (
-            <div key={`property-${property.name}-${property.type.name}`} className="pb3">
-                <code className="hljs">
-                    {property.name}:
-                    <Type type={property.type} sectionName={sectionName} docsInfo={this.props.docsInfo} />
-                </code>
-                {property.source && (
-                    <SourceLink
-                        version={this.props.docsVersion}
-                        source={property.source}
-                        baseUrl={this.props.docsInfo.packageUrl}
-                        subPackageName={this.props.docsInfo.subPackageName}
-                    />
-                )}
-                {property.comment && <Comment comment={property.comment} className="py2" />}
-            </div>
-        );
-    }
-    private _renderMethodBlocks(
-        method: SolidityMethod | TypescriptMethod,
-        sectionName: string,
-        isConstructor: boolean,
-        typeDefinitionByName: TypeDefinitionByName,
-    ): React.ReactNode {
-        return (
-            <MethodBlock
-                key={`method-${method.name}-${sectionName}`}
-                sectionName={sectionName}
-                method={method}
-                typeDefinitionByName={typeDefinitionByName}
-                libraryVersion={this.props.docsVersion}
-                docsInfo={this.props.docsInfo}
-            />
-        );
-    }
-    private _scrollToHash(): void {
-        const hashWithPrefix = this.props.location.hash;
-        let hash = hashWithPrefix.slice(1);
-        if (_.isEmpty(hash)) {
-            hash = SCROLL_TOP_ID; // scroll to the top
-        }
+		const sortedEvents = _.sortBy(docSection.events, 'name');
+		const eventDefs = _.map(sortedEvents, (event: Event, i: number) => {
+			return (
+				<EventDefinition
+					key={`event-${event.name}-${i}`}
+					event={event}
+					sectionName={sectionName}
+					docsInfo={this.props.docsInfo}
+				/>
+			);
+		});
+		return (
+			<div key={`section-${sectionName}`} className="py2 pr3 md-pl2 sm-pl3">
+				<div className="flex">
+					<div style={{ marginRight: 7 }}>
+						<SectionHeader sectionName={sectionName} />
+					</div>
+					{this._renderNetworkBadgesIfExists(sectionName)}
+				</div>
+				{docSection.comment && <Comment comment={docSection.comment} />}
+				{docSection.constructors.length > 0 &&
+					this.props.docsInfo.isVisibleConstructor(sectionName) && (
+						<div>
+							<h2 className="thin">Constructor</h2>
+							{this._renderConstructors(docSection.constructors, sectionName, typeDefinitionByName)}
+						</div>
+					)}
+				{docSection.properties.length > 0 && (
+					<div>
+						<h2 className="thin">Properties</h2>
+						<div>{propertyDefs}</div>
+					</div>
+				)}
+				{docSection.methods.length > 0 && (
+					<div>
+						<h2 className="thin">Methods</h2>
+						<div>{methodDefs}</div>
+					</div>
+				)}
+				{!_.isUndefined(docSection.events) &&
+					docSection.events.length > 0 && (
+						<div>
+							<h2 className="thin">Events</h2>
+							<div>{eventDefs}</div>
+						</div>
+					)}
+				{!_.isUndefined(typeDefs) &&
+					typeDefs.length > 0 && (
+						<div>
+							<div>{typeDefs}</div>
+						</div>
+					)}
+			</div>
+		);
+	}
+	private _renderNetworkBadgesIfExists(sectionName: string) {
+		const networkToAddressByContractName = configs.CONTRACT_ADDRESS[this.props.docsVersion];
+		const badges = _.map(
+			networkToAddressByContractName,
+			(addressByContractName: AddressByContractName, networkName: string) => {
+				const contractAddress = addressByContractName[sectionName];
+				if (_.isUndefined(contractAddress)) {
+					return null;
+				}
+				const linkIfExists = utils.getEtherScanLinkIfExists(
+					contractAddress,
+					constants.NETWORK_ID_BY_NAME[networkName],
+					EtherscanLinkSuffixes.Address,
+				);
+				return (
+					<a
+						key={`badge-${networkName}-${sectionName}`}
+						href={linkIfExists}
+						target="_blank"
+						style={{ color: colors.white, textDecoration: 'none' }}
+					>
+						<Badge title={networkName} backgroundColor={networkNameToColor[networkName]} />
+					</a>
+				);
+			},
+		);
+		return badges;
+	}
+	private _renderConstructors(
+		constructors: SolidityMethod[] | TypescriptMethod[],
+		sectionName: string,
+		typeDefinitionByName: TypeDefinitionByName,
+	): React.ReactNode {
+		const constructorDefs = _.map(constructors, constructor => {
+			return this._renderMethodBlocks(constructor, sectionName, constructor.isConstructor, typeDefinitionByName);
+		});
+		return <div>{constructorDefs}</div>;
+	}
+	private _renderProperty(sectionName: string, property: Property): React.ReactNode {
+		return (
+			<div key={`property-${property.name}-${property.type.name}`} className="pb3">
+				<code className="hljs">
+					{property.name}:
+					<Type type={property.type} sectionName={sectionName} docsInfo={this.props.docsInfo} />
+				</code>
+				{property.source && (
+					<SourceLink
+						version={this.props.docsVersion}
+						source={property.source}
+						baseUrl={this.props.docsInfo.packageUrl}
+						subPackageName={this.props.docsInfo.subPackageName}
+					/>
+				)}
+				{property.comment && <Comment comment={property.comment} className="py2" />}
+			</div>
+		);
+	}
+	private _renderMethodBlocks(
+		method: SolidityMethod | TypescriptMethod,
+		sectionName: string,
+		isConstructor: boolean,
+		typeDefinitionByName: TypeDefinitionByName,
+	): React.ReactNode {
+		return (
+			<MethodBlock
+				key={`method-${method.name}-${sectionName}`}
+				sectionName={sectionName}
+				method={method}
+				typeDefinitionByName={typeDefinitionByName}
+				libraryVersion={this.props.docsVersion}
+				docsInfo={this.props.docsInfo}
+			/>
+		);
+	}
+	private _scrollToHash(): void {
+		const hashWithPrefix = this.props.location.hash;
+		let hash = hashWithPrefix.slice(1);
+		if (_.isEmpty(hash)) {
+			hash = SCROLL_TOP_ID; // scroll to the top
+		}
 
-        scroller.scrollTo(hash, {
-            duration: 0,
-            offset: 0,
-            containerId: 'documentation',
-        });
-    }
-    private async _fetchJSONDocsFireAndForgetAsync(preferredVersionIfExists?: string): Promise<void> {
-        const versionToFileName = await docUtils.getVersionToFileNameAsync(this.props.docsInfo.docsJsonRoot);
-        const versions = _.keys(versionToFileName);
-        this.props.dispatcher.updateAvailableDocVersions(versions);
-        const sortedVersions = semverSort.desc(versions);
-        const latestVersion = sortedVersions[0];
+		scroller.scrollTo(hash, {
+			duration: 0,
+			offset: 0,
+			containerId: 'documentation',
+		});
+	}
+	private async _fetchJSONDocsFireAndForgetAsync(preferredVersionIfExists?: string): Promise<void> {
+		const versionToFileName = await docUtils.getVersionToFileNameAsync(this.props.docsInfo.docsJsonRoot);
+		const versions = _.keys(versionToFileName);
+		this.props.dispatcher.updateAvailableDocVersions(versions);
+		const sortedVersions = semverSort.desc(versions);
+		const latestVersion = sortedVersions[0];
 
-        let versionToFetch = latestVersion;
-        if (!_.isUndefined(preferredVersionIfExists)) {
-            const preferredVersionFileNameIfExists = versionToFileName[preferredVersionIfExists];
-            if (!_.isUndefined(preferredVersionFileNameIfExists)) {
-                versionToFetch = preferredVersionIfExists;
-            }
-        }
-        this.props.dispatcher.updateCurrentDocsVersion(versionToFetch);
+		let versionToFetch = latestVersion;
+		if (!_.isUndefined(preferredVersionIfExists)) {
+			const preferredVersionFileNameIfExists = versionToFileName[preferredVersionIfExists];
+			if (!_.isUndefined(preferredVersionFileNameIfExists)) {
+				versionToFetch = preferredVersionIfExists;
+			}
+		}
+		this.props.dispatcher.updateCurrentDocsVersion(versionToFetch);
 
-        const versionFileNameToFetch = versionToFileName[versionToFetch];
-        const versionDocObj = await docUtils.getJSONDocFileAsync(
-            versionFileNameToFetch,
-            this.props.docsInfo.docsJsonRoot,
-        );
-        const docAgnosticFormat = this.props.docsInfo.convertToDocAgnosticFormat(versionDocObj as DoxityDocObj);
+		const versionFileNameToFetch = versionToFileName[versionToFetch];
+		const versionDocObj = await docUtils.getJSONDocFileAsync(
+			versionFileNameToFetch,
+			this.props.docsInfo.docsJsonRoot,
+		);
+		const docAgnosticFormat = this.props.docsInfo.convertToDocAgnosticFormat(versionDocObj as DoxityDocObj);
 
-        this.setState(
-            {
-                docAgnosticFormat,
-            },
-            () => {
-                this._scrollToHash();
-            },
-        );
-    }
+		this.setState(
+			{
+				docAgnosticFormat,
+			},
+			() => {
+				this._scrollToHash();
+			},
+		);
+	}
 }
diff --git a/packages/website/ts/pages/documentation/enum.tsx b/packages/website/ts/pages/documentation/enum.tsx
index 7dfdee771..cfcc7f8d7 100644
--- a/packages/website/ts/pages/documentation/enum.tsx
+++ b/packages/website/ts/pages/documentation/enum.tsx
@@ -3,20 +3,20 @@ import * as React from 'react';
 import { EnumValue } from 'ts/types';
 
 interface EnumProps {
-    values: EnumValue[];
+	values: EnumValue[];
 }
 
 export function Enum(props: EnumProps) {
-    const values = _.map(props.values, (value, i) => {
-        const defaultValueIfAny = !_.isUndefined(value.defaultValue) ? ` = ${value.defaultValue}` : '';
-        return `\n\t${value.name}${defaultValueIfAny},`;
-    });
-    return (
-        <span>
-            {`{`}
-            {values}
-            <br />
-            {`}`}
-        </span>
-    );
+	const values = _.map(props.values, (value, i) => {
+		const defaultValueIfAny = !_.isUndefined(value.defaultValue) ? ` = ${value.defaultValue}` : '';
+		return `\n\t${value.name}${defaultValueIfAny},`;
+	});
+	return (
+		<span>
+			{`{`}
+			{values}
+			<br />
+			{`}`}
+		</span>
+	);
 }
diff --git a/packages/website/ts/pages/documentation/event_definition.tsx b/packages/website/ts/pages/documentation/event_definition.tsx
index 0e53e38e7..9274ae512 100644
--- a/packages/website/ts/pages/documentation/event_definition.tsx
+++ b/packages/website/ts/pages/documentation/event_definition.tsx
@@ -7,76 +7,76 @@ import { Event, EventArg, HeaderSizes } from 'ts/types';
 import { colors } from 'ts/utils/colors';
 
 interface EventDefinitionProps {
-    event: Event;
-    sectionName: string;
-    docsInfo: DocsInfo;
+	event: Event;
+	sectionName: string;
+	docsInfo: DocsInfo;
 }
 
 interface EventDefinitionState {
-    shouldShowAnchor: boolean;
+	shouldShowAnchor: boolean;
 }
 
 export class EventDefinition extends React.Component<EventDefinitionProps, EventDefinitionState> {
-    constructor(props: EventDefinitionProps) {
-        super(props);
-        this.state = {
-            shouldShowAnchor: false,
-        };
-    }
-    public render() {
-        const event = this.props.event;
-        return (
-            <div
-                id={`${this.props.sectionName}-${event.name}`}
-                className="pb2"
-                style={{ overflow: 'hidden', width: '100%' }}
-                onMouseOver={this._setAnchorVisibility.bind(this, true)}
-                onMouseOut={this._setAnchorVisibility.bind(this, false)}
-            >
-                <AnchorTitle
-                    headerSize={HeaderSizes.H3}
-                    title={`Event ${event.name}`}
-                    id={event.name}
-                    shouldShowAnchor={this.state.shouldShowAnchor}
-                />
-                <div style={{ fontSize: 16 }}>
-                    <pre>
-                        <code className="hljs">{this._renderEventCode()}</code>
-                    </pre>
-                </div>
-            </div>
-        );
-    }
-    private _renderEventCode() {
-        const indexed = <span style={{ color: colors.green }}> indexed</span>;
-        const eventArgs = _.map(this.props.event.eventArgs, (eventArg: EventArg) => {
-            const type = (
-                <Type type={eventArg.type} sectionName={this.props.sectionName} docsInfo={this.props.docsInfo} />
-            );
-            return (
-                <span key={`eventArg-${eventArg.name}`}>
-                    {eventArg.name}
-                    {eventArg.isIndexed ? indexed : ''}: {type},
-                </span>
-            );
-        });
-        const argList = _.reduce(eventArgs, (prev: React.ReactNode, curr: React.ReactNode) => {
-            return [prev, '\n\t', curr];
-        });
-        return (
-            <span>
-                {`{`}
-                <br />
-                {'\t'}
-                {argList}
-                <br />
-                {`}`}
-            </span>
-        );
-    }
-    private _setAnchorVisibility(shouldShowAnchor: boolean) {
-        this.setState({
-            shouldShowAnchor,
-        });
-    }
+	constructor(props: EventDefinitionProps) {
+		super(props);
+		this.state = {
+			shouldShowAnchor: false,
+		};
+	}
+	public render() {
+		const event = this.props.event;
+		return (
+			<div
+				id={`${this.props.sectionName}-${event.name}`}
+				className="pb2"
+				style={{ overflow: 'hidden', width: '100%' }}
+				onMouseOver={this._setAnchorVisibility.bind(this, true)}
+				onMouseOut={this._setAnchorVisibility.bind(this, false)}
+			>
+				<AnchorTitle
+					headerSize={HeaderSizes.H3}
+					title={`Event ${event.name}`}
+					id={event.name}
+					shouldShowAnchor={this.state.shouldShowAnchor}
+				/>
+				<div style={{ fontSize: 16 }}>
+					<pre>
+						<code className="hljs">{this._renderEventCode()}</code>
+					</pre>
+				</div>
+			</div>
+		);
+	}
+	private _renderEventCode() {
+		const indexed = <span style={{ color: colors.green }}> indexed</span>;
+		const eventArgs = _.map(this.props.event.eventArgs, (eventArg: EventArg) => {
+			const type = (
+				<Type type={eventArg.type} sectionName={this.props.sectionName} docsInfo={this.props.docsInfo} />
+			);
+			return (
+				<span key={`eventArg-${eventArg.name}`}>
+					{eventArg.name}
+					{eventArg.isIndexed ? indexed : ''}: {type},
+				</span>
+			);
+		});
+		const argList = _.reduce(eventArgs, (prev: React.ReactNode, curr: React.ReactNode) => {
+			return [prev, '\n\t', curr];
+		});
+		return (
+			<span>
+				{`{`}
+				<br />
+				{'\t'}
+				{argList}
+				<br />
+				{`}`}
+			</span>
+		);
+	}
+	private _setAnchorVisibility(shouldShowAnchor: boolean) {
+		this.setState({
+			shouldShowAnchor,
+		});
+	}
 }
diff --git a/packages/website/ts/pages/documentation/interface.tsx b/packages/website/ts/pages/documentation/interface.tsx
index 16a772125..ee07a2c50 100644
--- a/packages/website/ts/pages/documentation/interface.tsx
+++ b/packages/website/ts/pages/documentation/interface.tsx
@@ -6,56 +6,56 @@ import { Type } from 'ts/pages/documentation/type';
 import { CustomType, TypeDocTypes } from 'ts/types';
 
 interface InterfaceProps {
-    type: CustomType;
-    sectionName: string;
-    docsInfo: DocsInfo;
+	type: CustomType;
+	sectionName: string;
+	docsInfo: DocsInfo;
 }
 
 export function Interface(props: InterfaceProps) {
-    const type = props.type;
-    const properties = _.map(type.children, property => {
-        return (
-            <span key={`property-${property.name}-${property.type}-${type.name}`}>
-                {property.name}:{' '}
-                {property.type.typeDocType !== TypeDocTypes.Reflection ? (
-                    <Type type={property.type} sectionName={props.sectionName} docsInfo={props.docsInfo} />
-                ) : (
-                    <MethodSignature
-                        method={property.type.method}
-                        sectionName={props.sectionName}
-                        shouldHideMethodName={true}
-                        shouldUseArrowSyntax={true}
-                        docsInfo={props.docsInfo}
-                    />
-                )},
-            </span>
-        );
-    });
-    const hasIndexSignature = !_.isUndefined(type.indexSignature);
-    if (hasIndexSignature) {
-        const is = type.indexSignature;
-        const param = (
-            <span key={`indexSigParams-${is.keyName}-${is.keyType}-${type.name}`}>
-                {is.keyName}: <Type type={is.keyType} sectionName={props.sectionName} docsInfo={props.docsInfo} />
-            </span>
-        );
-        properties.push(
-            <span key={`indexSignature-${type.name}-${is.keyType.name}`}>
-                [{param}]: {is.valueName},
-            </span>,
-        );
-    }
-    const propertyList = _.reduce(properties, (prev: React.ReactNode, curr: React.ReactNode) => {
-        return [prev, '\n\t', curr];
-    });
-    return (
-        <span>
-            {`{`}
-            <br />
-            {'\t'}
-            {propertyList}
-            <br />
-            {`}`}
-        </span>
-    );
+	const type = props.type;
+	const properties = _.map(type.children, property => {
+		return (
+			<span key={`property-${property.name}-${property.type}-${type.name}`}>
+				{property.name}:{' '}
+				{property.type.typeDocType !== TypeDocTypes.Reflection ? (
+					<Type type={property.type} sectionName={props.sectionName} docsInfo={props.docsInfo} />
+				) : (
+					<MethodSignature
+						method={property.type.method}
+						sectionName={props.sectionName}
+						shouldHideMethodName={true}
+						shouldUseArrowSyntax={true}
+						docsInfo={props.docsInfo}
+					/>
+				)},
+			</span>
+		);
+	});
+	const hasIndexSignature = !_.isUndefined(type.indexSignature);
+	if (hasIndexSignature) {
+		const is = type.indexSignature;
+		const param = (
+			<span key={`indexSigParams-${is.keyName}-${is.keyType}-${type.name}`}>
+				{is.keyName}: <Type type={is.keyType} sectionName={props.sectionName} docsInfo={props.docsInfo} />
+			</span>
+		);
+		properties.push(
+			<span key={`indexSignature-${type.name}-${is.keyType.name}`}>
+				[{param}]: {is.valueName},
+			</span>,
+		);
+	}
+	const propertyList = _.reduce(properties, (prev: React.ReactNode, curr: React.ReactNode) => {
+		return [prev, '\n\t', curr];
+	});
+	return (
+		<span>
+			{`{`}
+			<br />
+			{'\t'}
+			{propertyList}
+			<br />
+			{`}`}
+		</span>
+	);
 }
diff --git a/packages/website/ts/pages/documentation/method_block.tsx b/packages/website/ts/pages/documentation/method_block.tsx
index dfde5931b..fb03cf5be 100644
--- a/packages/website/ts/pages/documentation/method_block.tsx
+++ b/packages/website/ts/pages/documentation/method_block.tsx
@@ -10,133 +10,133 @@ import { colors } from 'ts/utils/colors';
 import { typeDocUtils } from 'ts/utils/typedoc_utils';
 
 interface MethodBlockProps {
-    method: SolidityMethod | TypescriptMethod;
-    sectionName: string;
-    libraryVersion: string;
-    typeDefinitionByName: TypeDefinitionByName;
-    docsInfo: DocsInfo;
+	method: SolidityMethod | TypescriptMethod;
+	sectionName: string;
+	libraryVersion: string;
+	typeDefinitionByName: TypeDefinitionByName;
+	docsInfo: DocsInfo;
 }
 
 interface MethodBlockState {
-    shouldShowAnchor: boolean;
+	shouldShowAnchor: boolean;
 }
 
 const styles: Styles = {
-    chip: {
-        fontSize: 13,
-        backgroundColor: colors.lightBlueA700,
-        color: colors.white,
-        height: 11,
-        borderRadius: 14,
-        marginTop: 19,
-        lineHeight: 0.8,
-    },
+	chip: {
+		fontSize: 13,
+		backgroundColor: colors.lightBlueA700,
+		color: colors.white,
+		height: 11,
+		borderRadius: 14,
+		marginTop: 19,
+		lineHeight: 0.8,
+	},
 };
 
 export class MethodBlock extends React.Component<MethodBlockProps, MethodBlockState> {
-    constructor(props: MethodBlockProps) {
-        super(props);
-        this.state = {
-            shouldShowAnchor: false,
-        };
-    }
-    public render() {
-        const method = this.props.method;
-        if (typeDocUtils.isPrivateOrProtectedProperty(method.name)) {
-            return null;
-        }
+	constructor(props: MethodBlockProps) {
+		super(props);
+		this.state = {
+			shouldShowAnchor: false,
+		};
+	}
+	public render() {
+		const method = this.props.method;
+		if (typeDocUtils.isPrivateOrProtectedProperty(method.name)) {
+			return null;
+		}
 
-        return (
-            <div
-                id={`${this.props.sectionName}-${method.name}`}
-                style={{ overflow: 'hidden', width: '100%' }}
-                className="pb4"
-                onMouseOver={this._setAnchorVisibility.bind(this, true)}
-                onMouseOut={this._setAnchorVisibility.bind(this, false)}
-            >
-                {!method.isConstructor && (
-                    <div className="flex">
-                        {(method as TypescriptMethod).isStatic && this._renderChip('Static')}
-                        {(method as SolidityMethod).isConstant && this._renderChip('Constant')}
-                        {(method as SolidityMethod).isPayable && this._renderChip('Payable')}
-                        <AnchorTitle
-                            headerSize={HeaderSizes.H3}
-                            title={method.name}
-                            id={`${this.props.sectionName}-${method.name}`}
-                            shouldShowAnchor={this.state.shouldShowAnchor}
-                        />
-                    </div>
-                )}
-                <code className="hljs">
-                    <MethodSignature
-                        method={method}
-                        sectionName={this.props.sectionName}
-                        typeDefinitionByName={this.props.typeDefinitionByName}
-                        docsInfo={this.props.docsInfo}
-                    />
-                </code>
-                {(method as TypescriptMethod).source && (
-                    <SourceLink
-                        version={this.props.libraryVersion}
-                        source={(method as TypescriptMethod).source}
-                        baseUrl={this.props.docsInfo.packageUrl}
-                        subPackageName={this.props.docsInfo.subPackageName}
-                    />
-                )}
-                {method.comment && <Comment comment={method.comment} className="py2" />}
-                {method.parameters &&
-                    !_.isEmpty(method.parameters) && (
-                        <div>
-                            <h4 className="pb1 thin" style={{ borderBottom: '1px solid #e1e8ed' }}>
-                                ARGUMENTS
-                            </h4>
-                            {this._renderParameterDescriptions(method.parameters)}
-                        </div>
-                    )}
-                {method.returnComment && (
-                    <div className="pt1 comment">
-                        <h4 className="pb1 thin" style={{ borderBottom: '1px solid #e1e8ed' }}>
-                            RETURNS
-                        </h4>
-                        <Comment comment={method.returnComment} />
-                    </div>
-                )}
-            </div>
-        );
-    }
-    private _renderChip(text: string) {
-        return (
-            <div className="p1 mr1" style={styles.chip}>
-                {text}
-            </div>
-        );
-    }
-    private _renderParameterDescriptions(parameters: Parameter[]) {
-        const descriptions = _.map(parameters, parameter => {
-            const isOptional = parameter.isOptional;
-            return (
-                <div
-                    key={`param-description-${parameter.name}`}
-                    className="flex pb1 mb2"
-                    style={{ borderBottom: '1px solid #f0f4f7' }}
-                >
-                    <div className="pl2 col lg-col-4 md-col-4 sm-col-12 col-12">
-                        <div className="bold">{parameter.name}</div>
-                        <div className="pt1" style={{ color: colors.grey, fontSize: 14 }}>
-                            {isOptional && 'optional'}
-                        </div>
-                    </div>
-                    <div className="col lg-col-8 md-col-8 sm-col-12 col-12">
-                        {parameter.comment && <Comment comment={parameter.comment} />}
-                    </div>
-                </div>
-            );
-        });
-        return descriptions;
-    }
-    private _setAnchorVisibility(shouldShowAnchor: boolean) {
-        this.setState({
-            shouldShowAnchor,
-        });
-    }
+		return (
+			<div
+				id={`${this.props.sectionName}-${method.name}`}
+				style={{ overflow: 'hidden', width: '100%' }}
+				className="pb4"
+				onMouseOver={this._setAnchorVisibility.bind(this, true)}
+				onMouseOut={this._setAnchorVisibility.bind(this, false)}
+			>
+				{!method.isConstructor && (
+					<div className="flex">
+						{(method as TypescriptMethod).isStatic && this._renderChip('Static')}
+						{(method as SolidityMethod).isConstant && this._renderChip('Constant')}
+						{(method as SolidityMethod).isPayable && this._renderChip('Payable')}
+						<AnchorTitle
+							headerSize={HeaderSizes.H3}
+							title={method.name}
+							id={`${this.props.sectionName}-${method.name}`}
+							shouldShowAnchor={this.state.shouldShowAnchor}
+						/>
+					</div>
+				)}
+				<code className="hljs">
+					<MethodSignature
+						method={method}
+						sectionName={this.props.sectionName}
+						typeDefinitionByName={this.props.typeDefinitionByName}
+						docsInfo={this.props.docsInfo}
+					/>
+				</code>
+				{(method as TypescriptMethod).source && (
+					<SourceLink
+						version={this.props.libraryVersion}
+						source={(method as TypescriptMethod).source}
+						baseUrl={this.props.docsInfo.packageUrl}
+						subPackageName={this.props.docsInfo.subPackageName}
+					/>
+				)}
+				{method.comment && <Comment comment={method.comment} className="py2" />}
+				{method.parameters &&
+					!_.isEmpty(method.parameters) && (
+						<div>
+							<h4 className="pb1 thin" style={{ borderBottom: '1px solid #e1e8ed' }}>
+								ARGUMENTS
+							</h4>
+							{this._renderParameterDescriptions(method.parameters)}
+						</div>
+					)}
+				{method.returnComment && (
+					<div className="pt1 comment">
+						<h4 className="pb1 thin" style={{ borderBottom: '1px solid #e1e8ed' }}>
+							RETURNS
+						</h4>
+						<Comment comment={method.returnComment} />
+					</div>
+				)}
+			</div>
+		);
+	}
+	private _renderChip(text: string) {
+		return (
+			<div className="p1 mr1" style={styles.chip}>
+				{text}
+			</div>
+		);
+	}
+	private _renderParameterDescriptions(parameters: Parameter[]) {
+		const descriptions = _.map(parameters, parameter => {
+			const isOptional = parameter.isOptional;
+			return (
+				<div
+					key={`param-description-${parameter.name}`}
+					className="flex pb1 mb2"
+					style={{ borderBottom: '1px solid #f0f4f7' }}
+				>
+					<div className="pl2 col lg-col-4 md-col-4 sm-col-12 col-12">
+						<div className="bold">{parameter.name}</div>
+						<div className="pt1" style={{ color: colors.grey, fontSize: 14 }}>
+							{isOptional && 'optional'}
+						</div>
+					</div>
+					<div className="col lg-col-8 md-col-8 sm-col-12 col-12">
+						{parameter.comment && <Comment comment={parameter.comment} />}
+					</div>
+				</div>
+			);
+		});
+		return descriptions;
+	}
+	private _setAnchorVisibility(shouldShowAnchor: boolean) {
+		this.setState({
+			shouldShowAnchor,
+		});
+	}
 }
diff --git a/packages/website/ts/pages/documentation/method_signature.tsx b/packages/website/ts/pages/documentation/method_signature.tsx
index 041dcd093..7c6bf96d2 100644
--- a/packages/website/ts/pages/documentation/method_signature.tsx
+++ b/packages/website/ts/pages/documentation/method_signature.tsx
@@ -6,94 +6,94 @@ import { Parameter, SolidityMethod, TypeDefinitionByName, TypescriptMethod } fro
 import { constants } from 'ts/utils/constants';
 
 interface MethodSignatureProps {
-    method: TypescriptMethod | SolidityMethod;
-    sectionName: string;
-    shouldHideMethodName?: boolean;
-    shouldUseArrowSyntax?: boolean;
-    typeDefinitionByName?: TypeDefinitionByName;
-    docsInfo: DocsInfo;
+	method: TypescriptMethod | SolidityMethod;
+	sectionName: string;
+	shouldHideMethodName?: boolean;
+	shouldUseArrowSyntax?: boolean;
+	typeDefinitionByName?: TypeDefinitionByName;
+	docsInfo: DocsInfo;
 }
 
 const defaultProps = {
-    shouldHideMethodName: false,
-    shouldUseArrowSyntax: false,
+	shouldHideMethodName: false,
+	shouldUseArrowSyntax: false,
 };
 
 export const MethodSignature: React.SFC<MethodSignatureProps> = (props: MethodSignatureProps) => {
-    const sectionName = constants.TYPES_SECTION_NAME;
-    const parameters = renderParameters(props.method, props.docsInfo, sectionName, props.typeDefinitionByName);
-    const paramString = _.reduce(parameters, (prev: React.ReactNode, curr: React.ReactNode) => {
-        return [prev, ', ', curr];
-    });
-    const methodName = props.shouldHideMethodName ? '' : props.method.name;
-    const typeParameterIfExists = _.isUndefined((props.method as TypescriptMethod).typeParameter)
-        ? undefined
-        : renderTypeParameter(props.method, props.docsInfo, sectionName, props.typeDefinitionByName);
-    return (
-        <span>
-            {props.method.callPath}
-            {methodName}
-            {typeParameterIfExists}({paramString})
-            {props.shouldUseArrowSyntax ? ' => ' : ': '}{' '}
-            {props.method.returnType && (
-                <Type
-                    type={props.method.returnType}
-                    sectionName={sectionName}
-                    typeDefinitionByName={props.typeDefinitionByName}
-                    docsInfo={props.docsInfo}
-                />
-            )}
-        </span>
-    );
+	const sectionName = constants.TYPES_SECTION_NAME;
+	const parameters = renderParameters(props.method, props.docsInfo, sectionName, props.typeDefinitionByName);
+	const paramString = _.reduce(parameters, (prev: React.ReactNode, curr: React.ReactNode) => {
+		return [prev, ', ', curr];
+	});
+	const methodName = props.shouldHideMethodName ? '' : props.method.name;
+	const typeParameterIfExists = _.isUndefined((props.method as TypescriptMethod).typeParameter)
+		? undefined
+		: renderTypeParameter(props.method, props.docsInfo, sectionName, props.typeDefinitionByName);
+	return (
+		<span>
+			{props.method.callPath}
+			{methodName}
+			{typeParameterIfExists}({paramString})
+			{props.shouldUseArrowSyntax ? ' => ' : ': '}{' '}
+			{props.method.returnType && (
+				<Type
+					type={props.method.returnType}
+					sectionName={sectionName}
+					typeDefinitionByName={props.typeDefinitionByName}
+					docsInfo={props.docsInfo}
+				/>
+			)}
+		</span>
+	);
 };
 
 MethodSignature.defaultProps = defaultProps;
 
 function renderParameters(
-    method: TypescriptMethod | SolidityMethod,
-    docsInfo: DocsInfo,
-    sectionName: string,
-    typeDefinitionByName?: TypeDefinitionByName,
+	method: TypescriptMethod | SolidityMethod,
+	docsInfo: DocsInfo,
+	sectionName: string,
+	typeDefinitionByName?: TypeDefinitionByName,
 ) {
-    const parameters = method.parameters;
-    const params = _.map(parameters, (p: Parameter) => {
-        const isOptional = p.isOptional;
-        const type = (
-            <Type
-                type={p.type}
-                sectionName={sectionName}
-                typeDefinitionByName={typeDefinitionByName}
-                docsInfo={docsInfo}
-            />
-        );
-        return (
-            <span key={`param-${p.type}-${p.name}`}>
-                {p.name}
-                {isOptional && '?'}: {type}
-            </span>
-        );
-    });
-    return params;
+	const parameters = method.parameters;
+	const params = _.map(parameters, (p: Parameter) => {
+		const isOptional = p.isOptional;
+		const type = (
+			<Type
+				type={p.type}
+				sectionName={sectionName}
+				typeDefinitionByName={typeDefinitionByName}
+				docsInfo={docsInfo}
+			/>
+		);
+		return (
+			<span key={`param-${p.type}-${p.name}`}>
+				{p.name}
+				{isOptional && '?'}: {type}
+			</span>
+		);
+	});
+	return params;
 }
 
 function renderTypeParameter(
-    method: TypescriptMethod,
-    docsInfo: DocsInfo,
-    sectionName: string,
-    typeDefinitionByName?: TypeDefinitionByName,
+	method: TypescriptMethod,
+	docsInfo: DocsInfo,
+	sectionName: string,
+	typeDefinitionByName?: TypeDefinitionByName,
 ) {
-    const typeParameter = method.typeParameter;
-    const typeParam = (
-        <span>
-            {`<${typeParameter.name} extends `}
-            <Type
-                type={typeParameter.type}
-                sectionName={sectionName}
-                typeDefinitionByName={typeDefinitionByName}
-                docsInfo={docsInfo}
-            />
-            {`>`}
-        </span>
-    );
-    return typeParam;
+	const typeParameter = method.typeParameter;
+	const typeParam = (
+		<span>
+			{`<${typeParameter.name} extends `}
+			<Type
+				type={typeParameter.type}
+				sectionName={sectionName}
+				typeDefinitionByName={typeDefinitionByName}
+				docsInfo={docsInfo}
+			/>
+			{`>`}
+		</span>
+	);
+	return typeParam;
 }
diff --git a/packages/website/ts/pages/documentation/source_link.tsx b/packages/website/ts/pages/documentation/source_link.tsx
index 6588ee39e..32126b7da 100644
--- a/packages/website/ts/pages/documentation/source_link.tsx
+++ b/packages/website/ts/pages/documentation/source_link.tsx
@@ -4,28 +4,28 @@ import { Source } from 'ts/types';
 import { colors } from 'ts/utils/colors';
 
 interface SourceLinkProps {
-    source: Source;
-    baseUrl: string;
-    version: string;
-    subPackageName: string;
+	source: Source;
+	baseUrl: string;
+	version: string;
+	subPackageName: string;
 }
 
 const packagesWithNamespace = ['connect'];
 
 export function SourceLink(props: SourceLinkProps) {
-    const src = props.source;
-    const url = props.baseUrl;
-    const pkg = props.subPackageName;
-    let tagPrefix = pkg;
-    if (_.includes(packagesWithNamespace, pkg)) {
-        tagPrefix = `@0xproject/${pkg}`;
-    }
-    const sourceCodeUrl = `${url}/blob/${tagPrefix}%40${props.version}/packages/${pkg}/${src.fileName}#L${src.line}`;
-    return (
-        <div className="pt2" style={{ fontSize: 14 }}>
-            <a href={sourceCodeUrl} target="_blank" className="underline" style={{ color: colors.grey }}>
-                Source
-            </a>
-        </div>
-    );
+	const src = props.source;
+	const url = props.baseUrl;
+	const pkg = props.subPackageName;
+	let tagPrefix = pkg;
+	if (_.includes(packagesWithNamespace, pkg)) {
+		tagPrefix = `@0xproject/${pkg}`;
+	}
+	const sourceCodeUrl = `${url}/blob/${tagPrefix}%40${props.version}/packages/${pkg}/${src.fileName}#L${src.line}`;
+	return (
+		<div className="pt2" style={{ fontSize: 14 }}>
+			<a href={sourceCodeUrl} target="_blank" className="underline" style={{ color: colors.grey }}>
+				Source
+			</a>
+		</div>
+	);
 }
diff --git a/packages/website/ts/pages/documentation/type.tsx b/packages/website/ts/pages/documentation/type.tsx
index e989e7129..9a2696e22 100644
--- a/packages/website/ts/pages/documentation/type.tsx
+++ b/packages/website/ts/pages/documentation/type.tsx
@@ -11,202 +11,202 @@ import { utils } from 'ts/utils/utils';
 
 // Some types reference other libraries. For these types, we want to link the user to the relevant documentation.
 const typeToUrl: { [typeName: string]: string } = {
-    Web3: constants.URL_WEB3_DOCS,
-    Provider: constants.URL_WEB3_PROVIDER_DOCS,
-    BigNumber: constants.URL_BIGNUMBERJS_GITHUB,
-    DecodedLogEntryEvent: constants.URL_WEB3_DECODED_LOG_ENTRY_EVENT,
-    LogEntryEvent: constants.URL_WEB3_LOG_ENTRY_EVENT,
+	Web3: constants.URL_WEB3_DOCS,
+	Provider: constants.URL_WEB3_PROVIDER_DOCS,
+	BigNumber: constants.URL_BIGNUMBERJS_GITHUB,
+	DecodedLogEntryEvent: constants.URL_WEB3_DECODED_LOG_ENTRY_EVENT,
+	LogEntryEvent: constants.URL_WEB3_LOG_ENTRY_EVENT,
 };
 
 const typePrefix: { [typeName: string]: string } = {
-    Provider: 'Web3',
-    DecodedLogEntryEvent: 'Web3',
-    LogEntryEvent: 'Web3',
+	Provider: 'Web3',
+	DecodedLogEntryEvent: 'Web3',
+	LogEntryEvent: 'Web3',
 };
 
 const typeToSection: { [typeName: string]: string } = {
-    ExchangeWrapper: 'exchange',
-    TokenWrapper: 'token',
-    TokenRegistryWrapper: 'tokenRegistry',
-    EtherTokenWrapper: 'etherToken',
-    ProxyWrapper: 'proxy',
-    TokenTransferProxyWrapper: 'proxy',
-    OrderStateWatcher: 'orderWatcher',
+	ExchangeWrapper: 'exchange',
+	TokenWrapper: 'token',
+	TokenRegistryWrapper: 'tokenRegistry',
+	EtherTokenWrapper: 'etherToken',
+	ProxyWrapper: 'proxy',
+	TokenTransferProxyWrapper: 'proxy',
+	OrderStateWatcher: 'orderWatcher',
 };
 
 interface TypeProps {
-    type: TypeDef;
-    docsInfo: DocsInfo;
-    sectionName: string;
-    typeDefinitionByName?: TypeDefinitionByName;
+	type: TypeDef;
+	docsInfo: DocsInfo;
+	sectionName: string;
+	typeDefinitionByName?: TypeDefinitionByName;
 }
 
 // The return type needs to be `any` here so that we can recursively define <Type /> components within
 // <Type /> components (e.g when rendering the union type).
 export function Type(props: TypeProps): any {
-    const type = props.type;
-    const isReference = type.typeDocType === TypeDocTypes.Reference;
-    const isArray = type.typeDocType === TypeDocTypes.Array;
-    let typeNameColor = 'inherit';
-    let typeName: string | React.ReactNode;
-    let typeArgs: React.ReactNode[] = [];
-    switch (type.typeDocType) {
-        case TypeDocTypes.Intrinsic:
-        case TypeDocTypes.Unknown:
-            typeName = type.name;
-            typeNameColor = colors.orange;
-            break;
+	const type = props.type;
+	const isReference = type.typeDocType === TypeDocTypes.Reference;
+	const isArray = type.typeDocType === TypeDocTypes.Array;
+	let typeNameColor = 'inherit';
+	let typeName: string | React.ReactNode;
+	let typeArgs: React.ReactNode[] = [];
+	switch (type.typeDocType) {
+		case TypeDocTypes.Intrinsic:
+		case TypeDocTypes.Unknown:
+			typeName = type.name;
+			typeNameColor = colors.orange;
+			break;
 
-        case TypeDocTypes.Reference:
-            typeName = type.name;
-            typeArgs = _.map(type.typeArguments, (arg: TypeDef) => {
-                if (arg.typeDocType === TypeDocTypes.Array) {
-                    const key = `type-${arg.elementType.name}-${arg.elementType.typeDocType}`;
-                    return (
-                        <span>
-                            <Type
-                                key={key}
-                                type={arg.elementType}
-                                sectionName={props.sectionName}
-                                typeDefinitionByName={props.typeDefinitionByName}
-                                docsInfo={props.docsInfo}
-                            />[]
-                        </span>
-                    );
-                } else {
-                    const subType = (
-                        <Type
-                            key={`type-${arg.name}-${arg.value}-${arg.typeDocType}`}
-                            type={arg}
-                            sectionName={props.sectionName}
-                            typeDefinitionByName={props.typeDefinitionByName}
-                            docsInfo={props.docsInfo}
-                        />
-                    );
-                    return subType;
-                }
-            });
-            break;
+		case TypeDocTypes.Reference:
+			typeName = type.name;
+			typeArgs = _.map(type.typeArguments, (arg: TypeDef) => {
+				if (arg.typeDocType === TypeDocTypes.Array) {
+					const key = `type-${arg.elementType.name}-${arg.elementType.typeDocType}`;
+					return (
+						<span>
+							<Type
+								key={key}
+								type={arg.elementType}
+								sectionName={props.sectionName}
+								typeDefinitionByName={props.typeDefinitionByName}
+								docsInfo={props.docsInfo}
+							/>[]
+						</span>
+					);
+				} else {
+					const subType = (
+						<Type
+							key={`type-${arg.name}-${arg.value}-${arg.typeDocType}`}
+							type={arg}
+							sectionName={props.sectionName}
+							typeDefinitionByName={props.typeDefinitionByName}
+							docsInfo={props.docsInfo}
+						/>
+					);
+					return subType;
+				}
+			});
+			break;
 
-        case TypeDocTypes.StringLiteral:
-            typeName = `'${type.value}'`;
-            typeNameColor = colors.green;
-            break;
+		case TypeDocTypes.StringLiteral:
+			typeName = `'${type.value}'`;
+			typeNameColor = colors.green;
+			break;
 
-        case TypeDocTypes.Array:
-            typeName = type.elementType.name;
-            break;
+		case TypeDocTypes.Array:
+			typeName = type.elementType.name;
+			break;
 
-        case TypeDocTypes.Union:
-            const unionTypes = _.map(type.types, t => {
-                return (
-                    <Type
-                        key={`type-${t.name}-${t.value}-${t.typeDocType}`}
-                        type={t}
-                        sectionName={props.sectionName}
-                        typeDefinitionByName={props.typeDefinitionByName}
-                        docsInfo={props.docsInfo}
-                    />
-                );
-            });
-            typeName = _.reduce(unionTypes, (prev: React.ReactNode, curr: React.ReactNode) => {
-                return [prev, '|', curr];
-            });
-            break;
+		case TypeDocTypes.Union:
+			const unionTypes = _.map(type.types, t => {
+				return (
+					<Type
+						key={`type-${t.name}-${t.value}-${t.typeDocType}`}
+						type={t}
+						sectionName={props.sectionName}
+						typeDefinitionByName={props.typeDefinitionByName}
+						docsInfo={props.docsInfo}
+					/>
+				);
+			});
+			typeName = _.reduce(unionTypes, (prev: React.ReactNode, curr: React.ReactNode) => {
+				return [prev, '|', curr];
+			});
+			break;
 
-        case TypeDocTypes.TypeParameter:
-            typeName = type.name;
-            break;
+		case TypeDocTypes.TypeParameter:
+			typeName = type.name;
+			break;
 
-        default:
-            throw utils.spawnSwitchErr('type.typeDocType', type.typeDocType);
-    }
-    // HACK: Normalize BigNumber to simply BigNumber. For some reason the type
-    // name is unpredictably one or the other.
-    if (typeName === 'BigNumber') {
-        typeName = 'BigNumber';
-    }
-    const commaSeparatedTypeArgs = _.reduce(typeArgs, (prev: React.ReactNode, curr: React.ReactNode) => {
-        return [prev, ', ', curr];
-    });
+		default:
+			throw utils.spawnSwitchErr('type.typeDocType', type.typeDocType);
+	}
+	// HACK: Normalize BigNumber to simply BigNumber. For some reason the type
+	// name is unpredictably one or the other.
+	if (typeName === 'BigNumber') {
+		typeName = 'BigNumber';
+	}
+	const commaSeparatedTypeArgs = _.reduce(typeArgs, (prev: React.ReactNode, curr: React.ReactNode) => {
+		return [prev, ', ', curr];
+	});
 
-    const typeNameUrlIfExists = typeToUrl[typeName as string];
-    const typePrefixIfExists = typePrefix[typeName as string];
-    const sectionNameIfExists = typeToSection[typeName as string];
-    if (!_.isUndefined(typeNameUrlIfExists)) {
-        typeName = (
-            <a
-                href={typeNameUrlIfExists}
-                target="_blank"
-                className="text-decoration-none"
-                style={{ color: colors.lightBlueA700 }}
-            >
-                {!_.isUndefined(typePrefixIfExists) ? `${typePrefixIfExists}.` : ''}
-                {typeName}
-            </a>
-        );
-    } else if (
-        (isReference || isArray) &&
-        (props.docsInfo.isPublicType(typeName as string) || !_.isUndefined(sectionNameIfExists))
-    ) {
-        const id = Math.random().toString();
-        const typeDefinitionAnchorId = _.isUndefined(sectionNameIfExists)
-            ? `${props.sectionName}-${typeName}`
-            : sectionNameIfExists;
-        let typeDefinition;
-        if (props.typeDefinitionByName) {
-            typeDefinition = props.typeDefinitionByName[typeName as string];
-        }
-        typeName = (
-            <ScrollLink
-                to={typeDefinitionAnchorId}
-                offset={0}
-                duration={constants.DOCS_SCROLL_DURATION_MS}
-                containerId={constants.DOCS_CONTAINER_ID}
-            >
-                {_.isUndefined(typeDefinition) || utils.isUserOnMobile() ? (
-                    <span
-                        onClick={utils.setUrlHash.bind(null, typeDefinitionAnchorId)}
-                        style={{ color: colors.lightBlueA700, cursor: 'pointer' }}
-                    >
-                        {typeName}
-                    </span>
-                ) : (
-                    <span
-                        data-tip={true}
-                        data-for={id}
-                        onClick={utils.setUrlHash.bind(null, typeDefinitionAnchorId)}
-                        style={{
-                            color: colors.lightBlueA700,
-                            cursor: 'pointer',
-                            display: 'inline-block',
-                        }}
-                    >
-                        {typeName}
-                        <ReactTooltip type="light" effect="solid" id={id} className="typeTooltip">
-                            <TypeDefinition
-                                sectionName={props.sectionName}
-                                customType={typeDefinition}
-                                shouldAddId={false}
-                                docsInfo={props.docsInfo}
-                            />
-                        </ReactTooltip>
-                    </span>
-                )}
-            </ScrollLink>
-        );
-    }
-    return (
-        <span>
-            <span style={{ color: typeNameColor }}>{typeName}</span>
-            {isArray && '[]'}
-            {!_.isEmpty(typeArgs) && (
-                <span>
-                    {'<'}
-                    {commaSeparatedTypeArgs}
-                    {'>'}
-                </span>
-            )}
-        </span>
-    );
+	const typeNameUrlIfExists = typeToUrl[typeName as string];
+	const typePrefixIfExists = typePrefix[typeName as string];
+	const sectionNameIfExists = typeToSection[typeName as string];
+	if (!_.isUndefined(typeNameUrlIfExists)) {
+		typeName = (
+			<a
+				href={typeNameUrlIfExists}
+				target="_blank"
+				className="text-decoration-none"
+				style={{ color: colors.lightBlueA700 }}
+			>
+				{!_.isUndefined(typePrefixIfExists) ? `${typePrefixIfExists}.` : ''}
+				{typeName}
+			</a>
+		);
+	} else if (
+		(isReference || isArray) &&
+		(props.docsInfo.isPublicType(typeName as string) || !_.isUndefined(sectionNameIfExists))
+	) {
+		const id = Math.random().toString();
+		const typeDefinitionAnchorId = _.isUndefined(sectionNameIfExists)
+			? `${props.sectionName}-${typeName}`
+			: sectionNameIfExists;
+		let typeDefinition;
+		if (props.typeDefinitionByName) {
+			typeDefinition = props.typeDefinitionByName[typeName as string];
+		}
+		typeName = (
+			<ScrollLink
+				to={typeDefinitionAnchorId}
+				offset={0}
+				duration={constants.DOCS_SCROLL_DURATION_MS}
+				containerId={constants.DOCS_CONTAINER_ID}
+			>
+				{_.isUndefined(typeDefinition) || utils.isUserOnMobile() ? (
+					<span
+						onClick={utils.setUrlHash.bind(null, typeDefinitionAnchorId)}
+						style={{ color: colors.lightBlueA700, cursor: 'pointer' }}
+					>
+						{typeName}
+					</span>
+				) : (
+					<span
+						data-tip={true}
+						data-for={id}
+						onClick={utils.setUrlHash.bind(null, typeDefinitionAnchorId)}
+						style={{
+							color: colors.lightBlueA700,
+							cursor: 'pointer',
+							display: 'inline-block',
+						}}
+					>
+						{typeName}
+						<ReactTooltip type="light" effect="solid" id={id} className="typeTooltip">
+							<TypeDefinition
+								sectionName={props.sectionName}
+								customType={typeDefinition}
+								shouldAddId={false}
+								docsInfo={props.docsInfo}
+							/>
+						</ReactTooltip>
+					</span>
+				)}
+			</ScrollLink>
+		);
+	}
+	return (
+		<span>
+			<span style={{ color: typeNameColor }}>{typeName}</span>
+			{isArray && '[]'}
+			{!_.isEmpty(typeArgs) && (
+				<span>
+					{'<'}
+					{commaSeparatedTypeArgs}
+					{'>'}
+				</span>
+			)}
+		</span>
+	);
 }
diff --git a/packages/website/ts/pages/documentation/type_definition.tsx b/packages/website/ts/pages/documentation/type_definition.tsx
index d46eec76c..356926157 100644
--- a/packages/website/ts/pages/documentation/type_definition.tsx
+++ b/packages/website/ts/pages/documentation/type_definition.tsx
@@ -13,113 +13,113 @@ import { colors } from 'ts/utils/colors';
 import { utils } from 'ts/utils/utils';
 
 interface TypeDefinitionProps {
-    sectionName: string;
-    customType: CustomType;
-    shouldAddId?: boolean;
-    docsInfo: DocsInfo;
+	sectionName: string;
+	customType: CustomType;
+	shouldAddId?: boolean;
+	docsInfo: DocsInfo;
 }
 
 interface TypeDefinitionState {
-    shouldShowAnchor: boolean;
+	shouldShowAnchor: boolean;
 }
 
 export class TypeDefinition extends React.Component<TypeDefinitionProps, TypeDefinitionState> {
-    public static defaultProps: Partial<TypeDefinitionProps> = {
-        shouldAddId: true,
-    };
-    constructor(props: TypeDefinitionProps) {
-        super(props);
-        this.state = {
-            shouldShowAnchor: false,
-        };
-    }
-    public render() {
-        const customType = this.props.customType;
-        if (!this.props.docsInfo.isPublicType(customType.name)) {
-            return null; // no-op
-        }
+	public static defaultProps: Partial<TypeDefinitionProps> = {
+		shouldAddId: true,
+	};
+	constructor(props: TypeDefinitionProps) {
+		super(props);
+		this.state = {
+			shouldShowAnchor: false,
+		};
+	}
+	public render() {
+		const customType = this.props.customType;
+		if (!this.props.docsInfo.isPublicType(customType.name)) {
+			return null; // no-op
+		}
 
-        let typePrefix: string;
-        let codeSnippet: React.ReactNode;
-        switch (customType.kindString) {
-            case KindString.Interface:
-                typePrefix = 'Interface';
-                codeSnippet = (
-                    <Interface type={customType} sectionName={this.props.sectionName} docsInfo={this.props.docsInfo} />
-                );
-                break;
+		let typePrefix: string;
+		let codeSnippet: React.ReactNode;
+		switch (customType.kindString) {
+			case KindString.Interface:
+				typePrefix = 'Interface';
+				codeSnippet = (
+					<Interface type={customType} sectionName={this.props.sectionName} docsInfo={this.props.docsInfo} />
+				);
+				break;
 
-            case KindString.Variable:
-                typePrefix = 'Enum';
-                codeSnippet = <CustomEnum type={customType} />;
-                break;
+			case KindString.Variable:
+				typePrefix = 'Enum';
+				codeSnippet = <CustomEnum type={customType} />;
+				break;
 
-            case KindString.Enumeration:
-                typePrefix = 'Enum';
-                const enumValues = _.map(customType.children, (c: CustomTypeChild) => {
-                    return {
-                        name: c.name,
-                        defaultValue: c.defaultValue,
-                    };
-                });
-                codeSnippet = <Enum values={enumValues} />;
-                break;
+			case KindString.Enumeration:
+				typePrefix = 'Enum';
+				const enumValues = _.map(customType.children, (c: CustomTypeChild) => {
+					return {
+						name: c.name,
+						defaultValue: c.defaultValue,
+					};
+				});
+				codeSnippet = <Enum values={enumValues} />;
+				break;
 
-            case KindString.TypeAlias:
-                typePrefix = 'Type Alias';
-                codeSnippet = (
-                    <span>
-                        <span style={{ color: colors.lightPurple }}>type</span> {customType.name} ={' '}
-                        {customType.type.typeDocType !== TypeDocTypes.Reflection ? (
-                            <Type
-                                type={customType.type}
-                                sectionName={this.props.sectionName}
-                                docsInfo={this.props.docsInfo}
-                            />
-                        ) : (
-                            <MethodSignature
-                                method={customType.type.method}
-                                sectionName={this.props.sectionName}
-                                shouldHideMethodName={true}
-                                shouldUseArrowSyntax={true}
-                                docsInfo={this.props.docsInfo}
-                            />
-                        )}
-                    </span>
-                );
-                break;
+			case KindString.TypeAlias:
+				typePrefix = 'Type Alias';
+				codeSnippet = (
+					<span>
+						<span style={{ color: colors.lightPurple }}>type</span> {customType.name} ={' '}
+						{customType.type.typeDocType !== TypeDocTypes.Reflection ? (
+							<Type
+								type={customType.type}
+								sectionName={this.props.sectionName}
+								docsInfo={this.props.docsInfo}
+							/>
+						) : (
+							<MethodSignature
+								method={customType.type.method}
+								sectionName={this.props.sectionName}
+								shouldHideMethodName={true}
+								shouldUseArrowSyntax={true}
+								docsInfo={this.props.docsInfo}
+							/>
+						)}
+					</span>
+				);
+				break;
 
-            default:
-                throw utils.spawnSwitchErr('type.kindString', customType.kindString);
-        }
+			default:
+				throw utils.spawnSwitchErr('type.kindString', customType.kindString);
+		}
 
-        const typeDefinitionAnchorId = `${this.props.sectionName}-${customType.name}`;
-        return (
-            <div
-                id={this.props.shouldAddId ? typeDefinitionAnchorId : ''}
-                className="pb2"
-                style={{ overflow: 'hidden', width: '100%' }}
-                onMouseOver={this._setAnchorVisibility.bind(this, true)}
-                onMouseOut={this._setAnchorVisibility.bind(this, false)}
-            >
-                <AnchorTitle
-                    headerSize={HeaderSizes.H3}
-                    title={`${typePrefix} ${customType.name}`}
-                    id={this.props.shouldAddId ? typeDefinitionAnchorId : ''}
-                    shouldShowAnchor={this.state.shouldShowAnchor}
-                />
-                <div style={{ fontSize: 16 }}>
-                    <pre>
-                        <code className="hljs">{codeSnippet}</code>
-                    </pre>
-                </div>
-                {customType.comment && <Comment comment={customType.comment} className="py2" />}
-            </div>
-        );
-    }
-    private _setAnchorVisibility(shouldShowAnchor: boolean) {
-        this.setState({
-            shouldShowAnchor,
-        });
-    }
+		const typeDefinitionAnchorId = `${this.props.sectionName}-${customType.name}`;
+		return (
+			<div
+				id={this.props.shouldAddId ? typeDefinitionAnchorId : ''}
+				className="pb2"
+				style={{ overflow: 'hidden', width: '100%' }}
+				onMouseOver={this._setAnchorVisibility.bind(this, true)}
+				onMouseOut={this._setAnchorVisibility.bind(this, false)}
+			>
+				<AnchorTitle
+					headerSize={HeaderSizes.H3}
+					title={`${typePrefix} ${customType.name}`}
+					id={this.props.shouldAddId ? typeDefinitionAnchorId : ''}
+					shouldShowAnchor={this.state.shouldShowAnchor}
+				/>
+				<div style={{ fontSize: 16 }}>
+					<pre>
+						<code className="hljs">{codeSnippet}</code>
+					</pre>
+				</div>
+				{customType.comment && <Comment comment={customType.comment} className="py2" />}
+			</div>
+		);
+	}
+	private _setAnchorVisibility(shouldShowAnchor: boolean) {
+		this.setState({
+			shouldShowAnchor,
+		});
+	}
 }
-- 
cgit v1.2.3