Add config file specifically in prettier command and fix files

12 files changed, 1062 insertions, 1062 deletions

diff --git a/packages/website/ts/pages/documentation/comment.tsx b/packages/website/ts/pages/documentation/comment.tsx
index 6be39f586..23cfd96bd 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 0006b8d7e..8d50a2f52 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 e1080f3a0..4b1ec122a 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 0fc41d775..2315847ad 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 cfcc7f8d7..7dfdee771 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 9274ae512..0e53e38e7 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 ee07a2c50..16a772125 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 fb03cf5be..dfde5931b 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 7c6bf96d2..041dcd093 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 32126b7da..6588ee39e 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 9a2696e22..e989e7129 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 356926157..d46eec76c 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,
+        });
+    }
 }