diff --git a/.eslintrc b/.eslintrc
index 48848e5..e57cceb 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -73,6 +73,7 @@
                 "no-nested-ternary": 0,
                 "no-unmodified-loop-condition": 0,
                 "no-unused-vars": 1,
+                "no-useless-escape": 0,
                 "object-curly-spacing": [2, "always"],
                 "operator-linebreak": [2, "after"],
                 "quotes": [2, "single"],
@@ -80,6 +81,7 @@
                 "space-before-function-paren": 2,
                 "strict": 0,
                 "eol-last": ["error", "always"],
+                "@typescript-eslint/require-await": 0,
                 "@typescript-eslint/restrict-plus-operands": 0,
                 "@typescript-eslint/restrict-template-expressions": 0,
                 "jsdoc/check-alignment": 1,
diff --git a/package.json b/package.json
index 3549372..2e69797 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "private": true,
-    "version": "0.0.1-dev",
+    "version": "0.0.1-repository",
     "name": "@highcharts/connectors-morningstar",
     "license": "UNLICENSED",
     "description": "Highcharts connectors for Morningstar Direct Web Services",
@@ -42,11 +42,16 @@
         "highcharts": ">=11.4.0"
     },
     "scripts": {
+        "api": "npm run webpack && npm run api:server",
+        "api:server": "(sleep 1 ; open http://localhost:8005) & node bin/connectors-morningstar api",
         "build": "npm run webpack && npm run build:prepare && npm run build:copy && npm run build:pack && npm run build:cleanup",
         "build:cleanup": "rm -rf build/package/",
-        "build:copy": "cp -R bin code/* demos LICENSE.md README.md build/package/ && cp -R docs/connectors/ build/package/docs/ && cp package-build.json build/package/package.json",
+        "build:copy": "npm run copy:code && npm run copy:docs && npm run copy:json",
         "build:pack": "npm pack build/package/ --pack-destination build/",
         "build:prepare": "rm -rf build/ ; mkdir -p build/package/",
+        "copy:code": "cp -R bin code/* demos LICENSE.md README.md build/package/",
+        "copy:docs": "cp -R docs/connectors/ build/package/docs/",
+        "copy:json": "cp package-build.json build/package/package.json",
         "demos": "npm run webpack && npm run demos:server",
         "demos:server": "(sleep 1 ; open http://localhost:8080) & node bin/connectors-morningstar demos",
         "docs": "npm run webpack && npm run docs:server",
@@ -55,8 +60,8 @@
         "husky:pre-commit": "npx lint-staged && npm run webpack",
         "prepare": "rm -rf '.husky/_' ; husky",
         "scripts": "npm run scripts:bin && npm run scripts:code",
-        "scripts:bin": "rm -rf bin/ ; tsc -p src/CLI/ ; chmod +x bin/*.js",
-        "scripts:code": "rm -rf code/ ; tsc -p src/",
+        "scripts:bin": "rm -rf bin/ && tsc -p src/CLI/ && chmod +x bin/*.js && cp -R src/CLI/Static bin/ && ts-node tools/api",
+        "scripts:code": "rm -rf code/ && tsc -p src/",
         "reset": "rm -rf bin/ build/ code/ node_modules/ ; npm i",
         "test": "npm run webpack && npm run test:eslint && npm run test:tests",
         "test:eslint": "eslint .",
@@ -64,7 +69,7 @@
         "test:tests": "ts-node tools/tests",
         "watch": "tsc -p src/ -w",
         "webpack": "npm run scripts && webpack && npm run webpack:dts",
-        "webpack:dts": "npm run webpack:dts:cm && npm run webpack:dts:dbm && npm run webpack:dts:dgm && npm run webpack:dts:hcm",
+        "webpack:dts": "npm run webpack:dts:cm",
         "webpack:dts:cm": "cp src/webpack.d.ts code/connectors-morningstar.d.ts && cp src/webpack.d.ts code/connectors-morningstar.src.d.ts",
         "webpack:dts:dbm": "cp src/webpack.d.ts code/dashboards-morningstar.d.ts && cp src/webpack.d.ts code/dashboards-morningstar.src.d.ts",
         "webpack:dts:dgm": "cp src/webpack.d.ts code/datagrid-morningstar.d.ts && cp src/webpack.d.ts code/datagrid-morningstar.src.d.ts",
diff --git a/src/.eslintrc b/src/.eslintrc
index 36ce5c4..6dc304d 100644
--- a/src/.eslintrc
+++ b/src/.eslintrc
@@ -69,6 +69,7 @@
         "valid-jsdoc": 0,
         "eol-last": ["error", "always"],
         "@typescript-eslint/array-type": 0,
+        "@typescript-eslint/require-await": 0,
         "@typescript-eslint/explicit-function-return-type": 0, // covered by TypeScript
         "@typescript-eslint/indent": [
             "error",
diff --git a/src/CLI/Library/APIServer.ts b/src/CLI/Library/APIServer.ts
new file mode 100644
index 0000000..9e281e7
--- /dev/null
+++ b/src/CLI/Library/APIServer.ts
@@ -0,0 +1,560 @@
+/* *
+ *
+ *  (c) 2009-2024 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *
+ * */
+
+
+/* *
+ *
+ *  Imports
+ *
+ * */
+
+
+import * as FS from 'node:fs/promises';
+import * as FSS from 'node:fs';
+import * as HTTP from 'node:http';
+import * as Marked from 'marked';
+import * as Path from 'node:path';
+import * as PPath from 'node:path/posix';
+
+import APITemplate from './APITemplate';
+import Database from './Database';
+import Server, { MIME_TYPES } from './Server';
+
+
+/* *
+ *
+ *  Declarations
+ *
+ * */
+
+
+export interface Context extends Record<string, unknown> {
+    name: string;
+    node: Option;
+    side: Option;
+    platform: string;
+    productName: string;
+    toc: Record<string, ContextTOCItem>;
+    version?: string;
+    year?: number;
+}
+
+
+export interface ContextTOCItem extends Record<string, unknown> {
+    displayName: string;
+}
+
+
+export interface Nav {
+    children?: Array<Nav>;
+    default?: (boolean|null|number|string);
+    deprecated?: string;
+    description?: string;
+    filename?: string;
+    fullname?: string;
+    isLeaf?: boolean;
+    name?: string;
+    since?: string;
+    typeList?: { names: Array<string> };
+    version?: string;
+}
+
+
+export interface Option {
+    children: Options;
+    doclet: OptionDoclet;
+    meta: OptionMeta;
+}
+
+
+export type Options = Record<string, Option>;
+
+
+export interface OptionDoclet {
+    declare?: string;
+    defaultvalue?: (boolean|null|number|string)
+    deprecated?: string;
+    description?: string;
+    exclude?: Array<string>;
+    extends?: string;
+    productdescs?: Array<Record<string,string>>;
+    requires?: Array<string>;
+    samples?: Array<OptionDocletSample>;
+    see?: Array<string>;
+    since?: string;
+    type?: Record<string,Array<string>>;
+}
+
+
+export interface OptionDocletSample {
+    name: string;
+    value: string;
+    products?: Array<string>;
+}
+
+
+export interface OptionMeta {
+    default?: (boolean|null|number|string);
+    fullname: string;
+    hasChildren?: boolean;
+    name: string;
+}
+
+
+/* *
+ *
+ *  Constants
+ *
+ * */
+
+
+const PATH_ESCAPE = /\.\.?\/|\/\.|\/\//u;
+
+
+const STATIC_PATH = Path.join(__dirname, '..', 'Static');
+
+
+/* *
+ *
+ *  Functions
+ *
+ * */
+
+
+/**
+ * Creates or retrieves an option with the given name path.
+ *
+ * @param tree
+ * Tree root to walk on.
+ *
+ * @param nodePath
+ * Node path to retrieve.
+ *
+ * @return
+ * Created or retrieved option.
+ */
+function treeNode (
+    tree: Options,
+    nodePath: string
+): Option {
+    let node: Option = {
+        doclet: {},
+        meta: {
+            fullname: '',
+            name: ''
+        },
+        children: tree
+    };
+
+    let currentName = '';
+
+    for (const name of nodePath.split('.')) {
+        currentName = (currentName ? `${currentName}.${name}` : name);
+        node = node.children[name] = (
+            node.children[name] ||
+            {
+                doclet: {},
+                meta: {
+                    fullname: currentName,
+                    name
+                },
+                children: {}
+            }
+        );
+    }
+
+    return node;
+}
+
+
+function escape (
+    text: string
+): string {
+    return text.replace(/&/gu, '&amp;').replace(/</gu, '&lt;').replace(/>/gu, '&gt;');
+}
+
+
+async function getContext (
+    database: Database,
+    itemName: string = '',
+    version?: number
+): Promise<Context> {
+    const node = await getOption(database, itemName, version);
+    const side = await getOption(database, itemName, version, true);
+
+    return {
+        constr: 'Morningstar',
+        date: (new Date()).toISOString().substring(0, 19).replace('T', ''),
+        name: itemName,
+        node,
+        side,
+        platform: 'JS',
+        product: {
+            namespace: 'Connectors'
+        },
+        productModule: 'connectors-morningstar',
+        productName: 'Highcharts Connectors',
+        toc: {
+            '': {
+                active: true,
+                displayName: 'Highcharts Connectors for Morningstar'
+            }
+        }
+    } as Context;
+}
+
+
+async function getOption (
+    database: Database,
+    itemName: string = '',
+    version?: number,
+    forNavigation?: boolean
+): Promise<Option> {
+    const root: Option = (
+        forNavigation ?
+            await getOption(database, '', version) :
+            treeNode({}, '')
+    );
+    const option = (
+        itemName ?
+            treeNode(root.children, itemName) :
+            root
+    );
+    const node = await database.getItem(itemName, version);
+
+    if (node) {
+        option.doclet.description =
+            await Marked.parse(jsdoc2Markdown(node.description));
+
+        if (node.deprecated) {
+            option.doclet.deprecated = `${node.deprecated.toFixed(2)}.0`;
+        }
+
+        if (node.doclet) {
+            if (node.doclet.default) {
+                if (forNavigation) {
+                    (option.doclet as Record<string, string>).default =
+                        node.doclet.default.join(',');
+                } else {
+                    option.doclet.defaultvalue = escape(node.doclet.default.join(','));
+                }
+            }
+        }
+
+        if (node.since) {
+            option.doclet.since = `${node.since.toFixed(2)}.0`;
+        }
+    }
+
+    // Add direct children
+
+    let childOption: Option;
+
+    for (const child of await database.getItemChildren(itemName, version)) {
+
+        root.meta.hasChildren = true;
+        childOption = treeNode(root.children, child.name);
+        childOption.doclet.description =
+            await Marked.parse(jsdoc2Markdown(child.description));
+
+        if (child.doclet.type) {
+            childOption.doclet.type = {
+                name: child.doclet.type.map(escape)
+            };
+        }
+
+    }
+
+    return (
+        forNavigation ?
+            root :
+            option
+    );
+}
+
+
+async function getNav (
+    database: Database,
+    itemName: string = '',
+    version?: number
+): Promise<Nav> {
+    itemName = (itemName === 'index' ? '' : itemName);
+
+    const item = await database.getItem(itemName, version);
+    const nav: Nav = (item ? await toNav(item) : {});
+    const navChildren: Array<Nav> = [];
+
+    let navChild: Nav;
+
+    for (const childItem of await database.getItemChildren(itemName, version)) {
+        if (childItem && childItem.name) {
+            navChild = await toNav(childItem);
+            navChild.isLeaf = !await database.hasItemChildren(childItem.name, version);
+            navChildren.push(navChild);
+        }
+    }
+
+    if (navChildren.length) {
+        nav.children = navChildren;
+    }
+
+    return nav;
+}
+
+
+function jsdoc2Markdown (text: string): string {
+    return text
+        .replace(/\{@link\s+(\S*?)\s*\|\s*(.*?)\s*\}/gu, '[$2]($1)')
+        .replace(/\{@link\s+(\S*?)\s*\}/gu, '[link]($1)');
+}
+
+
+async function toNav (
+    item: Database.Item
+): Promise<Nav> {
+    const nav: Nav = {};
+
+    if (item.description) {
+        nav.description = await Marked.parse(jsdoc2Markdown(item.description));
+    }
+
+    if (item.meta.file) {
+        nav.filename = item.meta.file;
+    }
+
+    nav.fullname = item.name;
+    nav.name = item.name.split('.').pop();
+
+    if (item.doclet.type) {
+        if (item.doclet.default) {
+            nav.default = item.doclet.default[item.doclet.default.length - 1];
+        }
+        nav.typeList = { names: item.doclet.type.map(escape) };
+    }
+
+    return nav;
+}
+
+
+/**
+ * Response with a 200
+ *
+ * @param response
+ * HTTP response
+ *
+ * @param data
+ * File data
+ *
+ * @param ext
+ * File extension
+ */
+function response200 (
+    response: HTTP.ServerResponse,
+    data: (string|Buffer),
+    ext: string
+): void {
+    response.writeHead(200, { 'Content-Type': MIME_TYPES[ext] || MIME_TYPES.html });
+    response.end(data);
+}
+
+
+/**
+ * Response with a 404 - not found
+ *
+ * @param response
+ * HTTP response
+ *
+ * @param p
+ * Missing path
+ */
+function response404 (
+    response: HTTP.ServerResponse,
+    p: string
+): void {
+    /* eslint-disable no-console */
+    console.error('404', p);
+
+    response.writeHead(404);
+    response.end('Ooops, the requested file is 404', 'utf-8');
+}
+
+
+/**
+ * Removes path elements that could result in a folder escape.
+ *
+ * @param path
+ * Path to sanitize.
+ *
+ * @return
+ * Sanitized path.
+ */
+function sanitizePath (path: string): string {
+
+    path = (new URL(path, 'http://localhost')).pathname;
+
+    while (PATH_ESCAPE.test(path)) {
+        path = path.replace(PATH_ESCAPE, '');
+    }
+
+    return path;
+}
+
+
+/* *
+ *
+ *  Tasks
+ *
+ * */
+
+
+export class APIServer extends Server {
+
+
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+
+
+    public constructor (
+        folder?: string,
+        defaultFile?: string,
+        baseTitle?: string
+    ) {
+        super(folder, defaultFile, baseTitle);
+
+        this.database = new Database(
+            'connectors-morningstar',
+            Path.join(__dirname, '..', 'Static'),
+            'api'
+        );
+        this.databaseStats = FSS.lstatSync(
+            Path.join(__dirname, '..', 'Static', 'api.json')
+        );
+        this.version = (JSON.parse(
+            FSS.readFileSync(
+                // Path relative to bin folder
+                Path.join(__dirname, '..', '..', 'package.json'),
+                'utf8'
+            )
+        ) as Record<string, string>).version;
+        this.year = this.databaseStats.mtime.getFullYear();
+    }
+
+
+    /* *
+     *
+     *  Properties
+     *
+     * */
+
+
+    private readonly database: Database;
+
+
+    private readonly databaseStats: FSS.Stats;
+
+
+    private readonly version: string;
+
+
+    private readonly year: number;
+
+
+    /* *
+     *
+     *  Functions
+     *
+     * */
+
+
+    public override async handle (
+        request: HTTP.IncomingMessage,
+        response: HTTP.ServerResponse<HTTP.IncomingMessage>
+    ): Promise<void> {
+        const path = sanitizePath(request.url || '').substring(1);
+        console.log(path);
+        if (request.method !== 'GET') {
+            response404(response, path);
+            return;
+        }
+
+        try {
+            let file = PPath.basename(path);
+
+            const ext = PPath.extname(file).substring(1);
+
+            if (ext === 'json') {
+                if (path === 'search.json') {
+                    response200(
+                        response,
+                        JSON.stringify(await this.database.getItemNames()),
+                        'json'
+                    );
+                    return;
+                }
+                if (!path.startsWith('nav/')) {
+                    throw new Error();
+                }
+                file = file.substring(0, file.length - ext.length - 1);
+                response200(
+                    response,
+                    JSON.stringify(await getNav(this.database, file)),
+                    'json'
+                );
+                return;
+            }
+
+            if (path.startsWith('static/')) {
+                response200(
+                    response,
+                    await FS.readFile(
+                        `${STATIC_PATH}/${file}`,
+                        'utf8'
+                    ),
+                    ext
+                );
+                return;
+            }
+
+            const context = await getContext(this.database, path);
+
+            if (!context.node) {
+                throw new Error('Not found');
+            }
+
+            context.version = this.version;
+            context.year = this.year;
+
+            response200(response, APITemplate(context), 'html');
+
+        } catch (error) {
+            console.error('' + error);
+            if (!response.headersSent) {
+                response404(response, path);
+            }
+        }
+    }
+
+}
+
+
+/* *
+ *
+ *  Default Export
+ *
+ * */
+
+
+export default APIServer;
diff --git a/src/CLI/Library/APITemplate.ts b/src/CLI/Library/APITemplate.ts
new file mode 100644
index 0000000..8fadd1a
--- /dev/null
+++ b/src/CLI/Library/APITemplate.ts
@@ -0,0 +1,233 @@
+/* *
+ *
+ *  (c) 2009-2024 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *
+ * */
+
+
+/* *
+ *
+ *  Functions
+ *
+ * */
+
+
+function each (
+    obj: (Array<unknown>|Record<string, unknown>),
+    fn: (key: string, ths: any) => string
+): string {
+    const results = [];
+
+    if (obj) {
+        for (const key of Object.keys(obj)) {
+            results.push(fn(key, (obj as Record<string, unknown>)[key]));
+        }
+    }
+
+    return results.join('');
+}
+
+
+/* *
+ *
+ *  Default Export
+ *
+ * */
+
+
+/* eslint-disable */
+export default (ctx: Record<string, any>) => `<!DOCTYPE html>
+<html>
+    <head>
+
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+
+        <title>${ctx.node.meta.fullname ? ctx.node.meta.fullname + ' | ' : ''}${ctx.productName} ${ctx.platform} API Reference</title>
+
+        <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css" />
+        <link rel="stylesheet" href="/static/style.css" type="text/css" />
+        <script type="text/javascript" src="/static/api.js"></script>
+
+    </head>
+    <body>
+
+        <header class="header">
+            <div class="row row-1">
+                <div id="sidebar-link" class="cell sidebar-link">
+                    <a href="#"><i class="fa fa-bars" aria-hidden="true"></i></a>
+                </div>
+                <div id="highcharts-logo" class="cell">
+                    <a href="https://www.highcharts.com/" title="Highcharts Home Page">
+                        <img alt="Highcharts Home Page" src="https://api.highcharts.com/highcharts/highcharts.svg" border="0">
+                    </a>
+                </div>
+                <div id="page-title" class="cell">
+                    <h1>
+                        <a href="/">
+                            ${ctx.platform} API Reference
+                        </a>
+                    </h1>
+                </div>
+            </div>
+            <div class="row row-2">
+                ${ctx.toc ? `
+                    <div id="product-selector" class="menu" expanded="false">
+                        <a href="#" class="dropdown-link">${ctx.productName} <i class="fa fa-chevron-down" aria-hidden="true"></i></a>
+                        <div class="dropdown-menu">
+                            <ul>
+                                ${each(ctx.toc, (key, ths) => `
+                                <li class="product ${ths.active ? 'highlighted' : ''}">
+                                    <a id="${key}-link" href="${ths.versions?.current ? ths.versions?.current : '#' }">${ths.displayName}</a>
+                                </li>
+                                `)}
+                            </ul>
+                        </div>
+                    </div>
+                    ${ctx.platforms ? `
+                        <div id="platform-selector" class="menu" expanded="false">
+                            <a href="#" class="dropdown-link">${ctx.platform}<i class="fa fa-chevron-down" aria-hidden="true"></i></a>
+                            <div class="dropdown-menu">
+                                <ul class="group-list">
+                                    ${each(ctx.platforms, (key, ths) => `
+                                    <li class="group ${ths.active ? 'highlighted' : ''}">
+                                        <a href="${this}">${key}</a>
+                                    </li>
+                                    `)}
+                                </ul>
+                            </div>
+                        </div>
+                    ` : ''}
+                    ${ctx.version ? `
+                    <div id="version" class="menu">
+                        <a href="https://www.highcharts.com/changelog/" target="_blank">v${ctx.version}</a>
+                    </div>
+                    ` : ''}
+                    ${ctx.includeClassReference ? `
+                        <div id="namespaces" class="menu">
+                            <a href="../class-reference/Highcharts">Namespaces</a>
+                        </div>
+                        <div id="classes" class="menu">
+                            <a href="../class-reference/classes.list">Classes</a>
+                        </div>
+                        <div id="interfaces" class="menu">
+                            <a href="../class-reference/interfaces.list">Interfaces</a>
+                        </div>
+                    ` : ''}
+                ` : ''}
+            </div>
+            </div>
+        </header>
+
+        <div class="wrapper">
+            <div id="sidebar" class="navigation sidebar" expanded="false">
+                <div id="search" class="search-wrapper">
+                    <input type="text" autocapitalize="off" autocomplete="off" autocorrect="off" class="search" dir="auto" placeholder="Search - return for full results" />
+                    <button title="Full results"><i class="fa fa-search"></i></button>
+                    <ul class="results" style="display: none;"></ul>
+                </div>
+                <div id="option-trees-wrapper">
+                    <h3 id="options-header">Configuration options</h3>
+                    <p>For initial declarative connector setup.</p>
+                    <div class="options-tree">
+                        <code>${ctx.product.namespace}.${ctx.constr}({</code>
+                        <div id="options" class="tree">
+                            ${ctx.node.meta.name ? `
+                                <div class="node expanded option-${ctx.node.meta.name} parent">
+                                    <a class="title" href=".">
+                                        ${ctx.node.meta.name}:${ctx.node.children ? '<i class="fa fa-caret-right"></i>' : ''}
+                                    </a>
+                                    ${ctx.node.children ? `
+                                        <span class="bracket start">{</span>
+                                        <div class="children" style="max-height:none;">
+                                    ` : ''}
+                            `: ''}
+                            ${Object.keys(ctx.node.children).length ? `
+                                ${each(ctx.node.children, (_key, ths) => `
+                                    <div class="node collapsed option-${ths.shortName} ${ctx.node.meta.name ? 'leaf' : 'parent'}">
+                                        <a class="title" href="${ths.name}">
+                                            ${ths.shortName}:${ths.children ? '<i class="fa fa-caret-right"></i>' : ''}
+                                        </a>
+                                        ${ths.node?.children ? `
+                                            <span class="bracket start">{</span>
+                                            <span class="dots">...</span>
+                                            <span class="bracket end first">}</span>
+                                        ` : `
+                                            <span class="default type-undefined">${ths.node?.doclet.defaultvalue ? ths.node?.doclet.defaultvalue : 'null'}</span>
+                                        `}
+                                    </div>
+                                `)}
+                            ` : `
+                                <span class="default type-undefined">${ctx.node.doclet.defaultvalue ? ctx.node.doclet.defaultvalue : 'null'}</span>
+                            `}
+                            ${ctx.node.meta.name ? `
+                                    ${ctx.node.children ? `
+                                        </div>
+                                        <span class="bracket end second">}</span>
+                                    ` : ''}
+                                </div>
+                            ` : ''}
+                        </div>
+                        <code>});</code>
+                    </div>
+                </div>
+            </div>
+
+            <div id="body" class="body${ctx.node.meta.fullname ? ' loaded' : ''}">
+                <div id="splashText">
+                    <h1>Welcome to the <strong>${ctx.productName} ${ctx.platform}</strong> (${ctx.productModule}) Options Reference</h1>
+                    <p>These pages outline the chart configuration options, and the methods and properties of ${ctx.product.namespace} objects.</p>
+                    <p>Feel free to search this <a target="_blank" href="https://en.wikipedia.org/wiki/Application_programming_interface">API</a> through the search bar or the navigation tree in the sidebar.</p>
+                </div>
+                <div id="option-list">
+                    ${ctx.node.meta.fullname ? `
+                        <div class="option highlighted">
+                            <h1 class="title">${ctx.node.meta.fullname}</h1>
+                            <p class="description">
+                                <p>${ctx.node.doclet.description}</p>
+                                ${ctx.node.doclet.productdesc ? `
+                                    <p>${ctx.node.doclet.productdesc.value}</p>
+                                ` : ''}
+                            </p>
+                        </div>
+                    ` : ''}
+                </div>
+            </div>
+        </div>
+
+        <div class="footer">
+            <p>Copyright &copy; ${ctx.year}, Highsoft AS. All rights reserved.</p>
+            <div id="footer-social" class="footer-social">
+                <a href="https://www.facebook.com/Highcharts" title="Facebook" class="social-icon"><i class="fa fa-facebook"></i></a>
+                <a href="https://twitter.com/Highcharts" title="Twitter" class="social-icon"><i class="fa fa-twitter"></i></a>
+                <a href="https://www.linkedin.com/company/highsoft-solutions-as" title="LinkedIn" class="social-icon"><i class="fa fa-linkedin"></i></a>
+                <a href="https://github.com/highcharts/connectors-morningstar" title="Github" class="social-icon"><i class="fa fa-github"></i></a>
+            </div>
+
+            <p>
+                ${ctx.productName} v${ctx.version}
+            </p>
+        </div>
+        <script>
+            var state = '${ctx.name}',
+                hasChildren = ${!!ctx.node.meta.hasChildren};
+
+            hapi.createNavigation('#options', '#global-options', state);
+            hapi.createBody('#body', state, hasChildren);
+            hapi.initializeDropdowns('.menu', '.dropdown-link', '.body');
+            hapi.initializeSidebar('.sidebar', '.sidebar-link', '.body');
+            hapi.initializeSearchBar('.search', '#search button', '.results', 'search.json', 2, 20);
+
+        </script>
+
+    </body>
+
+</html>
+`;
diff --git a/src/CLI/Library/Database.ts b/src/CLI/Library/Database.ts
new file mode 100644
index 0000000..06089a0
--- /dev/null
+++ b/src/CLI/Library/Database.ts
@@ -0,0 +1,425 @@
+/* *
+ *
+ *  API Database API Mockup
+ *
+ *  (c) Highsoft AS
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *
+ * */
+
+
+/* *
+ *
+ *  Imports
+ *
+ * */
+
+
+import * as FS from 'node:fs';
+import * as Path from 'node:path';
+
+
+/* *
+ *
+ *  Declarations
+ *
+ * */
+
+
+interface Data {
+    deprecated: Array<(number|undefined)>;
+    description: Array<string>;
+    doclet: Array<string>;
+    meta: Array<string>;
+    name: Array<string>;
+    since: Array<number>;
+}
+
+
+/* *
+ *
+ *  Constant
+ *
+ * */
+
+
+const KEY_ANTI_PATTERN = /[^\w\- ]+/gsu;
+
+
+const SPACE_PATTERN = /\s+/gsu;
+
+
+/// const VALUE_ANTI_PATTERN = /[^\w\-\n\r\\/[\] .:,;?!=+*(){}<>'"`^#$%&@]+/gsu;
+
+
+/* *
+ *
+ *  Functions
+ *
+ * */
+
+
+function getNodeAt (
+    data: Data,
+    index: number,
+    alternativeName?: string
+): Database.Item {
+    return {
+        name: (alternativeName ?? data.name[index]),
+        description: data.description[index],
+        since: data.since[index],
+        deprecated: data.deprecated[index],
+        doclet: JSON.parse(data.doclet[index]) as Database.Doclet,
+        meta: JSON.parse(data.meta[index]) as Database.Meta
+    };
+}
+
+
+function partOfVersion (
+    node: Database.Item,
+    version: number
+): boolean {
+    const majorVersion = Math.floor(version);
+
+    return (
+        // Skip newer options.
+        node.since <= version &&
+        // Include only deprecations from last major version:
+        (
+            !node.deprecated ||
+            node.deprecated >= majorVersion - 1
+        )
+    );
+}
+
+
+function sanitizeKey (
+    key: string
+): string {
+
+    while (key.match(KEY_ANTI_PATTERN)) {
+        key = key.replace(KEY_ANTI_PATTERN, ' ');
+    }
+
+    return key.replace(SPACE_PATTERN, ' ');
+}
+
+
+/**
+ * @todo
+function sanitizeValue (
+    value: string
+): string {
+
+    while (value.match(VALUE_ANTI_PATTERN)) {
+        value = value.replace(VALUE_ANTI_PATTERN, '');
+    }
+
+    return value;
+}
+*/
+
+
+/* *
+ *
+ *  Class
+ *
+ * */
+
+
+export class Database {
+
+
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+
+
+    public constructor (
+        product: string,
+        storageFolder: string = process.cwd(),
+        name: string = 'database'
+    ) {
+        this.namePrefix = `${product}/`;
+        this.product = product;
+        this.storageFolder = storageFolder;
+        this.filePath = Path.join(storageFolder, `${sanitizeKey(name)}.json`);
+    }
+
+
+    /* *
+     *
+     *  Properties
+     *
+     * */
+
+
+    private dataCache?: Data;
+
+
+    public readonly filePath: string;
+
+
+    private readonly namePrefix: string;
+
+
+    public readonly product: string;
+
+
+    private readonly storageFolder: string;
+
+
+    /* *
+     *
+     *  Functions
+     *
+     * */
+
+
+    public async getCount (): Promise<number> {
+        return (await this.getData()).name.length;
+    }
+
+
+    private async getData (): Promise<Data> {
+        const filePath = this.filePath;
+
+        let data = this.dataCache;
+
+        if (data) {
+            return data;
+        }
+
+        if (
+            !FS.existsSync(filePath) ||
+            !FS.lstatSync(filePath).isFile()
+        ) {
+            await this.saveData({
+                deprecated: [],
+                description: [],
+                doclet: [],
+                meta: [],
+                name: [],
+                since: []
+            });
+        }
+
+        data = JSON.parse(FS.readFileSync(filePath, 'utf8')) as Data;
+
+        this.dataCache = data;
+
+        return data;
+    }
+
+
+    public async getItem (
+        itemName: string,
+        version?: number
+    ): Promise<(Database.Item|undefined)> {
+        const data = await this.getData();
+        const nodePath = this.namePrefix + itemName;
+        const index = data.name.indexOf(nodePath);
+
+        if (index === -1) {
+            return void 0;
+        }
+
+        const node = getNodeAt(data, index, itemName);
+
+        if (version && !partOfVersion(node, version)) {
+            return void 0;
+        }
+
+        return node;
+    }
+
+
+    public async getItemChildren (
+        itemName: string,
+        version?: number,
+        all?: boolean
+    ): Promise<Array<Database.Item>> {
+        const children: Array<Database.Item> = [];
+        const data = await this.getData();
+        const nodePath = this.namePrefix + itemName;
+        const indexOffset = nodePath.length + 1;
+        const prefixLength = this.namePrefix.length;
+
+        let index = -1;
+        let node: Database.Item;
+
+        for (const name of data.name) {
+
+            ++index;
+
+            if (
+                !name.startsWith(nodePath) ||
+                name === nodePath ||
+                // Skip children's children
+                (!all && name.indexOf('.', indexOffset) !== -1)
+            ) {
+                continue;
+            }
+
+            node = getNodeAt(data, index, name.substring(prefixLength));
+
+            if (version && !partOfVersion(node, version)) {
+                continue;
+            }
+
+            children.push(node);
+
+        }
+
+        children.sort((a, b) => (
+            a.name === b.name ?
+                0 :
+                a.name < b.name ?
+                    -1 :
+                    1
+        ));
+
+        return children;
+    }
+
+
+    public async getItemNames (): Promise<Array<string>> {
+        const namePrefix = this.namePrefix;
+        const nameIndex = namePrefix.length;
+
+        return (await this.getData())
+            .name
+            .filter(name => name.startsWith(namePrefix))
+            .map(name => name.substring(nameIndex));
+    }
+
+
+    public async hasItemChildren (
+        itemName: string,
+        version?: number
+    ): Promise<boolean> {
+        const data = await this.getData();
+        const nodePath = this.namePrefix + itemName;
+
+        let index = -1;
+
+        for (const name of data.name) {
+
+            ++index;
+
+            if (
+                name.startsWith(nodePath) &&
+                name !== nodePath &&
+                (
+                    !version ||
+                    partOfVersion(getNodeAt(data, index, name), version)
+                )
+            ) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+
+    private async saveData (
+        data: Data
+    ): Promise<Data> {
+        const filePath = this.filePath;
+
+        FS.mkdirSync(Path.dirname(filePath), { recursive: true });
+        FS.writeFileSync(filePath, JSON.stringify(data, void 0, '\t'), 'utf8');
+
+        return data;
+    }
+
+
+    public async setItem (
+        item: Database.Item
+    ): Promise<Database.Item> {
+        const data = await this.getData();
+        const nodePath = this.namePrefix + item.name;
+
+        let index = data.name.indexOf(nodePath);
+
+        if (index === -1) {
+            index = data.name.length;
+        }
+
+        data.doclet[index] = JSON.stringify(item.doclet);
+        data.deprecated[index] = item.deprecated;
+        data.description[index] = item.description;
+        data.meta[index] = JSON.stringify(item.meta);
+        data.name[index] = nodePath;
+        data.since[index] = item.since;
+
+        await this.saveData(data);
+
+        return item;
+    }
+
+
+}
+
+
+/* *
+ *
+ *  Class Namespace
+ *
+ * */
+
+
+export namespace Database {
+
+
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+
+
+    export interface Doclet extends Record<string, unknown> {
+        default?: Array<(boolean|number|string)>;
+        example?: Array<string>;
+        exclude?: Array<string>;
+        extends?: Array<string>;
+        product?: Array<string>;
+        requires?: Array<string>;
+        sample?: Array<string>;
+        see?: Array<string>;
+        type?: Array<string>;
+    }
+
+
+    export interface Meta {
+        file: string;
+    }
+
+
+    export interface Item {
+        name: string;
+        description: string;
+        since: number;
+        deprecated?: number;
+        doclet: Doclet;
+        meta: Meta;
+    }
+
+
+}
+
+
+/* *
+ *
+ *  Default Export
+ *
+ * */
+
+
+export default Database;
diff --git a/src/CLI/Library/Server.ts b/src/CLI/Library/Server.ts
index cdc115f..a37143c 100644
--- a/src/CLI/Library/Server.ts
+++ b/src/CLI/Library/Server.ts
@@ -41,7 +41,7 @@ export const CWD = process.cwd();
 export const DEFAULT_PORT = 8080;
 
 
-export const MIMES: Record<string, string> = {
+export const MIME_TYPES: Record<string, string> = {
     css: 'text/css; charset=utf-8',
     eot: 'application/vnd.ms-fontobject',
     gif: 'image/gif',
@@ -206,7 +206,7 @@ export class Server {
 
         let ext = Path.posix.extname(file).substring(1);
 
-        if (!MIMES[ext]) {
+        if (!MIME_TYPES[ext]) {
             ext = 'html';
             file += '.html';
         }
@@ -249,7 +249,7 @@ export class Server {
 
             response.writeHead(200, {
                 'Access-Control-Allow-Origin': '*',
-                'Content-Type': MIMES[ext]
+                'Content-Type': MIME_TYPES[ext]
             });
             response.end(fileBuffer);
 
diff --git a/src/CLI/Static/api.js b/src/CLI/Static/api.js
new file mode 100644
index 0000000..b35c8fb
--- /dev/null
+++ b/src/CLI/Static/api.js
@@ -0,0 +1,1112 @@
+/* eslint-disable */
+var hapi = {
+    versionLocation: '/versions.json'
+};
+
+var htmlExtension = '';
+var isLocal = window.location.hostname === 'localhost';
+
+hapi.ajax = function (p) {
+    var props = {
+        url: p.url || false,
+        type: p.type || 'GET',
+        dataType: p.dataType || 'json',
+        headers: p.headers || {},
+        success: p.success || function () { },
+        error: p.error || function (error) {
+            console.error(error);
+        }
+    },
+        mime = {
+            json: 'application/json',
+            xml: 'application/xml',
+            text: 'text/plain',
+            octet: 'application/octet-stream'
+        },
+        r = new XMLHttpRequest();
+
+    if (!props.url) return false;
+
+    r.open(props.type, props.url, true);
+
+    if (typeof props.headers['Content-Type'] === 'undefined') {
+        props.headers['Content-Type'] = (
+            mime[props.dataType] ||
+            mime.text
+        );
+    }
+
+    for (var header in props.headers) {
+        r.setRequestHeader(header, props.headers[header]);
+    }
+
+    r.onreadystatechange = function () {
+        if (r.readyState !== 4) {
+            return;
+        }
+        if (r.status === 429) {
+            let retryAfter = parseInt(r.getResponseHeader('Retry-After'));
+            window.setTimeout(hapi.ajax, ((retryAfter || 1) * 1000), p);
+            return;
+        }
+        if (props.dataType === 'json') {
+            var json;
+            try {
+                json = JSON.parse(r.responseText);
+            } catch (e) {
+                props.error(e, r.responseText);
+                return;
+            }
+            props.success(json);
+        } else if (r.status === 200) {
+            props.success(r.responseText);
+        } else {
+            props.error(r.responseURL + ' ' + r.statusText, r.responseText);
+        }
+    };
+
+    r.send(true);
+};
+
+
+
+
+(function () {
+
+    var clearSearch,
+        sidebar;
+
+    function tx(text) {
+        return document.createTextNode(text);
+    }
+
+    function cr(name, props, inner, asHTML) {
+        var el = document.createElement(name);
+        if (props) {
+            if (typeof props === 'object') {
+                for (var attr in props) {
+                    el.setAttribute(attr, props[attr]);
+                }
+            } else {
+                el.setAttribute('class', props);
+            }
+        }
+        el[asHTML ? 'innerHTML' : 'innerText'] = inner || '';
+        return el;
+    }
+
+    function on(target, event, callback, bubble) {
+        if (!target) {
+            return;
+        }
+        if (target.addEventListener) {
+            target.addEventListener(event, callback, (bubble === true));
+        } else {
+            target.attachEvent('on' + event, callback, (bubble === true));
+        }
+    }
+
+    function ap(target) {
+        var children = (Array.prototype.slice.call(arguments));
+        children.splice(0, 1);
+
+        if (target && typeof target.appendChild !== 'undefined') {
+            children.forEach(function (child) {
+                if (typeof child !== 'undefined' && typeof child.appendChild !== 'undefined') {
+                    target.appendChild(child);
+                }
+            });
+        }
+        return target;
+    }
+
+    function addClass(target, cls) {
+        if (target.className.indexOf(cls) < 0) {
+            target.className += ' ' + cls;
+        }
+    }
+
+    function removeClass(target, cls) {
+        if (target.className) {
+            target.className = target.className.replace(' ' + cls, '');
+        }
+    }
+
+    function encodeHTML(html) {
+        return html
+            .replace(/&/g, '&amp;')
+            .replace(/"/g, '&quot;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;');
+    }
+
+    function defined(variable, stringCheck) {
+        var defined = typeof variable !== 'undefined' && variable !== null;
+        if (defined && stringCheck) {
+            defined = variable !== 'undefined' && variable !== 'null';
+        }
+        return defined;
+    }
+
+    function autolinks(s) {
+        return s
+            .replace(/(styled mode)/i, function (match, p1) {
+                return '<a href="https://www.highcharts.com/docs/chart-design-and-style/style-by-css">' + p1 + '</a>';
+            })
+            .replace(
+                /href="#([\w\.]+)"/g,
+                'href="$1' + htmlExtension + '"'
+            );
+    }
+
+    function getDefault(def) {
+        if (
+            typeof def.default === 'boolean' ||
+            typeof def.default === 'number' ||
+            (defined(def.default, true) && def.default.length) ||
+            def.default === null ||
+            typeof def.default !== 'undefined'
+        ) {
+            if (def.default === null) {
+                return 'null';
+            }
+            return encodeHTML(def.default.toString());
+        }
+        return 'undefined';
+    }
+
+    function scrollTo(container, target, duration) {
+        var targetY = target.getBoundingClientRect().top,
+            startingY = window.pageYOffset,
+            diff = targetY - startingY - container.getBoundingClientRect().top,
+            start;
+        function step(timestamp) {
+            if (!start) {
+                start = timestamp;
+            }
+            var time = timestamp - start,
+                percent = Math.min(time / duration, 1);
+
+            window.scrollTo(0, startingY + diff * percent - 100);
+
+            if (time < duration) {
+                window.requestAnimationFrame(step);
+            }
+        };
+        window.requestAnimationFrame(step);
+    }
+
+    function updateTitle(member, product) {
+        return document.title = member + ' | ' + product + ' API Reference';
+    }
+
+    function historyEnabled() {
+        return defined(window.history) && defined(window.history.pushState);
+    }
+
+    function updateHistory(def, product) {
+        var title,
+            currentURL = location.pathname,
+            newURL = '/' + product.toLowerCase() + '/' + def.fullname + htmlExtension;
+        if (currentURL !== newURL) {
+            title = updateTitle(def.fullname, product);
+            if (historyEnabled()) {
+                history.pushState({
+                    product: product,
+                    member: def.fullname,
+                    hasChildren: !def.isLeaf
+                }, title, def.fullname + htmlExtension);
+            }
+        }
+    }
+
+    function buildBody(current, isParent, callback) {
+        hapi.createBody('#body', current, isParent, callback);
+    }
+
+    function highlight(targetClass, containerClass, resetClass) {
+        var container = document.querySelector(containerClass),
+            target = container.querySelector(targetClass),
+            resets = resetClass && document.querySelectorAll(resetClass);
+        if (resets) {
+            // IE does not support forEach on querySelectorAll returns
+            for (var i = 0; i < resets.length; i++) {
+                removeClass(resets[i], 'highlighted');
+            }
+        }
+        if (target) {
+            addClass(target, 'highlighted');
+            scrollTo(container, target, 300);
+        }
+    }
+
+    function toClassName(optionFullName) {
+        return 'option-' + (optionFullName || '').replace(/\./g, '-').replace(/\>/g, '-').replace(/\</g, '-');
+    }
+
+    function createNode(parent, def, state, origState, product) {
+        var isCurrent = def.fullname === origState,
+            optionClass = toClassName(def.fullname),
+            node = cr('div', 'node collapsed ' + optionClass),
+            arrow,
+            title = cr('a', 'title', def.name + ':'),
+            postfix,
+            startBracket,
+            dots,
+            children,
+            endBracket1,
+            endBracket2,
+            expanded = false,
+            hasNext = false;
+
+        title.href = def.fullname + htmlExtension
+
+        node.className += def.isLeaf ? ' leaf' : ' parent';
+
+        if (def.isLeaf) {
+            console.log(def);
+            postfix = cr(
+                'span',
+                'default type-' + (
+                    defined(def.default, true) &&
+                    def.typeList &&
+                    def.typeList.names &&
+                    def.typeList.names[0] ?
+                        def.typeList.names[0]
+                            .toLowerCase()
+                            .replace(/[\.\<\>]+/g, '-') :
+                        'undefined'
+                ),
+                getDefault(def),
+                true
+            );
+
+        } else {
+
+            arrow = cr('i', 'fa fa-caret-right');
+            children = cr('div', 'children');
+            dots = cr('span', 'dots', '...');
+
+            if (def.supportsArray) {
+                startBracket = cr('span', 'bracket start', '[{');
+                endBracket1 = cr('span', 'bracket end first', '}]');
+                endBracket2 = cr('span', 'bracket end second', '}]');
+            } else {
+                startBracket = cr('span', 'bracket start', '{');
+                endBracket1 = cr('span', 'bracket end first', '}');
+                endBracket2 = cr('span', 'bracket end second', '}');
+            }
+
+            if (/^series\.[a-z0-9]+$/.test(def.fullname)) {
+                title.innerHTML = '{ <span class="type-item">type: "' + def.name + '",</span>';
+                startBracket.innerHTML = '';
+                endBracket1.innerHTML = ' }';
+            }
+
+        }
+
+        ap(parent,
+            ap(node,
+                ap(
+                    title,
+                    arrow
+                ),
+                postfix,
+                startBracket,
+                dots,
+                endBracket1,
+                children,
+                endBracket2
+            )
+        );
+
+        function getNext(callback) {
+            hapi.ajax({
+                url: 'nav/' + def.fullname + '.json',
+                dataType: 'json',
+                success: function (data) {
+                    data.children.forEach(function (def) {
+                        createNode(children, def, state, origState, product);
+                    });
+                    hasNext = true;
+
+                    if (callback) {
+                        callback();
+                    }
+                }
+            })
+        }
+
+        function expand() {
+
+            function getChildrenEmHeight(children) {
+                var height = (children.childNodes.length * 1.5) + 0.5;
+
+                function child(childNode) {
+                    var childrenOfChild = childNode.querySelector('.children');
+                    if (childrenOfChild) {
+                        height += getChildrenEmHeight(childrenOfChild);
+                    }
+                };
+
+                // IE does not support forEach on childNodes
+                for (var i = 0; i < children.childNodes.length; i++) {
+                    child(children.childNodes[i]);
+                }
+
+                return height;
+            }
+            function slideDown() {
+                node.className = node.className.replace(
+                    'collapsed',
+                    'expanded'
+                );
+                children.style.maxHeight = getChildrenEmHeight(children) + 'em';
+                setTimeout(
+                    function () {
+                        children.style.maxHeight = 'none';
+                    },
+                    1000 * parseFloat(
+                        getComputedStyle(children)['transitionDuration']
+                    )
+                );
+            }
+
+            if (!def.isLeaf) {
+                if (!hasNext) {
+                    getNext(slideDown);
+                } else {
+                    slideDown();
+                }
+            }
+
+            updateTitle(def.fullname, product);
+
+            expanded = true;
+        }
+
+        function collapse() {
+            node.className = node.className.replace(
+                'expanded',
+                'collapsed'
+            );
+
+            if (children) {
+                children.style.maxHeight = children.clientHeight + 'px';
+            }
+
+            expanded = false;
+
+
+            if (children) {
+                /*setTimeout(
+                  function() {
+        
+                  },
+                  1000 * parseFloat(
+                    getComputedStyle(children)['transitionDuration']
+                  )
+                );*/
+
+                children.style.maxHeight = 0;
+            }
+
+        }
+
+        function toggle(e) {
+            expanded = !expanded;
+            if (expanded) return expand();
+            collapse();
+        }
+
+        function loadNode() {
+            if (dots) {
+                dots.innerHTML = '<i class="fa fa-spinner fa-spin"></i>';
+            }
+            highlight('.node.' + optionClass, '.sidebar', '.node');
+            updateTitle(def.fullname, product);
+            buildBody(def.fullname, !def.isLeaf, function () {
+                if (dots) {
+                    dots.innerHTML = '...';
+                }
+                highlight('.option.' + optionClass, 'body', '.option');
+            });
+        }
+
+        on(title, 'click', function (e) {
+            e.preventDefault();
+            sidebar.setAttribute('expanded', false);
+            loadNode();
+            toggle();
+            updateHistory(def, product);
+        });
+
+        if (state && state.length && state[0] === def.name) {
+            expand();
+            state.shift();
+        }
+        if (isCurrent) {
+            loadNode();
+        }
+    }
+
+    function getClassReferenceUrl(type) {
+        var url = (
+            (/(?:\<|\, )(Highcharts\..+?)[\,\>]/.exec(type) || [])[1] || type
+        );
+        if (url.indexOf('Highcharts.') !== 0) {
+            return;
+        }
+        if (/(?:Array|Dictionary|Function|Options|String|Type|Value)$/.test(url)) {
+            url = url.replace('Highcharts.', 'Highcharts#.');
+        }
+        return '/class-reference/' + url
+            .replace(/\<.*\>/g, '<T>')
+            .replace(/[^\w\.\#]+|\.\</gi, '_');
+    }
+
+    function getRequireList(def, parentDef) {
+        var defRequires = (def.requires || []).slice();
+        if (parentDef && parentDef.requires) {
+            parentDef.requires.forEach(function (req) {
+                if (defRequires.indexOf(req) === -1) {
+                    defRequires.push(req);
+                }
+            });
+        }
+        if (defRequires.length === 0) {
+            return;
+        }
+        requires = cr('div', 'requires');
+        requireList = cr('ul');
+        ap(requires,
+            cr('h4', undefined, 'Requires'),
+            requireList
+        );
+        defRequires.forEach(function (requirement) {
+            ap(requireList,
+                ap(
+                    cr('li'),
+                    cr('a', { href: ('https://code.highcharts.com/' + requirement + '.js') }, requirement)
+                )
+            );
+        });
+        return requires;
+    }
+
+    function getSampleList(def) {
+        var samples,
+            sampleList;
+        if (def.samples) {
+            samples = cr('div', 'samples');
+            sampleList = cr('ul');
+            ap(samples,
+                cr('h4', null, 'Try it'),
+                sampleList
+            );
+            def.samples.forEach(function (sample) {
+                var a = cr('a', null, sample.name),
+                    aLocal;
+                a.href = 'https://jsfiddle.net/gh/get/library/pure/highcharts/highcharts/tree/master/samples/' +
+                    sample.value;
+                a.target = '_blank';
+
+                if (isLocal) {
+                    aLocal = cr('a', null, ' [local]');
+                    aLocal.target = '_blank';
+                    aLocal.href = 'http://utils.highcharts.local/samples/#view/' +
+                        sample.value.replace(/\/$/, '')
+                }
+                ap(sampleList,
+                    ap(cr('li', 'sample'),
+                        a,
+                        aLocal
+                    )
+                );
+            });
+        }
+        return samples;
+    }
+
+    function createOption(target, def, parentDef, state, origState) {
+        var option = cr('div', 'option ' + toClassName(def.fullname)),
+            title = cr('h2', 'title'),
+            titleLink,
+            titleText = cr('span', null, def.name),
+            typeHTML,
+            typeHTMLClass,
+            typeHTMLPath,
+            types,
+            defaultvalue,
+            description,
+            context,
+            extend,
+            inheritedFrom,
+            deprecated,
+            since,
+            samples,
+            see,
+            seeList,
+            editLink,
+            defaultHTML = getDefault(def);
+
+        description = (def.description || '') +
+            (def.productdesc ? def.productdesc.value : '');
+        description = cr('p', 'description', autolinks(description), true);
+
+        if (def.isLeaf) {
+
+            if (def.typeList) {
+                types = cr('span', 'type-list', ': ');
+                def.typeList.names.forEach(function (type, index) {
+                    if (index) {
+                        ap(types, tx(', '));
+                    }
+                    typeHTMLClass = (
+                        'type type-' + type.toLowerCase().replace(/[\.\<\>]+/g, '-')
+                    );
+                    typeHTMLPath = getClassReferenceUrl(type);
+                    if (typeHTMLPath) {
+                        typeHTML = cr('a', { 'class': typeHTMLClass, href: typeHTMLPath }, type);
+                    } else {
+                        typeHTML = cr('span', typeHTMLClass, type);
+                    }
+                    ap(types, typeHTML);
+                });
+            }
+
+            if (typeof defaultHTML !== 'undefined') {
+                defaultvalue = cr(
+                    'span',
+                    'default type-' + (
+                        def.typeList &&
+                        def.typeList.names &&
+                        def.typeList.names[0] ?
+                            def.typeList.names[0]
+                                .toLowerCase()
+                                .replace(/[\.\<\>]+/g, '-') :
+                            'undefined'
+                    ),
+                    'Defaults to <code>' + defaultHTML + '</code>.',
+                    true
+                );
+            }
+
+        } else {
+
+            titleLink = cr('a');
+            titleLink.href = def.fullname + htmlExtension;
+            titleText = ap(titleLink, titleText);
+
+            if (def.typeList) {
+                def.typeList.names.forEach(function (type) {
+                    typeHTMLPath = getClassReferenceUrl(type);
+                    if (typeHTMLPath) {
+                        def.see = (def.see || []);
+                        def.see.push(cr('a', { href: typeHTMLPath }, type));
+                    }
+                });
+            }
+
+        }
+
+        if (def.context) {
+            context = cr('p', 'context', (
+                'Context: <a href="/class-reference/' +
+                (def.context.indexOf('.') === -1 ? 'Highcharts.' : '') + def.context +
+                htmlExtension + '">' + def.context + '</a>.'
+            ), true);
+        }
+        /*
+        if (def.extends) {
+          extend = cr('p', 'extends', 'Extends: ' + def.extends);
+        }
+        */
+
+        if (def.inheritedFrom) {
+            inheritedFrom = cr('p', 'inherited-from', 'Inherited from ' + def.inheritedFrom);
+        }
+
+        if (def.deprecated) {
+            deprecated = cr('p', 'deprecated', 'Deprecated' + (
+                def.deprecated === true ? '' : ' ' + def.deprecated
+            ));
+            option.setAttribute(
+                'class', option.getAttribute('class') + ' deprecated'
+            );
+        }
+        else if (def.since) {
+            since = cr('p', 'since', 'Since ' + def.since);
+        }
+
+        samples = getSampleList(def);
+
+        if (def.see) {
+            see = cr('div', 'see');
+            seeList = cr('ul');
+            ap(see,
+                cr('h4', null, 'See also'),
+                seeList
+            );
+            def.see.forEach(function (seeItem) {
+                if (typeof seeItem === 'object') {
+                    ap(seeList,
+                        ap(cr('li', 'see-item'), seeItem)
+                    );
+                } else {
+                    ap(seeList, cr('li', 'see-item', autolinks(seeItem), true));
+                }
+            });
+        }
+
+        if (def.filename) {
+            var fileName = def.filename;
+            editLink = cr('a', 'edit', '<i class="fa fa-edit"></i>', true);
+            editLink.setAttribute(
+                'title',
+                'Defined in ' + fileName
+            )
+            editLink.href = (
+                'https://github.com/highcharts/connectors-morningstar/blob/' +
+                'main/' +
+                fileName
+            );
+        }
+
+
+        ap(target,
+            ap(option,
+                ap(title,
+                    titleText,
+                    types
+                ),
+                editLink,
+                deprecated,
+                since,
+                description,
+                defaultvalue,
+                context,
+                extend,
+                inheritedFrom,
+                getRequireList(def, parentDef),
+                samples,
+                see
+            )
+        );
+    }
+
+    hapi.createNavigation = function (options, globals, state) {
+        globals = document.querySelector(globals);
+        options = document.querySelector(options);
+
+        function explodeState(state) {
+            state = state.replace(/</g, '.').replace(/>\./g, '.');
+            return state.split('.');
+        }
+
+        function build(data) {
+            if (globals) {
+                globals.innerHTML = '';
+            }
+            options.innerHTML = '';
+            data.children.forEach(function (def) {
+                if (globals && ['global', 'lang'].indexOf(def.fullname) >= 0) {
+                    createNode(globals, def, explodeState(state), state);
+                } else {
+                    createNode(options, def, explodeState(state), state);
+                }
+            });
+        }
+
+        hapi.ajax({
+            url: 'nav/index.json',
+            success: function (data) {
+                build(data);
+            }
+        });
+
+    };
+
+    hapi.createBody = function (target, state, hasChildren, callback) {
+        target = document.querySelector(target);
+
+        if (state.length > 0) {
+            var origState = state;
+            if (!hasChildren) {
+                if (state.indexOf('.') >= 0) {
+                    state = state.substr(0, state.lastIndexOf('.'));
+                } else {
+                    state = 'index';
+                }
+            }
+
+            function build(def) {
+                var optionList = document.getElementById('option-list'),
+                    option = cr('div', 'option option-header ' + toClassName(state)),
+                    title = cr('h1', 'title'),
+                    deprecated,
+                    description = def.description && cr(
+                        'p',
+                        'description',
+                        autolinks(def.description + (def.productdesc ? def.productdesc.value : '')),
+                        true
+                    ),
+                    see,
+                    seeList,
+                    typeHTMLPath;
+
+                if (def.deprecated) {
+                    deprecated = cr('p', 'deprecated', 'Deprecated' + (
+                        def.deprecated === true ? '' : ' ' + def.deprecated
+                    ));
+                    option.setAttribute(
+                        'class', option.getAttribute('class') + ' deprecated'
+                    );
+                }
+
+                state.split('.').forEach(function (titlePart, i) {
+                    ap(title,
+                        cr('span', null, (i > 0 ? '.' : '') + titlePart)
+                    );
+                });
+
+                optionList.innerHTML = '';
+                clearSearch();
+                addClass(target, 'loaded');
+
+                if (def.typeList) {
+                    def.typeList.names.forEach(function (type) {
+                        typeHTMLPath = getClassReferenceUrl(type);
+                        if (hasChildren && typeHTMLPath) {
+                            def.see = (def.see || []);
+                            def.see.push(cr('a', { href: typeHTMLPath }, type));
+                        }
+                    });
+                }
+
+                if (def.see) {
+                    see = cr('div', 'see');
+                    seeList = cr('ul');
+                    ap(see,
+                        cr('h4', null, 'See also:'),
+                        seeList
+                    );
+                    def.see.forEach(function (seeItem) {
+                        if (typeof seeItem === 'object') {
+                            ap(seeList,
+                                ap(cr('li', 'see-item'), seeItem)
+                            );
+                        } else {
+                            ap(seeList, cr('li', 'see-item', autolinks(seeItem), true));
+                        }
+                    });
+                }
+
+                ap(target,
+                    ap(optionList,
+                        ap(option,
+                            title,
+                            deprecated,
+                            description,
+                            getRequireList(def),
+                            getSampleList(def),
+                            see
+                        )
+                    )
+                );
+
+                def.children.forEach(function (def) {
+                    createOption(optionList, def, def, state, origState);
+                });
+                if (typeof callback === 'function') {
+                    callback();
+                }
+            }
+
+            hapi.ajax({
+                url: 'nav/' + state + '.json', //undefined.json
+                success: build
+            });
+        } else {
+            removeClass(target, 'loaded');
+        }
+    };
+
+    hapi.initializeDropdowns = function (dropdownQ, linkQ) {
+        var dropdowns = document.querySelectorAll(dropdownQ);
+
+        function create(dropdown) {
+            var link = dropdown.querySelector(linkQ),
+                expanded = false;
+
+            dropdown.setAttribute('expanded', expanded);
+
+            on(link, 'click', function (e) {
+                e.preventDefault();
+                e.stopPropagation();
+                expanded = !expanded;
+                dropdown.setAttribute('expanded', expanded);
+            });
+
+            on(document, 'click', function (e) {
+                expanded = false;
+                dropdown.setAttribute('expanded', expanded);
+            });
+        }
+
+        // IE does not support foreach on querySelectorAll results
+        for (var i = 0; i < dropdowns.length; i++) {
+            create(dropdowns[i]);
+        }
+
+    };
+
+    hapi.initializeSidebar = function (sidebarQ, linkQ) {
+        var link = document.querySelector(linkQ),
+            expanded = false;
+
+        sidebar = document.querySelector(sidebarQ);
+        sidebar.setAttribute('expanded', expanded);
+
+        on(link, 'click', function (e) {
+            e.preventDefault();
+            e.stopPropagation();
+            expanded = !expanded;
+            sidebar.setAttribute('expanded', expanded);
+        });
+
+        on(sidebar, 'click', function (e) {
+            e.stopPropagation();
+        });
+
+        on(window, 'click', function () {
+            expanded = false;
+            sidebar.setAttribute('expanded', expanded);
+        });
+    };
+
+    hapi.initializeSearchBar = function (
+        searchFieldQ, searchButtonQ, resultsQ, indexUrl, minLength, maxElements
+    ) {
+        var searchField = document.querySelector(searchFieldQ),
+            searchButton = document.querySelector(searchButtonQ),
+            sideResults = indexUrl && resultsQ && document.querySelector(resultsQ),
+            minLength = minLength || 2,
+            maxElements = maxElements || 15,
+            members = [],
+            query = '';
+
+        if (location.pathname.lastIndexOf('/') == (location.pathname.length - 1)) {
+            searchField.focus();
+        }
+
+        function navigateSearch(e) { // listen to keyboard events
+
+            var key = e.keyCode,
+                escape = 27,
+                space = 32,
+                pageUp = 33,
+                pageDown = 34,
+                arrowUp = 38,
+                arrowDown = 40,
+                active = document.activeElement,
+                previous = active.parentNode.previousSibling,
+                next = active.parentNode.nextSibling,
+                first = sideResults.firstChild;
+
+            if (key === space && active === searchField) {
+                key = (e.shiftKey ? pageUp : pageDown);
+            }
+
+            switch (key) {
+                case escape:
+                    e.preventDefault();
+                    clearSearch();
+                    break;
+                case pageUp:
+                case arrowUp:
+                    e.preventDefault();
+                    if (previous && previous.firstChild) {
+                        previous.firstChild.focus();
+                    } else {
+                        searchField.focus();
+                    }
+                    break;
+                case pageDown:
+                case arrowDown:
+                    e.preventDefault();
+                    if (active === searchField && first && first.firstChild) {
+                        first.firstChild.focus();
+                    } else if (next && next.firstChild) {
+                        next.firstChild.focus();
+                    }
+                    break;
+            }
+        }
+
+        function searchSide(e) {
+            if (members.length === 0) {
+                hapi.ajax({
+                    url: indexUrl,
+                    success: function (data) {
+                        members = data;
+                        searchSide();
+                    }
+                });
+                return;
+            }
+            query = searchField.value;
+            if (query.length >= minLength) {
+                showSideResults();
+            }
+        }
+
+        function clearSideResults() {
+            if (!sideResults) {
+                return;
+            }
+            sideResults.innerHTML = '';
+            sideResults.style.display = 'none';
+        }
+
+        function showSideResults() {
+            if (!sideResults) {
+                return;
+            }
+            var a,
+                marker = new RegExp(query, 'gi'),
+                member,
+                queryLC = query.toLowerCase();
+            sideResults.innerHTML = '';
+            for (var i = 0, ie = members.length; i < ie; ++i) {
+                member = members[i];
+                if (member.toLowerCase().indexOf(queryLC) >= 0) {
+                    a = cr('a', null, member.replace(
+                        marker, '<span class="sub-match">$&</span>'
+                    ), true);
+                    a.setAttribute('href', member + htmlExtension);
+                    ap(sideResults, ap(cr('li', 'match'), a));
+                    if (sideResults.childElementCount >= maxElements) {
+                        break;
+                    }
+                }
+            }
+            if (sideResults.hasChildNodes()) {
+                sideResults.style.display = 'block';
+                sideResults.scrollTo(1, 0);
+            } else {
+                sideResults.style.display = 'none';
+            }
+        }
+
+        clearSearch = function () {
+            if (sideResults) {
+                searchField.value = '';
+            }
+            clearSideResults();
+        }
+
+        if (sideResults) {
+            on(searchField.parentNode, 'keydown', navigateSearch, true);
+            on(searchField, 'input', searchSide);
+            on(searchButton, 'click', clearSearch);
+        }
+    };
+
+    /**
+     * Adds simulation of history navigation by detecting changes to the history
+     * state.
+     *
+     * @return [undefined] - nothing
+     */
+    hapi.simulateHistory = function () {
+
+        if (historyEnabled()) {
+            /**
+             * Updates the history with memberClick().
+             *
+             * If it is stored in the history state, the page will be used to
+             * update. If not, the global PAGE variable will be used.
+             *
+             * @param e - the event that triggered the history update
+             */
+            window.onpopstate = function (e) {
+                var state = e.state;
+                if (state !== undefined &&
+                    state !== null &&
+                    typeof state.member !== 'undefined' &&
+                    typeof state.product !== 'undefined'
+                ) {
+                    hapi.createNavigation('#options', '#global-options', state.member, state.product);
+                }
+            }
+        }
+    };
+
+    hapi.populateVersions = function () {
+        var body = document.getElementById('version-selector-body'),
+            vselector = document.getElementById('version-selector')
+            ;
+
+        body.innerHTML = 'Loading..';
+
+        function addGroup(oname) {
+            var gnode = cr('ul', 'group-list'),
+                name
+                ;
+
+            // Make sure the it's capitalized. Could do it with CSS,
+            // but text-transform support is a bit iffy sometimes.
+            name = oname[0].toUpperCase() + oname.substr(1);
+
+            function addChild(version) {
+                var inode = cr('li', 'version'),
+                    link = cr('a', '', version)
+                    ;
+
+                link.href = '/' + oname + '/' + version;
+
+                on(link, 'click', function () {
+                    hapi.switchVersion(this);
+                });
+
+                ap(gnode, ap(inode, link));
+
+                return {
+                    node: inode
+                };
+            }
+
+            ap(body,
+                ap(cr('li', 'group'),
+                    cr('p', '', name),
+                    gnode
+                )
+            );
+
+            return {
+                node: gnode,
+                addChild: addChild
+            };
+        }
+
+        function load(data) {
+            vselector.style.display = '';
+            body.innerHTML = '';
+            Object.keys(data).forEach(function (group) {
+                var groupIns = addGroup(group);
+                data[group].forEach(function (version) {
+                    groupIns.addChild(version);
+                });
+            });
+        }
+
+        vselector.style.display = 'none';
+
+        hapi.ajax({
+            url: hapi.versionLocation,
+            success: load
+        });
+    };
+
+})();
diff --git a/src/CLI/Static/style.css b/src/CLI/Static/style.css
new file mode 100644
index 0000000..cd5496c
--- /dev/null
+++ b/src/CLI/Static/style.css
@@ -0,0 +1,918 @@
+/*
+    Mobile first
+     _________
+    | _______ |
+    ||       ||
+    ||       ||
+    ||       ||
+    ||       ||
+    ||_______||
+    |____O____|
+*/
+
+html,
+body {
+    font-family: sans-serif;
+    height: 100%;
+    margin: 0;
+    padding: 0;
+    width: 100%;
+}
+
+body {
+    background: #f0f0f0;
+    color: #2f2b38;
+}
+
+* {
+    font-family:
+        "IBM Plex Sans",
+        -apple-system,
+        BlinkMacSystemFont,
+        "Segoe UI",
+        Roboto,
+        "Helvetica Neue",
+        Arial,
+        "Noto Sans",
+        "Liberation Sans",
+        sans-serif;
+}
+
+h1 {
+    font-weight: 100;
+}
+
+h2 {
+    font-size: 1.2em;
+}
+
+h3 {
+    text-transform: uppercase;
+    margin-bottom: 3px;
+}
+
+h4 {
+    color: #555;
+    font-style: italic;
+    font-size: 0.9em;
+}
+
+p {
+    margin: 0 0 1em;
+}
+
+a {
+    color: #8085e8;
+    text-decoration: none;
+    font-weight: bold;
+}
+
+code,
+pre {
+    border-radius: 3px;
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+}
+
+code {
+    padding: 0 2px;
+    font-size: 85%;
+    background-color: rgba(27, 31, 35, 0.05);
+}
+
+pre code {
+    background: none;
+}
+
+pre {
+    border: 1px solid #ddd;
+    padding: 5px;
+    overflow-x: auto;
+    background: #eee;
+}
+
+a:hover {
+    color: #90ee7e;
+}
+
+#option-trees-wrapper code {
+    background: none;
+    font-family: "Courier New", Courier, monospace;
+    font-size: 100%;
+}
+
+.header {
+    z-index: 999999;
+    width: 100%;
+    color: #eeeaea;
+    font-size: 14px;
+    position: fixed;
+    top: 0;
+}
+
+.wrapper {
+    background: #fff;
+    margin-top: 84px;
+}
+
+.navigation {
+    background: #fff;
+    height: calc(100vh - 96px);
+    border-right: 1px solid #ccc;
+    margin-top: 84px;
+}
+
+.body {
+    background: #fff;
+    border-left: 1px solid #ccc;
+    min-height: calc(100vh - 96px);
+}
+
+.footer {
+    padding: 10px 0;
+    width: 100%;
+    background: #373648;
+    color: #eeeaea;
+    display: inline-block;
+    text-align: center;
+    font-size: 10px;
+}
+
+.footer p {
+    padding: 0 30px;
+}
+
+.footer-social {
+    font-size: 1.5em;
+    padding-bottom: 10px;
+}
+
+/* Header styling */
+
+.header a {
+    color: #fff;
+    font-weight: inherit;
+}
+
+.header a:hover {
+    color: #a3edba;
+}
+
+.header .row {
+    overflow: hidden;
+}
+
+.header .row-1 {
+    background: #46465c;
+    color: #fff;
+    height: 40px;
+    line-height: 40px;
+    overflow: hidden;
+    padding: 0 10px;
+}
+
+.header .row-1 .cell {
+    display: inline-block;
+    vertical-align: top;
+}
+
+#sidebar-link {
+    float: right;
+}
+
+#sidebar-link a {
+    width: 40px;
+    height: 40px;
+    display: block;
+    text-align: center;
+    margin: 0;
+}
+
+#sidebar-link i {
+    font-size: 24px;
+    line-height: 40px;
+}
+
+#highcharts-logo {
+    line-height: 1em;
+}
+
+#highcharts-logo a {
+    display: inline-block;
+}
+
+#highcharts-logo img {
+    height: 40px;
+    vertical-align: top;
+}
+
+#page-title {
+    float: right;
+    margin-right: 10px;
+}
+
+#page-title h1 {
+    color: #fff;
+    margin: 0;
+    font-size: 18px;
+    font-weight: 400;
+}
+
+.header .row-2 {
+    background: #2f2b38;
+    color: #fff;
+    height: 44px;
+    overflow: hidden;
+}
+
+.header .row-2 .menu {
+    float: left;
+}
+
+.header .row-2 .menu a {
+    display: inline-block;
+    line-height: 2em;
+    padding: 8px 16px;
+}
+
+.dropdown-link {
+    display: inline-block;
+}
+
+.dropdown-link i {
+    font-size: 0.8em;
+    transition: all 0.1s ease;
+    margin-left: 7px;
+}
+
+.dropdown-menu {
+    position: absolute;
+    z-index: 999999999;
+    display: block;
+    width: 33.33%;
+}
+
+.dropdown-menu ul {
+    box-shadow: 0 6px 12px rgba(0, 0, 0, 0.2);
+    display: inline-block;
+    margin: -1px 2px 2px -1px;
+    padding: 5px 0;
+    background: #2f2b38;
+    border: 1px solid rgba(0, 0, 0, 0.2);
+    font-size: 14px;
+    min-width: 100px;
+    text-align: left;
+}
+
+.dropdown-menu li {
+    list-style-type: none;
+}
+
+.dropdown-menu li a {
+    padding: 8px 16px;
+    display: block;
+    line-height: 2em;
+    color: #fff;
+    transition: color 0.1s ease-in-out;
+}
+
+.dropdown-menu li.highlighted a {
+    font-weight: bold;
+    color: #a3edba;
+}
+
+.dropdown-menu li.highlighted a:hover {
+    color: #a3edba;
+}
+
+.dropdown-menu li.highlighted a,
+.dropdown-menu li a:hover {
+    color: #a3edba;
+}
+
+.dropdown-menu li.group p {
+    padding: 8px 16px;
+    display: block;
+    margin: 0;
+}
+
+.dropdown-menu ul.group-list {
+    padding: 0;
+}
+
+.dropdown-menu ul.group-list li a {
+    padding-left: 35px;
+}
+
+.dropdown-menu li:last-child {
+    border-top: 1px solid #000;
+}
+
+.menu[expanded="false"] .dropdown-menu {
+    display: none;
+}
+
+/*
+.menu[expanded="true"] .dropdown-link i {
+  transform: rotate(90deg);
+}
+*/
+
+#prog-lang-selector-list a.unavailable-prog-lang {
+    text-decoration: line-through;
+    cursor: default;
+}
+
+/* Sidebar styling */
+
+.search-wrapper {
+    margin: 30px;
+    border: 1px solid #ddd;
+    position: relative;
+}
+
+.search-wrapper i {
+    margin: 5px;
+    color: #252530;
+    font-size: 14px;
+}
+
+.search-wrapper input {
+    width: calc(100% - 59px);
+    height: 32px;
+    font-family: "Courier New", Courier, monospace;
+    font-size: 0.9em;
+    border: none;
+    outline: none;
+    color: #252530;
+    background: rgba(27, 31, 35, 0.05);
+    padding: 0 10px;
+}
+
+.search-wrapper button {
+    background-color: rgba(27, 31, 35, 0.1);
+    float: right;
+    font-size: 0.9em;
+    font-weight: bold;
+    height: 34px;
+    line-height: 30px;
+    margin: -1px;
+    padding: 0;
+    text-align: center;
+    width: 40px;
+    border: none;
+    border-left: 1px solid #ddd;
+}
+
+.results {
+    position: absolute;
+    list-style: none;
+    background: #fff;
+    border: 2px solid #ddd;
+    z-index: 99;
+    padding: 0;
+    margin: 0 0 0 -2px;
+    display: block;
+    width: 100%;
+    max-height: 254px;
+    overflow: auto;
+}
+
+.results .match {
+    border-bottom: 1px solid #ddd;
+}
+
+.results .match a {
+    display: block;
+    padding: 5px 10px;
+    text-overflow: ellipsis;
+    overflow: hidden;
+}
+
+.results .match a:hover,
+.results .match a:focus {
+    outline: none;
+}
+
+.results .match a:hover {
+    background: #ddd;
+}
+
+.results .match a:focus {
+    background: #bbb;
+}
+
+.results .match *,
+.results .match *:hover {
+    font-family: "Courier New", Courier, monospace;
+    font-size: 14px;
+    color: #222;
+}
+
+.results .match .sub-match {
+    background: #eefdec;
+}
+
+.sidebar {
+    position: fixed;
+    display: block;
+    top: 0;
+    overflow-x: scroll;
+    transition: right 0.2s ease;
+    z-index: 99;
+    width: 100%;
+}
+
+.sidebar[expanded="false"] {
+    right: -100%;
+}
+
+.sidebar[expanded="true"] {
+    right: 0;
+}
+
+/* Navigation styling */
+
+.tree {
+    padding-left: 24px;
+}
+
+.node {
+    position: relative;
+    margin: 0.2em 0;
+}
+
+.node.highlighted > .title {
+    background-color: #eefdec;
+}
+
+.node .title {
+    margin-right: 5px;
+}
+
+.node .title i {
+    position: absolute;
+    left: -12px;
+    top: 0;
+    color: gray;
+}
+
+.node.indicator .title,
+.node.indicator .title i {
+    color: #ccc;
+}
+
+.children {
+    padding-left: 16px;
+    transition: max-height 0.5s ease-in-out;
+    overflow-y: hidden;
+    overflow-x: hidden;
+}
+
+.node.collapsed > .children {
+    max-height: 0;
+}
+
+.node.collapsed > .bracket.end.second {
+    display: none;
+}
+
+.node.expanded > .dots {
+    display: none;
+}
+
+.node.expanded > .bracket.end.first {
+    display: none;
+}
+
+.node .fa-caret-right {
+    transition: all 0.1s ease;
+}
+
+.node.expanded .fa-caret-right {
+    transform: rotate(90deg);
+    transition: transform 0.5s ease-in-out;
+}
+
+.node.collapsed .fa-caret-right {
+    transform: rotate(0deg);
+    transition: transform 0.5s ease-in-out;
+}
+
+#option-trees-wrapper {
+    padding: 5px 5px 5px 30px;
+    margin-bottom: 30px;
+}
+
+#members-wrapper {
+    padding: 5px 5px 5px 30px;
+}
+
+.options-tree,
+.options-tree a,
+.options-tree a span {
+    font-family: "Courier New", Courier, monospace;
+}
+
+.options-tree code {
+    color: #8085e8;
+    font-weight: bold;
+}
+
+.node a.title {
+    color: #252530;
+}
+
+.options-tree .default {
+    color: #ccc;
+    white-space: nowrap;
+    margin: 1px;
+    font-family: "Courier New", Courier, monospace;
+    display: inline-block;
+    vertical-align: middle;
+    max-width: 50%;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.options-tree .default-block {
+    display: block;
+}
+
+.options-tree .default.type-string::before,
+.options-tree .default.type-string::after,
+.options-tree .default.type-highcharts-colorstring::before,
+.options-tree .default.type-highcharts-colorstring::after {
+    content: '"';
+}
+
+.options-tree .default.type-string,
+.options-tree .default.type-array-string-,
+.options-tree .default.type-highcharts-colorstring,
+.options-tree .default.type-array-highcharts-colorstring- {
+    color: #39a832;
+}
+
+.options-tree .default.type-number {
+    color: #297ea8;
+}
+
+.options-tree .default.type-boolean {
+    color: #7e29a8;
+}
+
+/* Body */
+
+.body h1 {
+    font-weight: 100;
+}
+
+#splashText {
+    padding: 30px;
+}
+
+#splashText h1 {
+    text-align: center;
+}
+
+/* Hide when options are visible */
+
+.body.loaded #splashText {
+    display: none;
+}
+
+/* Text search */
+
+#search-text-results {
+    padding: 30px;
+}
+
+#search-text-results .match {
+    padding: 15px 0;
+}
+
+#search-text-results .match h2,
+#search-text-results .match p {
+    margin: 0;
+}
+
+#search-text-results .match p b {
+    background-color: #eefdec;
+}
+
+#search-text-results .close,
+#search-text-results .more {
+    border: 1px solid #ddd;
+    cursor: pointer;
+    display: inline-block;
+    line-height: 2em;
+    padding: 0 1em;
+    text-align: center;
+}
+
+#search-text-results .close:hover,
+#search-text-results .more:hover {
+    background-color: #eee;
+    border-color: #bbb;
+}
+
+#search-text-results .close {
+    float: right;
+}
+
+#search-text-results .options {
+    margin: 2em auto;
+}
+
+/* Option styling */
+
+.option-header h1 {
+    display: inline-block;
+}
+
+.option-header h1 span {
+    font-family: "Courier New", Courier, monospace;
+    float: left;
+}
+
+.option-header,
+.option {
+    padding: 30px;
+    position: relative;
+}
+
+.option {
+    overflow-y: hidden;
+    border-top: 1px solid #cccc;
+}
+
+.option.deprecated * {
+    color: #999 !important;
+}
+
+.option.highlighted {
+    background-color: #eefdec;
+}
+
+.option .title,
+.option .title a,
+.option .returnType {
+    margin-bottom: 5px;
+    display: inline-block;
+}
+
+.option .title span,
+.option .title .type-list,
+.option .title .type-list a {
+    font-family: "Courier New", Courier, monospace;
+}
+
+.option .title .type-list a {
+    text-decoration: none;
+}
+
+.option .title a {
+    text-decoration: underline;
+}
+
+.option .title a.noChildren {
+    text-decoration: none;
+    color: #000;
+    font-weight: bold;
+    font-size: 1em;
+}
+
+.option .default {
+    color: #666;
+}
+
+.option .deprecated {
+    color: #c66 !important;
+    float: right;
+    font-size: 0.8em;
+}
+
+.option .since {
+    float: right;
+    font-size: 0.8em;
+}
+
+.option .edit {
+    float: right;
+    font-size: 0.8em;
+    color: #ccc;
+    padding-left: 0.6em;
+}
+
+.option p {
+    color: #666;
+}
+
+.option .context {
+    padding: 1em 0;
+}
+
+.description code {
+    color: #666;
+    font-weight: normal;
+}
+
+/*
+==============================
+=== Larger tablets / Computers
+==============================
+*/
+
+@media screen and (min-width: 767px) {
+    .wrapper {
+        margin-top: 112px;
+    }
+
+    /* Hide the sidebar-link */
+    #sidebar-link {
+        display: none;
+    }
+
+    .header .row-1 {
+        height: 60px;
+        line-height: 60px;
+        padding: 4px 17px;
+    }
+
+    #highcharts-logo {
+        width: 25%;
+    }
+
+    #highcharts-logo img {
+        height: 60px;
+    }
+
+    #page-title {
+        float: none;
+        margin: 0;
+        text-align: center;
+        width: 50%;
+    }
+
+    /* Make navigation and wrapper share width 30/70 */
+    .navigation,
+    .body {
+        float: left;
+        padding: 0;
+        margin-right: 0;
+        margin-left: -1px;
+
+        /* Couteract border */
+    }
+
+    .navigation {
+        margin-top: 112px;
+        width: 30%;
+    }
+
+    .body {
+        width: 70%;
+        margin-left: calc(30% - 1px);
+    }
+
+    .sidebar[expanded="false"] {
+        left: 0;
+    }
+
+    /* Left-align splash page title */
+    #splashText h1 {
+        text-align: left;
+    }
+
+    .footer {
+        padding-left: 30%;
+        width: 70%;
+    }
+
+    .options-tree {
+        overflow-x: auto;
+    }
+}
+
+@media (prefers-color-scheme: dark) {
+    :root {
+        --dc1: #222;
+        --dc2: #56566c;
+        --dc3: #757580;
+        --dc9: #fff;
+    }
+
+    body,
+    .body,
+    .navigation,
+    .wrapper {
+        background: #36364c;
+        border-color: var(--dc2);
+        color: var(--dc9);
+    }
+
+    h3,
+    h4 {
+        color: #bbb7b7;
+    }
+
+    pre {
+        border-color: var(--dc1);
+        background-color: #111;
+    }
+
+    .search-wrapper {
+        border-color: var(--dc3);
+    }
+
+    .search-wrapper button {
+        background-color: var(--dc3);
+        border-left-color: var(--dc3);
+    }
+
+    .results {
+        background-color: var(--dc2);
+        border-color: var(--dc3);
+        color: var(--dc9);
+    }
+
+    .results .match {
+        border-bottom-color: var(--dc3);
+    }
+
+    .results .match a:hover {
+        background-color: #333;
+    }
+
+    .results .match a:focus {
+        background-color: #444;
+    }
+
+    .results .match *,
+    .results .match *:hover {
+        color: #ddd9d9;
+    }
+
+    .node.highlighted > .title,
+    .results .match .sub-match {
+        background-color: var(--dc3);
+        color: var(--dc9);
+    }
+
+    .node a.title,
+    .search-wrapper input {
+        color: #ccc8c8;
+    }
+
+    .option {
+        border-top-color: var(--dc2);
+    }
+
+    .option p {
+        color: #ccc;
+    }
+
+    .option.deprecated {
+        color: #966 !important;
+    }
+
+    .option.highlighted {
+        background-color: var(--dc2);
+    }
+
+    .options-tree .code {
+        color: #6074e8;
+    }
+
+    .option .default,
+    .options-tree .default {
+        color: #aaa;
+    }
+
+    .options-tree .default.type-string,
+    .options-tree .default.type-array-string-,
+    .options-tree .default.type-highcharts-colorstring,
+    .options-tree .default.type-array-highcharts-colorstring- {
+        color: #49c842;
+    }
+
+    .options-tree .default.type-number {
+        color: #499ec8;
+    }
+
+    .options-tree .default.type-boolean {
+        color: #ce59e8;
+    }
+
+    .description code {
+        color: #aaa;
+    }
+
+    a {
+        color: #b3cafd;
+    }
+
+    a:hover {
+        color: #a3edba;
+        text-decoration: underline;
+    }
+}
diff --git a/src/CLI/connectors-morningstar.ts b/src/CLI/connectors-morningstar.ts
index 5b01ee5..5f953c4 100644
--- a/src/CLI/connectors-morningstar.ts
+++ b/src/CLI/connectors-morningstar.ts
@@ -26,9 +26,11 @@
  * */
 
 
-import Args, { SHORTCUTS as ARGS_SHORTCUTS } from './Library/Args';
 import * as FS from 'node:fs/promises';
 import * as Path from 'node:path';
+
+import Args, { SHORTCUTS as ARGS_SHORTCUTS } from './Library/Args';
+import APIServer from './Library/APIServer';
 import Server, { DEFAULT_PORT } from './Library/Server';
 
 
@@ -44,7 +46,7 @@ npx morningstar-connectors [COMMAND] [OPTIONS]
 
 COMMAND:
 
-    api      Opens API docs in your browser. (not implemented)
+    api      Opens API docs in your browser.
 
     demos    Opens demos in your web browser.
 
@@ -110,9 +112,13 @@ export async function main (): Promise<void> {
     switch (args._) {
 
         case 'api':
-            port = port || 9005;
-            console.info('Not implemented yet. Use VSC for inline API information.');
-            return;
+            port = port || 8005;
+            server = new APIServer(
+                Path.join(__dirname, '..', 'Static'),
+                'TimeSeries',
+                ' | Highcharts API'
+            );
+            break;
 
         case 'demo':
         case 'demos':
diff --git a/src/api.d.ts b/src/api.d.ts
new file mode 100644
index 0000000..bfa5dd9
--- /dev/null
+++ b/src/api.d.ts
@@ -0,0 +1,41 @@
+/* *
+ *
+ *  (c) 2009-2024 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *
+ * */
+
+
+/* *
+ *
+ *  Imports
+ *
+ * */
+
+
+import RNANewsOptions from './RNANews/RNANewsOptions';
+import TimeSeriesOptions from './TimeSeries/TimeSeriesOptions';
+import XRayOptions from './XRay/XRayOptions';
+
+
+/* *
+ *
+ *  API Options
+ *
+ * */
+
+
+/**
+ * Available types of the Highcharts Morningstar Connectors.
+ */
+interface Options {
+    RNANews: RNANewsOptions;
+    TimeSeries: TimeSeriesOptions;
+    XRay: XRayOptions;
+}
diff --git a/tools/api.ts b/tools/api.ts
new file mode 100644
index 0000000..415dc3b
--- /dev/null
+++ b/tools/api.ts
@@ -0,0 +1,374 @@
+/* *
+ *
+ *  Creating API options documentation from TypeScript sources.
+ *
+ *  (c) Highsoft AS
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *
+ * */
+
+
+/* eslint-disable no-console */
+
+
+/* *
+ *
+ *  Imports
+ *
+ * */
+
+
+import * as FS from 'node:fs';
+import * as Path from 'node:path';
+
+import Database from '../src/CLI/Library/Database';
+import TSLib from './libs/TS';
+
+
+/* *
+ *
+ *  Constants
+ *
+ * */
+
+
+const PRODUCT = 'connectors-morningstar';
+
+
+const DATABASE = new Database(PRODUCT, Path.join('bin', 'Static'), 'api');
+
+
+const REFERENCES: Record<string, true> = {};
+
+
+/* *
+ *
+ *  Functions
+ *
+ * */
+
+
+async function addOption (
+    parentItem: (Database.Item|undefined),
+    codeInfo: (TSLib.CodeInfo|undefined),
+    reference: string = ''
+): Promise<(Database.Item|undefined)> {
+
+    if (!codeInfo) {
+        return void 0;
+    }
+
+    const doclet = codeInfo.kind === 'Doclet' ? codeInfo : codeInfo.doclet;
+
+    if (doclet?.tags.internal) {
+        return void 0;
+    }
+
+    let name = (
+        (doclet && TSLib.extractInfoName(doclet)) ??
+        TSLib.extractInfoName(codeInfo)
+    );
+
+    // Skip recursive traps
+
+    reference += [codeInfo.meta.file, codeInfo.meta.scope, name].join(':');
+
+    if (REFERENCES[reference]) {
+        return void 0;
+    }
+
+    REFERENCES[reference] = true;
+
+    // Decorate option name
+
+    if (
+        typeof name === 'string' &&
+        !name.includes('.')
+    ) {
+        if (parentItem?.name) {
+            name = `${parentItem.name}.${name}`
+        } else if (
+            codeInfo.kind === 'Interface' &&
+            name.endsWith('Options')
+        ) {
+            // Create root interface name
+            name = name.substring(0, name.length - 7);
+            if (name) {
+                name = name[0].toLowerCase() + name.substring(1);
+            }
+        }
+    }
+
+    // Walk over code information
+
+    const moreInfos: Array<TSLib.CodeInfo> = [];
+
+    let item: (Database.Item|undefined) = (
+        name &&
+        await DATABASE.getItem(name)
+    ) || {
+        description: '',
+        doclet: {},
+        meta: {
+            file: codeInfo.meta.file
+        },
+        name: (name || ''),
+        since: parentItem?.since || 1
+    };
+    let resolved: (TSLib.CodeInfo|undefined);
+    let value: (TSLib.Value|undefined);
+
+    switch (codeInfo.kind) {
+
+        case 'Class':
+            item = void 0;
+            TSLib.autoExtendInfo(codeInfo);
+            for (const member of codeInfo.members) {
+                if (
+                    member.kind === 'Property' &&
+                    member.flags?.includes('static') &&
+                    TSLib
+                        .extractTypes(member.type || [])
+                        .some(type => type.endsWith('Options'))
+                ) {
+                    return addOption(void 0, member, reference);
+                }
+            }
+            break;
+
+        case 'Doclet':
+            break;
+
+        case 'Export':
+            value = codeInfo.value;
+            return (
+                value && typeof value === 'object' ?
+                    addOption(parentItem, value, reference) :
+                    void 0
+            );
+
+        case 'FunctionCall':
+            item = void 0;
+            if (
+                codeInfo.name === 'merge' &&
+                codeInfo.arguments
+            ) {
+                for (const argument of codeInfo.arguments) {
+                    if (argument && typeof argument === 'object') {
+                        moreInfos.push(argument);
+                    }
+                }
+            }
+            break;
+
+        case 'Interface':
+            item = void 0;
+            if (codeInfo.name.endsWith('Options')) {
+                TSLib.autoExtendInfo(codeInfo);
+                if (doclet && parentItem) {
+                    value = TSLib.extractTagText(doclet, 'description', true);
+                    if (typeof value === 'string') {
+                        parentItem.description = (
+                            parentItem.description ?
+                                `${parentItem.description}\n\n${value}` :
+                                value
+                        );
+                        await DATABASE.setItem(parentItem);
+                    }
+                }
+                moreInfos.push(...codeInfo.members);
+            }
+            break;
+
+        case 'Namespace':
+        case 'Object':
+            item = void 0;
+            for (const member of codeInfo.members) {
+                if (
+                    member.kind === 'Class' ||
+                    member.kind === 'Property' ||
+                    member.kind === 'Variable'
+                ) {
+                    moreInfos.push(member);
+                }
+            }
+            break;
+
+        case 'Property':
+        case 'Variable':
+            if (
+                codeInfo.kind === 'Variable' &&
+                codeInfo.name !== 'defaultOptions'
+            ) {
+                return;
+            }
+            value = codeInfo.value;
+            switch (typeof value) {
+
+                case 'boolean':
+                case 'number':
+                case 'string':
+                    item.doclet.default = (item.doclet.default || []);
+                    item.doclet.default.push(value);
+                    break;
+
+                case 'object':
+                    if (value) {
+                        moreInfos.push(value);
+                    }
+                    break;
+
+            }
+            if (codeInfo.type) {
+                item.doclet.type = TSLib.extractTypes(codeInfo.type);
+                for (const type of item.doclet.type) {
+                    if (type.endsWith('Options')) {
+                        resolved = TSLib.resolveReference(
+                            codeInfo,
+                            type
+                        );
+                        if (resolved) {
+                            moreInfos.push(resolved);
+                        }
+                    }
+                }
+            }
+            if (codeInfo.kind === 'Variable') {
+                item = void 0;
+            }
+            break;
+
+        case 'Reference':
+            resolved = TSLib.resolveReference(
+                TSLib.getSourceInfo(codeInfo.meta.file),
+                codeInfo
+            );
+            return (
+                resolved ?
+                    addOption(parentItem, resolved, reference) :
+                    void 0
+            );
+
+    }
+
+    // Update item with doclet information
+
+    if (item) {
+
+        if (doclet) {
+            for (const tag of Object.keys(doclet.tags)) {
+                switch (tag) {
+
+                    case 'apioption':
+                    case 'optionparent':
+                        {
+                            const name = TSLib.extractTagText(doclet, tag, PRODUCT);
+                            if (name) {
+                                item.name = name;
+                            }
+                        }
+                        break;
+
+                    case 'description':
+                        {
+                            const description = TSLib.extractTagText(doclet, tag, PRODUCT);
+                            if (description) {
+                                item.description = description;
+                            }
+                        }
+                        break;
+
+                    default:
+                        if (tag === 'deprecated' || tag === 'since') {
+                            item[tag] = parseFloat(
+                                TSLib.extractTagText(doclet, tag, PRODUCT) ||
+                                '1.0.0'
+                            );
+                        }
+                        item.doclet[tag] = doclet.tags[tag].slice();
+                        break;
+
+                }
+            }
+        }
+
+        if (item.name) {
+            item = await DATABASE.setItem(item);
+        } else {
+            item = void 0;
+        }
+
+    }
+
+    // Continue with potential sub-items
+
+    if (moreInfos.length) {
+        for (const moreInfo of moreInfos) {
+            await addOption(item || parentItem, moreInfo, reference);
+        }
+    }
+
+    // Done
+
+    if (item) {
+        // console.log('Added', item.name);
+    }
+
+    return item;
+}
+
+
+async function main () {
+
+    // Reset
+
+    if (FS.existsSync(DATABASE.filePath)) {
+        FS.rmSync(DATABASE.filePath, { force: true });
+    }
+
+    // Auto complete foreign declarations
+
+    const sourcePaths = FS
+        .readdirSync('src', { encoding: 'utf8', recursive: true })
+        .map(sourcePath => Path.join('src', sourcePath));
+
+    for (const sourcePath of sourcePaths) {
+        if (FS.lstatSync(sourcePath).isFile()) {
+            TSLib.getSourceInfo(sourcePath);
+        }
+    }
+
+    TSLib.autoCompleteInfos();
+
+    // Save statistic
+
+    let count = await DATABASE.getCount();
+
+    // Load root options
+
+    for (const code of TSLib.getSourceInfo('src/api.d.ts').code) {
+        await addOption(void 0, code);
+    }
+
+    // Done
+
+    count = await DATABASE.getCount() - count;
+
+    console.info('Found', count, 'options.');
+
+}
+
+
+/* *
+ *
+ *  Runtime
+ *
+ * */
+
+
+main()
+    .catch(error => {
+        throw error;
+    });
diff --git a/tools/libs/TS.ts b/tools/libs/TS.ts
new file mode 100644
index 0000000..83e4cc6
--- /dev/null
+++ b/tools/libs/TS.ts
@@ -0,0 +1,3789 @@
+/* *
+ *
+ *  Handles TypeScript API and provides a simplified AST for doclet-relevant
+ *  source nodes.
+ *
+ *  (c) Highsoft AS
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *
+ * */
+
+
+/* eslint-disable
+   func-style,
+   jsdoc/require-param-description, jsdoc/require-description,
+   no-console, no-undef, no-underscore-dangle, no-unused-expressions,
+   no-use-before-define */
+
+
+/* *
+ *
+ *  Imports
+ *
+ * */
+
+
+import * as FS from 'node:fs';
+
+import * as Path from 'node:path';
+
+import * as TS from 'typescript';
+
+
+/* *
+ *
+ *  Declarations
+ *
+ * */
+
+
+export interface ArrayInfo {
+    doclet?: DocletInfo;
+    flags?: Array<InfoFlag>;
+    kind: 'Array';
+    meta: Meta;
+    node?: TS.ArrayLiteralExpression;
+    value: Array<Value>;
+}
+
+
+export interface ClassInfo {
+    doclet?: DocletInfo;
+    extends?: string;
+    flags?: Array<InfoFlag>;
+    generics?: Array<TypeAliasInfo>;
+    implements?: Array<string>;
+    kind: 'Class';
+    members: Array<MemberInfo>;
+    meta: Meta;
+    name: string;
+    node?: TS.ClassDeclaration;
+}
+
+
+export type CodeInfo = (
+    ArrayInfo|ClassInfo|DeconstructInfo|DocletInfo|ExportInfo|FunctionCallInfo|
+    FunctionInfo|ImportInfo|InterfaceInfo|NamespaceInfo|ObjectInfo|PropertyInfo|
+    ReferenceInfo|TypeAliasInfo|VariableInfo
+);
+
+
+export interface DeconstructInfo {
+    deconstructs: Record<string,string>;
+    doclet?: DocletInfo;
+    flags?: Array<InfoFlag>;
+    from?: (FunctionCallInfo|ReferenceInfo)
+    kind: 'Deconstruct';
+    meta: Meta;
+    node?: (TS.ParameterDeclaration|TS.VariableDeclaration);
+    type?: Array<string>;
+}
+
+
+export interface DocletInfo {
+    kind: 'Doclet';
+    meta: Meta;
+    node?: TS.JSDoc;
+    tags: Record<string,Array<string>>;
+}
+
+
+export interface DocletTag {
+    isOptional?: boolean;
+    name?: string;
+    tag: string;
+    text?: string;
+    type?: Array<string>;
+    value?: string;
+}
+
+
+export interface ExportInfo {
+    doclet?: DocletInfo;
+    flags?: Array<InfoFlag>;
+    kind: 'Export';
+    meta: Meta;
+    node?: TS.ExportAssignment;
+    value?: Value;
+}
+
+
+export interface FunctionCallInfo {
+    arguments?: Array<Value>;
+    doclet?: DocletInfo;
+    genericArguments?: Array<string>;
+    kind: 'FunctionCall';
+    meta: Meta;
+    name: string;
+    node?: TS.CallExpression;
+}
+
+
+export interface FunctionInfo {
+    body?: Array<DocletInfo>;
+    doclet?: DocletInfo;
+    flags?: Array<InfoFlag>;
+    generics?: Array<TypeAliasInfo>;
+    inherited?: boolean;
+    kind: 'Function';
+    meta: Meta;
+    name: string;
+    node?: (TS.ConstructorDeclaration|TS.FunctionDeclaration|TS.MethodDeclaration);
+    parameters?: Array<VariableInfo>;
+    return?: Array<string>;
+}
+
+
+export interface ImportInfo {
+    doclet?: DocletInfo;
+    imports: Record<string,string>;
+    kind: 'Import';
+    meta: Meta;
+    node?: TS.ImportDeclaration;
+    from: string;
+}
+
+
+export type InfoFlag = (
+    'async'|'abstract'|'assured'|'await'|'declare'|'default'|'export'|
+    'optional'|'private'|'protected'|'rest'|'static'|'type'
+);
+
+
+export interface InterfaceInfo {
+    doclet?: DocletInfo;
+    flags?: Array<InfoFlag>;
+    generics?: Array<TypeAliasInfo>;
+    implements?: Array<string>;
+    kind: 'Interface';
+    members: Array<MemberInfo>;
+    meta: Meta;
+    name: string;
+    node?: TS.InterfaceDeclaration;
+}
+
+
+export type MemberInfo = (DocletInfo|FunctionInfo|PropertyInfo);
+
+
+export interface Meta {
+    begin: number;
+    end: number;
+    file: string;
+    merged?: boolean;
+    overhead: number;
+    scope?: string;
+    syntax: number;
+}
+
+
+export interface NamespaceInfo {
+    doclet?: DocletInfo;
+    flags?: Array<InfoFlag>;
+    kind: ('Module'|'Namespace');
+    members: Array<CodeInfo>;
+    meta: Meta;
+    name: string;
+    node?: TS.ModuleDeclaration;
+}
+
+
+export interface ObjectInfo {
+    doclet?: DocletInfo;
+    flags?: Array<InfoFlag>;
+    kind: 'Object';
+    members: Array<MemberInfo>;
+    meta: Meta;
+    node?: TS.ObjectLiteralExpression;
+    type?: Array<string>;
+}
+
+
+export interface PropertyInfo {
+    doclet?: DocletInfo;
+    flags?: Array<InfoFlag>;
+    inherited?: boolean;
+    kind: 'Property';
+    meta: Meta;
+    name: string;
+    node?: (
+        | TS.PropertyAssignment
+        | TS.PropertyDeclaration
+        | TS.PropertySignature
+        | TS.ShorthandPropertyAssignment
+    );
+    type?: Array<string>;
+    value?: Value;
+}
+
+
+export interface ReferenceInfo {
+    doclet?: DocletInfo;
+    kind: 'Reference';
+    meta: Meta;
+    name: string;
+    node: (TS.Identifier|TS.ParameterDeclaration|TS.PropertyAccessExpression);
+}
+
+
+export interface SourceInfo {
+    code: Array<CodeInfo>;
+    kind: 'Source';
+    node?: TS.SourceFile;
+    path: string;
+}
+
+
+export interface TypeAliasInfo {
+    doclet?: DocletInfo;
+    kind: 'TypeAlias';
+    generics?: Array<TypeAliasInfo>;
+    meta: Meta;
+    name: string;
+    node?: (TS.TypeAliasDeclaration|TS.TypeParameterDeclaration);
+    value?: Array<string>;
+}
+
+
+export type Value = (
+    boolean|null|number|string|ArrayInfo|FunctionCallInfo|FunctionInfo|
+    ObjectInfo|ReferenceInfo
+);
+
+
+export interface VariableInfo {
+    doclet?: DocletInfo;
+    flags?: Array<InfoFlag>;
+    kind: 'Variable';
+    meta: Meta;
+    name: string;
+    node?: (TS.ParameterDeclaration|TS.TypeParameterDeclaration|TS.VariableDeclaration);
+    type?: Array<string>;
+    value?: Value;
+}
+
+
+/* *
+ *
+ *  Constants
+ *
+ * */
+
+
+const DOCLET = /\/\*\*.*?\*\//gsu;
+
+
+const DOCLET_TAG_INSET = /^\s*\{([^}]+)\}/su;
+
+
+const DOCLET_TAG_NAME = /^(?:\[([a-z][\w\.='"]+)\]|([a-z][\w\.='"]*))/su;
+
+
+const JSX = /\.j(sx?)$/su;
+
+
+const GENERIC = /^[\w\.]*<[\s\w\.\[\],|()]+>$/su;
+
+
+const NATIVE_HELPER = new RegExp(
+    '^(?:' + [
+        'Array', 'Extract', 'Omit', 'Partial', 'Promise', 'Readonly',
+        'ReadonlyArray', 'Record', 'Require'
+    ].join('|') + ')(?:<|$)',
+    'gsu'
+);
+
+
+const NATIVE_TYPES = [
+    'Array',
+    'Function',
+    'NaN',
+    'Number',
+    'Object',
+    'String',
+    'Symbol'
+];
+
+
+/**
+ * Array of product IDs to extract. If empty, everything is included.
+ */
+const PRODUCTS: Array<string> = [];
+
+
+const SANITIZE_TEXT = /^(['"`]?)(.*)\1$/gsu;
+
+
+const SANITIZE_TYPE = /\(\s*(.*)\s*\)/gsu;
+
+
+/**
+ * Dictionary of cached source information. The key starts with the path.
+ * Separated with a colon character (`:`) follows a boolean value indicating the
+ * inclusion of native TypeScript nodes.
+ */
+const SOURCE_CACHE: Record<string,SourceInfo> = {};
+
+
+const SOURCE_EXTENSION = /(?:\.d)?\.[jt]sx?$/gsu;
+
+
+/* *
+ *
+ *  Functions
+ *
+ * */
+
+
+/**
+ * Add child informations and doclets.
+ *
+ * @param infos
+ * Array of code information to add to.
+ *
+ * @param nodes
+ * Child nodes to extract from.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ */
+function addChildInfos (
+    infos: Array<CodeInfo>,
+    nodes: Array<TS.Node>,
+    includeNodes?: boolean
+): void {
+    let _child: (CodeInfo|undefined);
+    let _children: (Array<CodeInfo>|undefined);
+    let _doclet: DocletInfo;
+    let _doclets: Array<DocletInfo>;
+    let _previousNode = nodes[0];
+
+    for (const node of nodes) {
+
+        if (node.kind === TS.SyntaxKind.EndOfFileToken) {
+            break;
+        }
+
+        if (TS.isVariableStatement(node)) {
+            _children = getChildInfos(
+                getNodesChildren(node.declarationList),
+                includeNodes
+            );
+            if (_children.length) {
+                // Take the first one out to attach leading doclet
+                _child = _children.shift();
+            }
+        } else {
+            _child = (
+                getVariableInfo(node, includeNodes) ||
+                getTypeAliasInfo(node, includeNodes) ||
+                getPropertyInfo(node, includeNodes) ||
+                getObjectInfo(node, includeNodes) ||
+                getNamespaceInfo(node, includeNodes) ||
+                getInterfaceInfo(node, includeNodes) ||
+                getImportInfo(node, includeNodes) ||
+                getFunctionInfo(node, includeNodes) ||
+                getFunctionCallInfo(node, includeNodes) ||
+                getExportInfo(node, includeNodes) ||
+                getDeconstructInfos(node, includeNodes) ||
+                getClassInfo(node, includeNodes) ||
+                getArrayInfo(node, includeNodes)
+            );
+        }
+
+        // Retrieve leading doclets
+
+        _doclets = getDocletInfosBetween(_previousNode, node, includeNodes);
+
+        // Deal with floating doclets before leading child doclet
+
+        if (_doclets.length) {
+
+            _doclet = _doclets[_doclets.length - 1];
+
+            // Add trailing doclet to child information
+
+            if (
+                _child &&
+                _child.kind !== 'Doclet' &&
+                _child.kind !== 'Export' &&
+                _child.kind !== 'Import' &&
+                !_doclet.tags.apioption
+            ) {
+                _child.doclet = _doclets.pop();
+            }
+
+            // Add floating doclets
+
+            for (_doclet of _doclets) {
+                if (isProductRelated(_doclet)) {
+                    infos.push(_doclet);
+                }
+            }
+
+        }
+
+        // Finally add child(ren)
+
+        if (_child) {
+            if (isProductRelated(_child.kind === 'Doclet' ? _child : _child.doclet)) {
+                infos.push(_child);
+            }
+            _child = void 0;
+        }
+
+        if (_children) {
+            infos.push(..._children);
+            _children = void 0;
+        }
+
+        _previousNode = node;
+    }
+
+}
+
+
+/**
+ * Adds info flags from the given node.
+ *
+ * @param info
+ * Information to add to.
+ *
+ * @param node
+ * Node to retrieve from.
+ */
+function addInfoFlags (
+    info: CodeInfo,
+    node: TS.Node
+): void {
+
+    switch (info.kind) {
+        case 'Doclet':
+        case 'FunctionCall':
+        case 'Import':
+        case 'Reference':
+        case 'TypeAlias':
+            return;
+    }
+
+    const _flags: Array<InfoFlag> = [];
+
+    if (!TS.canHaveModifiers(node)) {
+        return;
+    }
+
+    for (const _modifier of (TS.getModifiers(node) || [])) {
+        if (!TS.isDecorator(_modifier)) {
+            _flags.push(_modifier.getText() as InfoFlag);
+        }
+    }
+
+    if (
+        (
+            TS.isBindingElement(node) ||
+            TS.isParameterPropertyDeclaration(node, node.parent) ||
+            TS.isTupleTypeNode(node)
+        ) &&
+        node.dotDotDotToken
+    ) {
+        _flags.push('rest');
+    }
+
+    if (
+        TS.isArrayLiteralExpression(node) ||
+        TS.isConstructorDeclaration(node) ||
+        TS.isFunctionDeclaration(node) ||
+        TS.isGetAccessorDeclaration(node) ||
+        TS.isMethodDeclaration(node) ||
+        TS.isPropertyDeclaration(node) ||
+        TS.isSetAccessorDeclaration(node) ||
+        TS.isVariableDeclaration(node)
+    ) {
+        if (node.exclamationToken) {
+            _flags.push('assured');
+        }
+        if (node.questionToken) {
+            _flags.push('optional');
+        }
+    }
+
+    if (TS.isExportAssignment(node)) {
+        _flags.push('default');
+    }
+
+    if (
+        TS.isImportDeclaration(node) &&
+        node.importClause &&
+        node.importClause.isTypeOnly
+    ) {
+        _flags.push('type');
+    }
+
+    if (_flags.length) {
+        info.flags = _flags;
+    }
+
+}
+
+
+/**
+ * Retrieves meta information for a given node.
+ *
+ * @param info
+ * Information to add to.
+ *
+ * @param node
+ * Node to return meta information for.
+ */
+function addInfoMeta (
+    info: CodeInfo,
+    node: TS.Node
+): void {
+    info.meta = {
+        begin: node.getStart(),
+        end: node.getEnd(),
+        file: node.getSourceFile().fileName,
+        overhead: node.getLeadingTriviaWidth(),
+        syntax: node.kind
+    };
+}
+
+
+/**
+ * Adds the scope path to code informations.
+ *
+ * @param parentInfo
+ * Code information with scope path to add.
+ *
+ * @param targetInfos
+ * Code information to add to.
+ */
+function addInfoScopes (
+    parentInfo: (CodeInfo|SourceInfo),
+    targetInfos: Array<CodeInfo|Value>
+): void {
+    const _scopePath = extractInfoScopePath(parentInfo);
+
+    for (const _info of targetInfos) {
+
+        if (
+            !_info ||
+            typeof _info !== 'object' ||
+            _info.kind === 'Doclet' ||
+            _info.kind === 'Export' ||
+            _info.kind === 'Import'
+        ) {
+            continue;
+        }
+
+        if (_scopePath) {
+            _info.meta.scope = _scopePath;
+        }
+
+        switch (_info.kind) {
+
+            case 'Array':
+                if (_info.value) {
+                    addInfoScopes(_info, _info.value);
+                }
+                break;
+
+            case 'Class':
+            case 'Interface':
+                if (_info.generics) {
+                    addInfoScopes(_info, _info.generics);
+                }
+                addInfoScopes(_info, _info.members);
+                break;
+
+
+            case 'Function':
+                if (_info.generics) {
+                    addInfoScopes(_info, _info.generics);
+                }
+                if (_info.parameters) {
+                    addInfoScopes(_info, _info.parameters);
+                }
+                break;
+
+            case 'FunctionCall':
+                if (_info.arguments) {
+                    addInfoScopes(_info, _info.arguments);
+                }
+                if (_info.genericArguments) {
+                    addInfoScopes(_info, _info.genericArguments);
+                }
+                break;
+
+            case 'Module':
+            case 'Namespace':
+            case 'Object':
+                addInfoScopes(_info, _info.members);
+                break;
+
+            case 'Property':
+            case 'Variable':
+                if (typeof _info.value === 'object') {
+                    addInfoScopes(_info, [_info.value]);
+                }
+                break;
+
+            case 'TypeAlias':
+                if (_info.generics) {
+                    addInfoScopes(_info, _info.generics);
+                }
+                break;
+
+            default:
+                break;
+
+        }
+
+    }
+
+}
+
+
+/**
+ * Adds a tag to a DocletInfo object.
+ *
+ * @param doclet
+ * Doclet information to modify.
+ *
+ * @param tag
+ * Tag to add to.
+ *
+ * @param text
+ * Text to add.
+ *
+ * @return
+ * DocletInfo object as reference.
+ */
+function addTag (
+    doclet: DocletInfo,
+    tag: string,
+    text?: string
+): DocletInfo {
+    const tags = doclet.tags;
+
+    tags[tag] = tags[tag] || [];
+
+    if (text) {
+        tags[tag].push(text);
+    }
+
+    return doclet;
+}
+
+
+/**
+ * Complete cached source infos with external additions from DTS files.
+ */
+export function autoCompleteInfos (): void {
+    let _modulePath: string;
+    let _sourceInfo: SourceInfo;
+
+    for (const _key of Object.keys(SOURCE_CACHE)) {
+
+        _sourceInfo = SOURCE_CACHE[_key];
+
+        if (!_sourceInfo) {
+            continue;
+        }
+
+        for (const _info of _sourceInfo.code) {
+            if (
+                _info.kind === 'Module' &&
+                _info.flags?.includes('declare') &&
+                _sourceInfo.path.startsWith('.')
+            ) {
+                _modulePath = sanitizeSourcePath(
+                    Path
+                        .join(_sourceInfo.path, _info.name)
+                        .replace(/\\/gu, '/')
+                );
+
+                const _sourceInfoToMerge =
+                    getSourceInfo(`${_modulePath}.d.ts`, void 0, !!_info.node);
+
+                if (_sourceInfoToMerge) {
+                    mergeCodeInfos(_sourceInfoToMerge, _info);
+                }
+            }
+        }
+
+    }
+
+}
+
+
+/**
+ * Extends ClassInfo and InterfaceInfo with additional inherited members.
+ *
+ * @param infoToExtend
+ * Class or interface information to extend.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ *
+ * @return
+ * Extended class or interface information.
+ */
+export function autoExtendInfo<T extends (ClassInfo|InterfaceInfo)> (
+    infoToExtend: T,
+    includeNodes: boolean = false
+): T {
+    const _extendsToDo: Array<string> = [];
+
+    if (infoToExtend.implements) {
+        const _extendsTypes = (
+            typeof infoToExtend.implements === 'string' ?
+                [infoToExtend.implements] :
+                infoToExtend.implements
+        );
+
+        for (const _extendsType of _extendsTypes) {
+            for (const _extractedType of extractTypes(_extendsType)) {
+                if (!_extendsToDo.includes(_extractedType)) {
+                    _extendsToDo.push(_extractedType);
+                }
+            }
+        }
+
+    }
+
+    let _resolvedInfo: (CodeInfo|undefined);
+
+    for (const _extendType of _extendsToDo) {
+        _resolvedInfo = resolveReference(
+            getSourceInfo(infoToExtend.meta.file, void 0, includeNodes),
+            _extendType
+        );
+
+        if (
+            !_resolvedInfo ||
+            (
+                _resolvedInfo.kind !== 'Class' &&
+                _resolvedInfo.kind !== 'Namespace' &&
+                _resolvedInfo.kind !== 'Interface'
+            )
+        ) {
+            continue;
+        }
+
+        // First complete the parent
+        if (
+            _resolvedInfo.kind === 'Class' ||
+            _resolvedInfo.kind === 'Interface'
+        ) {
+            _resolvedInfo = autoExtendInfo(_resolvedInfo, includeNodes);
+        }
+
+        for (const _member of _resolvedInfo.members) {
+            const _name = extractInfoName(_member);
+
+            // Check if already defined in target
+            if (
+                !_name ||
+                _member.kind !== 'Property' ||
+                extractInfos(infoToExtend.members, _name)
+            ) {
+                continue;
+            }
+
+            const _newMember = newCodeInfo(_member);
+
+            _newMember.meta.merged = true;
+
+            infoToExtend.members.push(_newMember);
+
+        }
+
+    }
+
+    return infoToExtend;
+}
+
+
+/**
+ * Shifts ranges in the source code with replacements.
+ *
+ * @param sourceCode
+ * Source code to change.
+ *
+ * @param replacements
+ * Replacements to apply.
+ *
+ * @return
+ * Changed source code.
+ */
+function changeSourceCode (
+    sourceCode: string,
+    replacements: Array<[number,number,string]>
+): string {
+
+    if (
+        !replacements ||
+        !replacements.length
+    ) {
+        return sourceCode;
+    }
+
+    for (const replacement of replacements.sort((a, b) => b[0] - a[0])) {
+        sourceCode = (
+            sourceCode.substring(0, replacement[0]) +
+            replacement[2] +
+            sourceCode.substring(replacement[1])
+        );
+    }
+
+    return sourceCode;
+}
+
+
+/**
+ * [TS] Shifts ranges in the source node with replacements.
+ *
+ * @param sourceNode
+ * Source file to change.
+ *
+ * @param replacements
+ * Replacements to apply.
+ *
+ * @return
+ * New source node with changes.
+ */
+export function changeSourceNode (
+    sourceNode: TS.SourceFile,
+    replacements: Array<[number,number,string]>
+): TS.SourceFile {
+
+    if (
+        !replacements ||
+        !replacements.length
+    ) {
+        return sourceNode;
+    }
+
+    return TS.createSourceFile(
+        sourceNode.fileName,
+        changeSourceCode(sourceNode.getFullText(), replacements),
+        TS.ScriptTarget.ESNext,
+        true
+    );
+}
+
+
+/**
+ * [TS] Logs debug information for a node and its children into the console.
+ *
+ * @param node
+ * Node to debug.
+ *
+ * @param depth
+ * Level of debug depth regarding children.
+ *
+ * @param indent
+ * Internal parameter.
+ */
+export function debug (
+    node: TS.Node,
+    depth: number = 0,
+    indent: string = ''
+): void {
+
+    if (!node) {
+        console.info(indent + 0, 'undefined', '[-:-]');
+        return;
+    }
+
+    console.info(
+        indent + node.kind,
+        TS.SyntaxKind[node.kind],
+        `[${node.getFullStart()}:${node.getEnd()}]`
+    );
+
+    if (depth-- > 0) {
+        indent += '  ';
+        for (const child of getNodesChildren(node)) {
+            debug(child, depth, indent);
+        }
+    }
+
+}
+
+
+/**
+ * Extracts the arguments of the generic name or type.
+ *
+ * @param nameOrTypeString
+ * Name or type to extract from.
+ *
+ * @return
+ * Extracted generic arguments.
+ */
+export function extractGenericArguments (
+    nameOrTypeString: string
+): Array<string>|undefined {
+
+    if (!nameOrTypeString.match(GENERIC)) {
+        return void 0;
+    }
+
+    const types: Array<string> = [];
+
+    let sublevel = 0;
+
+    for (let part of nameOrTypeString.split(',')) {
+
+        part = part.trim();
+
+        if (sublevel) {
+            types.push(`${types.pop()},${part}`);
+        } else {
+            types.push(part);
+        }
+
+        if (part.includes('<')) {
+            ++sublevel;
+        }
+        if (part.includes('>')) {
+            --sublevel;
+        }
+
+    }
+
+    return types;
+}
+
+
+/**
+ * Extracts the entity name from the given code information.
+ *
+ * @param codeInfo
+ * Code information to extract from.
+ *
+ * @return
+ * Extracted name or `undefined`.
+ */
+export function extractInfoName (
+    codeInfo: (CodeInfo|SourceInfo)
+): (string|undefined) {
+    let _name: (string|undefined);
+
+    switch (codeInfo.kind) {
+        case 'Class':
+        case 'Function':
+        case 'Interface':
+        case 'Module':
+        case 'Namespace':
+        case 'Property':
+        case 'TypeAlias':
+        case 'Variable':
+            return codeInfo.name;
+        case 'Doclet':
+            _name = extractTagText(codeInfo, 'optionparent', true);
+            if (typeof _name === 'string') {
+                return _name;
+            }
+            return (
+                extractTagText(codeInfo, 'apioption', true) ||
+                extractTagText(codeInfo, 'function', true) ||
+                extractTagText(codeInfo, 'name', true)
+            );
+        case 'Source':
+            return codeInfo.path;
+        default:
+            return void 0;
+    }
+}
+
+
+/**
+ * Extracts information from an array of CodeInfo types.
+ *
+ * @param arr
+ * Array of informations to extract from.
+ *
+ * @param name
+ * Name of information to extract.
+ *
+ * @return
+ * Extracted information or `undefined`.
+ */
+function extractInfos (
+    arr: Array<CodeInfo>,
+    name: string
+): (Array<CodeInfo>|undefined) {
+
+    if (typeof name !== 'string') {
+        return void 0;
+    }
+
+    const extractions: Array<CodeInfo> = [];
+
+    for (const info of arr) {
+        switch (info.kind) {
+            case 'Class':
+            case 'Function':
+            case 'Interface':
+            case 'Module':
+            case 'Namespace':
+            case 'Property':
+            case 'Variable':
+                if (info.name === name) {
+                    extractions.push(info);
+                }
+                continue;
+            default:
+                continue;
+        }
+    }
+
+    return (
+        extractions.length ?
+            extractions :
+            void 0
+    );
+}
+
+
+/**
+ * Extracts scope path for the given code information.
+ *
+ * @param info
+ * Information to extract from.
+ *
+ * @return
+ * Scope path or `undefined`.
+ */
+function extractInfoScopePath (
+    info: (CodeInfo|SourceInfo)
+): (string|undefined) {
+
+    switch (info.kind) {
+
+        case 'Array':
+        case 'Deconstruct':
+        case 'Object':
+            return info.meta.scope;
+
+        case 'Class':
+        case 'Function':
+        case 'FunctionCall':
+        case 'Interface':
+        case 'Namespace':
+        case 'Property':
+        case 'Reference':
+        case 'TypeAlias':
+        case 'Variable':
+            return (
+                info.meta.scope ?
+                    `${info.meta.scope}.${info.name}` :
+                    info.name
+            );
+
+        default:
+            return void 0;
+
+    }
+
+}
+
+
+/**
+ * Retrieves the leading curly bracket inset from the given tag text.
+ *
+ * @param text
+ * Tag text to get insets from.
+ *
+ * @return
+ * Inset from curly bracket or `undefined`.
+ */
+function extractTagInset (
+    text: string
+): string {
+    return (text.match(DOCLET_TAG_INSET) || [])[1];
+}
+
+
+/**
+ * Retrieves all information for the specified tag from a DocletInfo object.
+ *
+ * @param doclet
+ * Doclet information to retrieve from.
+ *
+ * @param tag
+ * Tag to retrieve.
+ *
+ * @return
+ * Retrieved tag informations.
+ */
+export function extractTagObjects (
+    doclet: DocletInfo,
+    tag: string
+): Array<DocletTag> {
+    const _objects: Array<DocletTag> = [];
+
+    let _inset: (string|undefined);
+    let _match: (RegExpMatchArray|null);
+    let _object: DocletTag;
+
+    for (let _text of (doclet.tags[tag] || [])) {
+        _object = { tag };
+        _inset = extractTagInset(_text);
+
+        if (_inset) {
+            _object.type = [_inset];
+            _text = _text
+                .substring(_text.indexOf(`{${_inset}}` + _inset.length + 2))
+                .trimStart();
+        }
+
+        switch (tag) {
+
+            default:
+                break;
+
+            case 'param':
+            case 'return':
+            case 'returns':
+                _match = _text.match(DOCLET_TAG_NAME);
+                if (_match) {
+                    if (_match[1]) {
+                        _object.isOptional = true;
+                        _object.name = _match[1];
+                    } else {
+                        _object.name = _match[2];
+                    }
+                    if (_object.name.includes('=')) {
+                        _object.value = _object.name.split('=', 2)[1];
+                        _object.name = _object.name.split('=', 2)[0];
+                    }
+                    _text = _text.substring(_match[0].length).trimStart();
+                }
+                break;
+
+            case 'sample':
+            case 'samples':
+                _match = _text.match(/^\S+/gsu);
+                if (_match) {
+                    _object.name = _text.substring(_match[0].length).trim();
+                    _object.value = _match[0];
+                    _text = '';
+                }
+                break;
+
+        }
+        if (_text) {
+            _object.text = _text;
+        }
+        _objects.push(_object);
+    }
+
+    if (
+        !_objects.length &&
+        doclet.tags[tag]
+    ) {
+        _objects.push({ tag });
+    }
+
+    return _objects;
+}
+
+
+/**
+ * Retrieves the text of the specified tag from a DocletInfo object.
+ *
+ * @param doclet
+ * Doclet information to retrieve from.
+ *
+ * @param tag
+ * Tag to retrieve.
+ *
+ * @param allOrInset
+ * * `false`: Extracts only text from the last tag occurance. (default)
+ * * `true`: Extracts text from all tag occurances, separated by `\n\n`.
+ * * `string`: Extracts only text with matching leading inset (e.g. product).
+ *
+ * @return
+ * Retrieved text or `undefined`.
+ */
+export function extractTagText (
+    doclet: DocletInfo,
+    tag: string,
+    allOrInset: (boolean|string) = false
+): (string|undefined) {
+    const _tagText = doclet.tags[tag];
+
+    if (
+        !_tagText ||
+        !_tagText.length
+    ) {
+        return void 0;
+    }
+
+    if (allOrInset === false) {
+        return _tagText[_tagText.length - 1];
+    }
+
+    if (allOrInset === true) {
+        return _tagText.join('\n\n');
+    }
+
+    const _insetText: Array<string> = [];
+
+    let _inset: (string|undefined);
+
+    for (const _text of _tagText) {
+        _inset = extractTagInset(_text);
+        if (!_inset) {
+            _insetText.push(_text);
+        } else if (_inset === allOrInset) {
+            _insetText.push(
+                _text
+                    .substring(_text.indexOf(`{${_inset}}` + _inset.length + 1))
+                    .trimStart()
+            );
+        }
+    }
+
+    return _insetText.join('\n\n');
+}
+
+
+/**
+ * Extracts all types of a type statement, including conditionals, generics,
+ * intersects and unions.
+ *
+ * @param typeStrings
+ * Type statements as strings to extract from.
+ *
+ * @param includeNativeTypes
+ * Set `true` to include TypeScript's native types.
+ *
+ * @return
+ * Array of extracted types.
+ */
+export function extractTypes (
+    typeStrings: (string|Array<string>),
+    includeNativeTypes?: boolean
+): Array<string> {
+    const _types: Array<string> = [];
+
+    let _sublevel = 0;
+
+    typeStrings = (
+        typeof typeStrings === 'string' ?
+            [typeStrings] :
+            typeStrings
+    );
+
+    for (const _typeString of typeStrings) {
+        for (let _part of _typeString.split('|')) {
+
+            if (
+                !includeNativeTypes &&
+                isNativeType(_part)
+            ) {
+                if (_part.includes('<')) {
+                    _types.push(
+                        _part
+                            .replace(NATIVE_HELPER, '')
+                            .replace('>', '')
+                    );
+                }
+                continue;
+            }
+
+            _part = _part.trim();
+
+            if (_sublevel) {
+                _types.push(`${_types.pop()}|${_part}`);
+            } else {
+                _types.push(_part);
+            }
+
+            if (_part.includes('<')) {
+                ++_sublevel;
+            }
+            if (_part.includes('>')) {
+                --_sublevel;
+            }
+
+        }
+    }
+
+    return _types;
+}
+
+
+/**
+ * Retrieves array info from the given node.
+ *
+ * @param node
+ * Node that might be an array.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ *
+ * @return
+ * Array information or `undefined`.
+ */
+function getArrayInfo (
+    node: TS.Node,
+    includeNodes?: boolean
+): (ArrayInfo|undefined) {
+
+    if (!TS.isArrayLiteralExpression(node)) {
+        return void 0;
+    }
+
+    const _info = {
+        kind: 'Array'
+    } as ArrayInfo;
+
+    const _values: Array<Value> = _info.value = [];
+
+    for (const _child of node.elements) {
+        const _infoValue = getInfoValue(_child);
+
+        if (_infoValue) {
+            _values.push(_infoValue);
+        }
+    }
+
+    addInfoFlags(_info, node);
+    addInfoMeta(_info, node);
+
+    if (includeNodes) {
+        _info.node = node;
+    }
+
+    return _info;
+}
+
+
+/**
+ * Retrieve child informations and doclets.
+ *
+ * @param nodes
+ * Child nodes to extract from.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ *
+ * @return
+ * Retrieved child informations.
+ */
+function getChildInfos (
+    nodes: Array<TS.Node>,
+    includeNodes?: boolean
+): Array<CodeInfo> {
+    const _infos: Array<CodeInfo> = [];
+
+    addChildInfos(_infos, nodes, includeNodes);
+
+    return _infos;
+}
+
+
+/**
+ * Retrieves class info from the given node.
+ *
+ * @param node
+ * Node that might be a class.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ *
+ * @return
+ * Class information or `undefined`.
+ */
+function getClassInfo (
+    node: TS.Node,
+    includeNodes?: boolean
+): (ClassInfo|undefined) {
+
+    if (!TS.isClassDeclaration(node)) {
+        return void 0;
+    }
+
+    const _info = {
+        kind: 'Class'
+    } as ClassInfo;
+
+    _info.name = ((node.name && node.name.getText()) || 'default');
+
+    if (node.typeParameters) {
+        addChildInfos(
+            _info.generics = [],
+            Array.from(node.typeParameters),
+            includeNodes
+        );
+    }
+
+    if (node.heritageClauses) {
+        for (const clause of node.heritageClauses) {
+            if (clause.token === TS.SyntaxKind.ExtendsKeyword) {
+                _info.extends = clause.types[0]?.getText();
+            } else {
+                _info.implements = clause.types.map(t => t.getText());
+            }
+        }
+    }
+
+    addChildInfos(_info.members = [], Array.from(node.members), includeNodes);
+    addInfoFlags(_info, node);
+    addInfoMeta(_info, node);
+
+    if (includeNodes) {
+        _info.node = node;
+    }
+
+    return _info;
+}
+
+
+/**
+ * Retrieves deconstruct information from the given node.
+ *
+ * @param node
+ * Node that might be a deconstruct.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript node in the information.
+ *
+ * @return
+ * Deconstruct information or `undefined`.
+ */
+function getDeconstructInfos (
+    node: TS.Node,
+    includeNodes?: boolean
+): (DeconstructInfo|undefined) {
+
+    if (
+        !TS.isParameter(node) &&
+        !TS.isVariableDeclaration(node)
+    ) {
+        return void 0;
+    }
+
+    if (
+        !TS.isArrayBindingPattern(node.name) &&
+        !TS.isObjectBindingPattern(node.name)
+    ) {
+        return void 0;
+    }
+
+    const _info = {
+        kind: 'Deconstruct',
+        deconstructs: {}
+    } as DeconstructInfo;
+
+    if (node.initializer) {
+        const _from = getInfoValue(node.initializer);
+
+        if (
+            _from &&
+            typeof _from === 'object' &&
+            (
+                _from.kind === 'FunctionCall' ||
+                _from.kind === 'Reference'
+            )
+        ) {
+            _info.from = _from;
+        }
+    }
+
+    for (const element of node.name.elements) {
+        if (TS.isOmittedExpression(element)) {
+            continue;
+        }
+        _info.deconstructs[(element.propertyName || element.name).getText()] =
+            element.name.getText();
+    }
+
+    addInfoFlags(_info, node);
+    addInfoMeta(_info, node);
+
+    if (includeNodes) {
+        _info.node = node;
+    }
+
+    return _info;
+}
+
+
+/**
+ * Retrieve doclet informations between two nodes.
+ *
+ * @param startNode
+ * Node that comes before doclets.
+ *
+ * @param endNode
+ * Node that comes after doclets.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ *
+ * @return
+ * Retrieved doclet informations.
+ */
+function getDocletInfosBetween (
+    startNode: TS.Node,
+    endNode: TS.Node,
+    includeNodes?: boolean
+): Array<DocletInfo> {
+    const _toString = (tag: (TS.JSDoc|TS.JSDocComment|TS.JSDocTag)): (string|undefined) => {
+        switch (tag.kind) {
+            case TS.SyntaxKind.JSDoc:
+                return (
+                    tag.comment instanceof Array ?
+                        tag.comment.map(_toString).join('') :
+                        tag.comment
+                );
+            case TS.SyntaxKind.JSDocLink:
+            case TS.SyntaxKind.JSDocLinkCode:
+            case TS.SyntaxKind.JSDocLinkPlain:
+                return (
+                    '{@link ' +
+                    ((tag as TS.JSDocLink).name?.getText() || '') +
+                    tag.getText() +
+                    '}'
+                );
+            case TS.SyntaxKind.JSDocText:
+                return tag.getText();
+            default:
+                return tag
+                    .getText()
+                    .substring(tag.tagName.text.length + 1)
+                    .replace(/\n +\* ?/gsu, '\n')
+                    .trim();
+        }
+    };
+
+    const _doclets: Array<DocletInfo> = [];
+
+    let _doclet: DocletInfo;
+    let _tagName: string;
+
+    for (const doclet of getDocletsBetween(startNode, endNode)) {
+
+        _doclet = newDocletInfo();
+
+        for (const node of doclet) {
+            if (TS.isJSDoc(node)) {
+
+                if (node.comment) {
+                    addTag(_doclet, 'description', _toString(node));
+                }
+
+                if (node.tags) {
+                    for (const tag of node.tags) {
+                        _tagName = tag.tagName.text;
+                        addTag(_doclet, _tagName, _toString(tag));
+                    }
+                }
+
+                addInfoMeta(_doclet, node);
+
+                if (includeNodes) {
+                    _doclet.node = node;
+                }
+
+            }
+        }
+
+        _doclets.push(_doclet);
+
+    }
+
+    return _doclets;
+}
+
+
+/**
+ * Retrieves all doclet nodes between two nodes.
+ *
+ * @param startNode
+ * Start node that comes before doclets.
+ *
+ * @param endNode
+ * End node that comes after doclets.
+ *
+ * @return
+ * Array of doclet nodes.
+ */
+function getDocletsBetween (
+    startNode: TS.Node,
+    endNode: TS.Node
+): Array<ReturnType<typeof TS.getJSDocCommentsAndTags>> {
+    const doclets: Array<ReturnType<typeof TS.getJSDocCommentsAndTags>> = [];
+    const end = endNode.getStart();
+    const start = (
+        startNode === endNode ?
+            startNode.getFullStart() :
+            startNode.getEnd()
+    );
+    const sourceFile = startNode.getSourceFile();
+    const snippets = Array.from(
+        sourceFile
+            .getFullText()
+            .substring(start, end)
+            .matchAll(DOCLET)
+    );
+
+    if (snippets.length) {
+        // Restore original position range in snap
+        let lastIndex = 0;
+        let snap = ''.padEnd(start, ' ');
+
+        for (const snippet of snippets) {
+            snap += (
+                '\n\'' + ''.padEnd(snippet.index - lastIndex - 5, '_') +
+                '\';\n' + snippet
+            );
+            lastIndex = snippet.index;
+        }
+
+        let parts: ReturnType<typeof TS.getJSDocCommentsAndTags>;
+
+        TS.forEachChild(
+            TS.createSourceFile(
+                sourceFile.fileName,
+                snap + '\n\'\';\n',
+                TS.ScriptTarget.Latest,
+                true
+            ),
+            node => {
+                parts = TS.getJSDocCommentsAndTags(node);
+                if (parts.length) {
+                    doclets.push(parts);
+                }
+            }
+        );
+    }
+
+    return doclets;
+}
+
+
+/**
+ * Retrieves export information from the given node.
+ *
+ * @param node
+ * Node that might be an export.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ *
+ * @return
+ * Export information or `undefined`.
+ */
+function getExportInfo (
+    node: TS.Node,
+    includeNodes?: boolean
+): (ExportInfo|undefined) {
+
+    if (!TS.isExportAssignment(node)) {
+        return void 0;
+    }
+
+    const _info = {
+        kind: 'Export',
+        value: getInfoValue(node.expression, includeNodes)
+    } as ExportInfo;
+
+    addInfoFlags(_info, node);
+    addInfoMeta(_info, node);
+
+    if (includeNodes) {
+        _info.node = node;
+    }
+
+    return _info;
+}
+
+
+/**
+ * Retrieves function call info from the given node.
+ *
+ * @param node
+ * Node that might be a function call.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ *
+ * @return
+ * Function call information or `undefined`.
+ */
+function getFunctionCallInfo (
+    node: TS.Node,
+    includeNodes?: boolean
+): (FunctionCallInfo|undefined) {
+
+    if (!TS.isCallExpression(node)) {
+        return void 0;
+    }
+
+    const _info = {
+        kind: 'FunctionCall',
+        name: ''
+    } as FunctionCallInfo;
+
+    if (TS.isIdentifier(node.expression)) {
+        _info.name = node.expression.text;
+    }
+
+    if (node.arguments) {
+        const _arguments: Array<Value> = _info.arguments = [];
+
+        let _valueInfo: (Value|undefined);
+
+        for (const _child of node.arguments) {
+            _valueInfo = getInfoValue(_child);
+
+            if (_valueInfo) {
+                _arguments.push(_valueInfo);
+            }
+        }
+
+        if (!_arguments.length) {
+            delete _info.arguments;
+        }
+    }
+
+    if (node.typeArguments) {
+        const _genericArguments: Array<string> = _info.genericArguments = [];
+
+        for (const _child of node.typeArguments) {
+            _genericArguments.push(...(getInfoType(_child) || []));
+        }
+
+        if (!_genericArguments.length) {
+            delete _info.genericArguments;
+        }
+    }
+
+    addInfoMeta(_info, node);
+
+    if (includeNodes) {
+        _info.node = node;
+    }
+
+    return _info;
+}
+
+
+/**
+ * Retrieves function information from the given node.
+ *
+ * @param node
+ * Node that might be an import.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ *
+ * @return
+ * Function information or `undefined`.
+ */
+function getFunctionInfo (
+    node: TS.Node,
+    includeNodes?: boolean
+): (FunctionInfo|undefined) {
+
+    if (
+        !TS.isConstructorDeclaration(node) &&
+        !TS.isFunctionDeclaration(node) &&
+        !TS.isMethodDeclaration(node)
+    ) {
+        return void 0;
+    }
+
+    const _info = {
+        kind: 'Function',
+        name: (
+            TS.isConstructorDeclaration(node) ?
+                'constructor' :
+                (node.name?.getText() || '')
+        )
+    } as FunctionInfo;
+
+    if (node.typeParameters) {
+        const _generics: Array<TypeAliasInfo> = _info.generics = [];
+
+        let _typeAlias: (TypeAliasInfo|undefined);
+
+        for (const _typeParameter of node.typeParameters) {
+            _typeAlias = getTypeAliasInfo(_typeParameter, includeNodes);
+
+            if (_typeAlias) {
+                _generics.push(_typeAlias);
+            }
+        }
+
+        if (!_generics.length) {
+            delete _info.generics;
+        }
+    }
+
+    if (node.parameters) {
+        const _parameters: Array<VariableInfo> = _info.parameters = [];
+
+        let _variableInfo: (VariableInfo|undefined);
+
+        for (const parameter of node.parameters) {
+            _variableInfo = getVariableInfo(parameter, includeNodes);
+
+            if (_variableInfo) {
+                _parameters.push(_variableInfo);
+            }
+        }
+
+        if (!_parameters.length) {
+            delete _info.parameters;
+        }
+    }
+
+    const _type = node.type || TS.getJSDocReturnType(node);
+
+    if (_type) {
+        _info.return = getInfoType(_type);
+    }
+
+    addInfoFlags(_info, node);
+    addInfoMeta(_info, node);
+
+    const firstToken = node.body?.getFirstToken()
+
+    if (firstToken) {
+        const _bodyDoclets = getDocletInfosBetween(
+            firstToken,
+            node.body?.getLastToken() || firstToken
+        );
+
+        if (_bodyDoclets && _bodyDoclets.length) {
+            _info.body = _bodyDoclets;
+        }
+
+    }
+
+    if (includeNodes) {
+        _info.node = node;
+    }
+
+    return _info;
+}
+
+
+/**
+ * Retrieves import information from the given node.
+ *
+ * @param node
+ * Node that might be an import.
+ *
+ * @param includeNode
+ * Whether to include the TypeScript node in the information.
+ *
+ * @return
+ * Import information or `undefined`.
+ */
+function getImportInfo (
+    node: TS.Node,
+    includeNode?: boolean
+): (ImportInfo|undefined) {
+
+    if (!TS.isImportDeclaration(node)) {
+        return void 0;
+    }
+
+    const _info = {
+        kind: 'Import'
+    } as ImportInfo;
+
+    _info.from = sanitizeText(node.moduleSpecifier.getText());
+
+    if (node.importClause) {
+        const _imports: Record<string, string> = _info.imports = {};
+
+        let propertyName: string;
+
+        for (const clause of getNodesChildren(node.importClause)) {
+            if (TS.isIdentifier(clause)) {
+                _imports.default = clause.text;
+            }
+            if (TS.isNamedImports(clause)) {
+                for (const child of getNodesChildren(clause)) {
+                    if (TS.isImportSpecifier(child)) {
+                        propertyName = (
+                            child.propertyName &&
+                            child.propertyName.text ||
+                            child.name.text
+                        );
+                        _imports[propertyName] = child.name.text;
+                    }
+                }
+            }
+        }
+
+    }
+
+    addInfoFlags(_info, node);
+    addInfoMeta(_info, node);
+
+    if (includeNode) {
+        _info.node = node;
+    }
+
+    return _info;
+}
+
+
+/**
+ * Retrieves type information for a given node.
+ *
+ * @param node
+ * Node to return type information for.
+ *
+ * @return
+ * Type information for the given node.
+ */
+function getInfoType (
+    node: (TS.Expression|TS.TypeNode|undefined)
+): (Array<string>|undefined) {
+    let _infoType: Array<string> = [];
+
+    if (node) {
+        if (TS.isParenthesizedTypeNode(node)) {
+            return getInfoType(node.type);
+        }
+        if (TS.isExpression(node)) {
+            const _nodeValue = getInfoValue(node);
+            if (!_nodeValue || typeof _nodeValue !== 'object') {
+                _infoType.push(typeof _nodeValue);
+            } else if (_nodeValue.kind === 'Reference') {
+                _infoType.push(_nodeValue.name);
+            } else {
+                _infoType.push(
+                    _nodeValue.kind.replace('FunctionCall', 'Function')
+                );
+            }
+        } else if (TS.isUnionTypeNode(node)) {
+            for (const _nodeType of node.types) {
+                _infoType.push(...(getInfoType(_nodeType) || []));
+            }
+        } else {
+            _infoType.push(sanitizeType(node.getText()));
+        }
+    }
+
+    _infoType = _infoType.filter(_type => _type !== 'void');
+
+    if (_infoType.length) {
+        return _infoType;
+    }
+
+    return void 0;
+}
+
+
+/**
+ * Retrieves value information for a given expression.
+ *
+ * @param node
+ * Expression to return a value for.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ *
+ * @return
+ * Value or `undefined`.
+ */
+function getInfoValue (
+    node: TS.Expression,
+    includeNodes?: boolean
+): (Value|undefined) {
+    let _value: (Value|undefined) = (
+        getArrayInfo(node, includeNodes) ||
+        getFunctionCallInfo(node, includeNodes) ||
+        getFunctionInfo(node, includeNodes) ||
+        getReferenceInfo(node, includeNodes) ||
+        getVariableInfo(node, includeNodes)?.value
+    );
+
+    if (typeof _value === 'undefined') {
+        const _deconstructInfo = getDeconstructInfos(node, includeNodes);
+
+        if (_deconstructInfo) {
+            _value = _deconstructInfo.from;
+        }
+    }
+
+    if (_value && typeof _value === 'object') {
+        const _doclets = getDocletInfosBetween(node, node, includeNodes);
+
+        if (_doclets.length) {
+            _value.doclet = _doclets.pop();
+        }
+
+        return _value;
+    }
+
+    _value = node.getText();
+
+    if (sanitizeText(_value) !== _value) {
+        return sanitizeText(_value);
+    }
+
+    if (!isNaN(Number(_value))) {
+        return Number(_value);
+    }
+
+    return {
+        false: false,
+        null: null,
+        true: true
+    }[_value] || _value;
+}
+
+
+/**
+ * Retrieves interface information from the given node.
+ *
+ * @param node
+ * Node that might be an interface.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ *
+ * @return
+ * Interface or `undefined`.
+ */
+function getInterfaceInfo (
+    node: TS.Node,
+    includeNodes?: boolean
+): (InterfaceInfo|undefined) {
+
+    if (!TS.isInterfaceDeclaration(node)) {
+        return void 0;
+    }
+
+    const _info = {
+        kind: 'Interface'
+    } as InterfaceInfo;
+
+    _info.name = node.name.text;
+
+    if (node.typeParameters) {
+        addChildInfos(
+            _info.generics = [],
+            Array.from(node.typeParameters),
+            includeNodes
+        );
+    }
+
+    if (node.heritageClauses) {
+        for (const clause of node.heritageClauses) {
+            if (clause.token === TS.SyntaxKind.ExtendsKeyword) {
+                _info.implements = clause.types.map(t => t.getText());
+            } else {
+                _info.implements = clause.types.map(t => t.getText());
+            }
+        }
+    }
+
+    addChildInfos(_info.members = [], Array.from(node.members), includeNodes);
+    addInfoFlags(_info, node);
+    addInfoMeta(_info, node);
+
+    if (includeNodes) {
+        _info.node = node;
+    }
+
+    return _info;
+}
+
+
+/**
+ * Retrieves namespace and module information from the given node.
+ *
+ * @param node
+ * Node that might be a namespace or module.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ *
+ * @return
+ * Namespace, module or `undefined`.
+ */
+function getNamespaceInfo (
+    node: TS.Node,
+    includeNodes?: boolean
+): (NamespaceInfo|undefined) {
+
+    if (!TS.isModuleDeclaration(node)) {
+        return void 0;
+    }
+
+    const _info = {
+        kind: (
+            node
+                .getChildren()
+                .some(token => token.kind === TS.SyntaxKind.ModuleKeyword) ?
+                'Module' :
+                'Namespace'
+        ),
+        name: node.name.text
+    } as NamespaceInfo;
+
+    addChildInfos(
+        _info.members = [],
+        node.body && getNodesChildren(node.body) || [],
+        includeNodes
+    );
+    addInfoFlags(_info, node);
+    addInfoMeta(_info, node);
+
+    if (includeNodes) {
+        _info.node = node;
+    }
+
+    return _info;
+}
+
+
+/**
+ * Retrieves all logical children and skips statement tokens.
+ *
+ * @param node
+ * Node to retrieve logical children from.
+ *
+ * @return
+ * Array of logical children.
+ */
+function getNodesChildren (
+    node: TS.Node
+): Array<TS.Node> {
+    const children: Array<TS.Node> = [];
+
+    TS.forEachChild(node, child => {
+        children.push(child);
+    });
+
+    return children;
+}
+
+
+/**
+ * [TS] Retrieve the first logical child of a node.
+ *
+ * @param node
+ * Node to retrieve the first logical child from.
+ *
+ * @return
+ * First logical child, if found.
+ */
+export function getNodesFirstChild (
+    node: TS.Node
+): (TS.Node|undefined) {
+    return getNodesChildren(node).shift();
+}
+
+
+/**
+ * [TS] Retrieve the last logical child of a node.
+ *
+ * @param node
+ * Node to retrieve the last logical child from.
+ *
+ * @return
+ * Last logical child, if found.
+ */
+export function getNodesLastChild (
+    node: TS.Node
+): (TS.Node|undefined) {
+    return getNodesChildren(node).pop();
+}
+
+
+/**
+ * Retrieves object information from the current node.
+ *
+ * @param node
+ * Node that might be an object literal.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ *
+ * @return
+ * Object information or `undefined`.
+ */
+function getObjectInfo (
+    node: TS.Node,
+    includeNodes?: boolean
+): (ObjectInfo|undefined) {
+    let _type: (Array<string>|undefined);
+
+    if (TS.isAsExpression(node)) {
+        _type = getInfoType(node.type);
+        node = node.expression;
+    }
+
+    if (!TS.isObjectLiteralExpression(node)) {
+        return void 0;
+    }
+
+    const _info = {
+        kind: 'Object'
+    } as ObjectInfo;
+
+    _type = (_type || getInfoType(TS.getJSDocType(node)));
+
+    if (typeof _type !== 'object') {
+        _info.type = _type;
+    }
+
+    addChildInfos(
+        _info.members = [],
+        Array.from(node.properties),
+        includeNodes
+    );
+    addInfoFlags(_info, node);
+    addInfoMeta(_info, node);
+
+    if (includeNodes) {
+        _info.node = node;
+    }
+
+    return _info;
+}
+
+
+/**
+ * Retrieves property information from the current node.
+ *
+ * @param node
+ * Node that might be a property.
+ *
+ * @param includeNode
+ * Whether to include the TypeScript node in the information.
+ *
+ * @return
+ * Property information or `undefined`.
+ */
+function getPropertyInfo (
+    node: TS.Node,
+    includeNode?: boolean
+): (PropertyInfo|undefined) {
+
+    if (
+        !TS.isPropertyAssignment(node) &&
+        !TS.isPropertyDeclaration(node) &&
+        !TS.isPropertySignature(node) &&
+        !TS.isShorthandPropertyAssignment(node)
+    ) {
+        return void 0;
+    }
+
+    const _info = {
+        kind: 'Property'
+    } as PropertyInfo;
+
+    _info.name = node.name.getText();
+
+    if (
+        !TS.isPropertyAssignment(node) &&
+        !TS.isShorthandPropertyAssignment(node)
+    ) {
+        _info.type = (
+            getInfoType(node.type) ||
+            getInfoType(TS.getJSDocType(node))
+        );
+    }
+
+    if (!TS.isPropertySignature(node)) {
+        const _initializer = (
+            TS.isShorthandPropertyAssignment(node) ?
+                node.objectAssignmentInitializer :
+                node.initializer
+        );
+
+        if (_initializer) {
+            _info.value = getInfoValue(_initializer);
+        }
+    }
+
+    addInfoFlags(_info, node);
+    addInfoMeta(_info, node);
+
+    if (includeNode) {
+        _info.node = node;
+    }
+
+    return _info;
+}
+
+
+/**
+ * Retrieves reference information from the current node.
+ *
+ * @param node
+ * Node that might be a reference like an intendifier.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript node in the information.
+ *
+ * @return
+ * Reference information or `undefined`.
+ */
+function getReferenceInfo (
+    node: TS.Node,
+    includeNodes?: boolean
+): (ReferenceInfo|undefined) {
+
+    if (
+        !TS.isIdentifier(node) &&
+        !TS.isParameter(node) &&
+        !TS.isPropertyAccessExpression(node)
+    ) {
+        return void 0;
+    }
+
+    const _info = {
+        kind: 'Reference',
+        name: (
+            TS.isParameter(node) ?
+                node.name.getText() :
+                node.getText()
+        )
+    } as ReferenceInfo;
+
+    addInfoFlags(_info, node);
+    addInfoMeta(_info, node);
+
+    if (includeNodes) {
+        _info.node = node;
+    }
+
+    return _info;
+}
+
+
+/**
+ * Retrieves source information from the given file source.
+ *
+ * @param filePath
+ * Path to source file.
+ *
+ * @param sourceText
+ * Text of source file.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ *
+ * @return
+ * Source information.
+ */
+export function getSourceInfo (
+    filePath: string,
+    sourceText?: string,
+    includeNodes?: boolean
+): SourceInfo {
+    let _info = getSourceInfoFromCache(filePath, includeNodes);
+
+    if (!sourceText) {
+        if (_info) {
+            return _info;
+        }
+        sourceText = FS.readFileSync(filePath, 'utf8');
+    }
+
+    const _cacheKey = `${filePath}:${!!includeNodes}`;
+    const _sourceFile = TS.createSourceFile(
+        filePath,
+        sourceText,
+        TS.ScriptTarget.Latest,
+        true
+    );
+
+    _info = {
+        kind: 'Source',
+        path: filePath,
+        code: []
+    } as SourceInfo;
+
+    addChildInfos(_info.code, getNodesChildren(_sourceFile), includeNodes);
+    addInfoScopes(_info, _info.code);
+
+    SOURCE_CACHE[_cacheKey] = _info;
+
+    return _info;
+}
+
+
+/**
+ * Retrieves source information from the source cache.
+ *
+ * @param filePath
+ * Path to source file.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript nodes in the information.
+ *
+ * @return
+ * Source information.
+ */
+function getSourceInfoFromCache (
+    filePath: string,
+    includeNodes?: boolean
+): (SourceInfo|undefined) {
+    return SOURCE_CACHE[`${filePath}:${!!includeNodes}`];
+}
+
+
+/**
+ * Retrieves type alias information from the given node.
+ *
+ * @param node
+ * Node that might be a type alias.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript node in the information.
+ *
+ * @return
+ * Type alias information or `undefined`.
+ */
+function getTypeAliasInfo (
+    node: TS.Node,
+    includeNodes?: boolean
+): (TypeAliasInfo|undefined) {
+
+    if (
+        !TS.isTypeAliasDeclaration(node) &&
+        !TS.isTypeParameterDeclaration(node)
+    ) {
+        return void 0;
+    }
+
+    const _info = {
+        kind: 'TypeAlias',
+        name: node.name.text
+    } as TypeAliasInfo;
+
+    if (TS.isTypeParameterDeclaration(node)) {
+        if (node.constraint) {
+            _info.value = getInfoType(node.constraint);
+        }
+        if (node.default) {
+            _info.value = _info.value || [];
+            _info.value = getInfoType(node.default);
+        }
+    } else {
+        _info.value = (
+            getInfoType(node.type) ||
+            getInfoType(TS.getJSDocType(node))
+        );
+        if (node.typeParameters) {
+            const _generics: Array<TypeAliasInfo> = [];
+
+            let _typeAliasInfo: (TypeAliasInfo|undefined);
+
+            for (const parameter of node.typeParameters) {
+                _typeAliasInfo = getTypeAliasInfo(parameter);
+                if (_typeAliasInfo) {
+                    _generics.push(_typeAliasInfo);
+                }
+            }
+
+            if (_generics.length) {
+                _info.generics = _generics;
+            }
+        }
+
+    }
+
+    addInfoFlags(_info, node);
+    addInfoMeta(_info, node);
+
+    if (includeNodes) {
+        _info.node = node;
+    }
+
+    return _info;
+}
+
+
+/**
+ * Retrieves variable information from the given node.
+ *
+ * @param node
+ * Node that might be a variable or assignment.
+ *
+ * @param includeNodes
+ * Whether to include the TypeScript node in the information.
+ *
+ * @return
+ * Variable information or `undefined`.
+ */
+function getVariableInfo (
+    node: TS.Node,
+    includeNodes?: boolean
+): (VariableInfo|undefined) {
+
+    if (
+        !TS.isVariableDeclaration(node) ||
+        TS.isArrayBindingPattern(node.name) || // See getDeconstructInfo
+        TS.isObjectBindingPattern(node.name)
+    ) {
+        return void 0;
+    }
+
+    const _info = {
+        kind: 'Variable',
+        name: node.name.text
+    } as VariableInfo;
+
+    _info.type = (
+        getInfoType(node.type) ||
+        getInfoType(TS.getJSDocType(node))
+    );
+
+    if (node.initializer) {
+        _info.type = (
+            _info.type ||
+            getInfoType(node.initializer)
+        );
+        _info.value = getInfoValue(node.initializer, includeNodes);
+    }
+
+    if (TS.isVariableDeclarationList(node.parent)) {
+        addInfoFlags(_info, node.parent.parent);
+    } else {
+        addInfoFlags(_info, node);
+    }
+
+    addInfoMeta(_info, node);
+
+    if (includeNodes) {
+        _info.node = node;
+    }
+
+    return _info;
+}
+
+
+/**
+ * Tests if a text string starts with upper case.
+ *
+ * @param text
+ * Text string to test.
+ *
+ * @return
+ * `true`, if text string starts with upper case.
+ */
+function isCapitalCase (
+    text: string
+): boolean {
+    const firstChar = `${text}`.charAt(0);
+
+    return (firstChar === firstChar.toUpperCase());
+}
+
+
+/**
+ * Tests if a type is integrated into TypeScript.
+ *
+ * @param typeString
+ * Type to test.
+ *
+ * @return
+ * `true`, if type is integrated into TypeScript.
+ */
+function isNativeType (
+    typeString: string
+): boolean {
+    return (
+        typeString.length < 2 ||
+        !isCapitalCase(typeString) ||
+        NATIVE_TYPES.includes(typeString) ||
+        !!typeString.match(NATIVE_HELPER) ||
+        !!TS.SyntaxKind[typeString as keyof typeof TS.SyntaxKind]
+    );
+}
+
+
+/**
+ * Tests whether a doclet tag is related to one or more products. The test will
+ * also succeed, if no product information was provided or could be found.
+ *
+ * @param docletOrTagLine
+ * Doclet information or tag line to test.
+ *
+ * @param products
+ * Products to test against.
+ *
+ * @return
+ * `true` if related to one or more products, otherwise `false`.
+ */
+function isProductRelated (
+    docletOrTagLine: (string|DocletInfo|undefined),
+    products: Array<string> = PRODUCTS
+): boolean {
+    const productsToTest: Array<string> = [];
+
+    if (
+        !docletOrTagLine ||
+        !products.length
+    ) {
+        return true;
+    }
+
+    /**
+     * Adds any discovered product to the `productsToTest` array.
+     *
+     * @param tagLine
+     * Line to extract product from.
+     */
+    function addProductsToTest (tagLine: string) {
+        const inset = extractTagInset(tagLine);
+
+        if (inset) {
+            productsToTest.push(...inset.split(/[^\w\-]+/gu));
+        }
+
+    }
+
+    if (typeof docletOrTagLine === 'string') {
+
+        addProductsToTest(docletOrTagLine);
+
+    } else {
+        const productTagLine = extractTagText(docletOrTagLine, 'product', true);
+
+        if (productTagLine) {
+            return isProductRelated(`{${productTagLine}}`, products);
+        }
+
+        const tags = docletOrTagLine.tags;
+
+        for (const tag of Object.keys(tags)) {
+
+            if (
+                tag === 'param' ||
+                tag === 'type'
+            ) {
+                continue;
+            }
+
+            for (const tagLine of tags[tag]) {
+                addProductsToTest(tagLine);
+            }
+
+        }
+
+    }
+
+    if (!productsToTest.length) {
+        return true;
+    }
+
+    for (const product of productsToTest) {
+        if (products.includes(product)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+/**
+ * Merge code information.
+ *
+ * @param targetInfo
+ * Target information to merge into.
+ *
+ * @param sourceInfo
+ * Source information to merge.
+ *
+ * @return
+ * Target infos as reference.
+ */
+function mergeCodeInfos<T extends (CodeInfo|SourceInfo)> (
+    targetInfo: T,
+    sourceInfo: (CodeInfo|SourceInfo)
+): T {
+    let _sourceMembers: Array<CodeInfo>;
+    let _targetMembers: Array<CodeInfo>;
+
+    switch (targetInfo.kind) {
+        default:
+            return targetInfo;
+        case 'Class':
+        case 'Interface':
+        case 'Namespace':
+        case 'Object':
+            _targetMembers = targetInfo.members;
+            break;
+        case 'Source':
+            _targetMembers = targetInfo.code;
+            break;
+    }
+
+    switch (sourceInfo.kind) {
+        default:
+            return targetInfo;
+        case 'Class':
+        case 'Interface':
+        case 'Module':
+        case 'Namespace':
+        case 'Object':
+            _sourceMembers = sourceInfo.members;
+            break;
+        case 'Source':
+            _sourceMembers = sourceInfo.code;
+            break;
+    }
+
+    if (
+        targetInfo.kind !== sourceInfo.kind &&
+        (
+            targetInfo.kind !== 'Source' ||
+            sourceInfo.kind !== 'Module'
+        )
+    ) {
+        return targetInfo;
+    }
+
+    let _merged: boolean;
+    let _mergedMember: CodeInfo;
+    let _name: (string|undefined);
+
+    for (const _sourceMember of _sourceMembers) {
+
+        _merged = false;
+        _name = extractInfoName(_sourceMember);
+
+        if (!_name) {
+            continue;
+        }
+
+        for (
+            const _targetMember
+            of (extractInfos(_targetMembers, _name) || [])
+        ) {
+            if (_targetMember.kind !== _sourceMember.kind) {
+                continue;
+            }
+            switch (_sourceMember.kind) {
+                default:
+                    continue;
+                case 'Class':
+                case 'Interface':
+                case 'Namespace':
+                case 'Object':
+                    mergeCodeInfos(_targetMember, _sourceMember);
+                    break;
+                case 'Doclet':
+                    if (_targetMember.kind !== 'Doclet') {
+                        continue;
+                    }
+                    mergeDocletInfos(
+                        _targetMember,
+                        _sourceMember
+                    );
+                    break;
+                case 'Function':
+                    _mergedMember = newCodeInfo(_sourceMember);
+                    _mergedMember.meta.merged = true;
+                    _targetMembers.push(_mergedMember);
+                    addInfoScopes(_targetMember, [_mergedMember]);
+                    break;
+                case 'Property':
+                    if (_targetMember.kind !== 'Property') {
+                        continue;
+                    }
+                    if (_sourceMember.doclet) {
+                        if (_targetMember.doclet) {
+                            mergeDocletInfos(
+                                _targetMember.doclet,
+                                _sourceMember.doclet
+                            );
+                        } else {
+                            _mergedMember =
+                                newDocletInfo(_sourceMember.doclet);
+                            _mergedMember.meta.merged = true;
+                            _targetMember.doclet = _mergedMember;
+                        }
+                    }
+                    if (
+                        _targetMember.type ||
+                        _sourceMember.type
+                    ) {
+                        _targetMember.type = Array.from(new Set([
+                            ...(_targetMember.type || []),
+                            ...(_sourceMember.type || [])
+                        ]));
+                    }
+                    if (
+                        _targetMember.value &&
+                        typeof _targetMember.value === 'object' &&
+                        _sourceMember.value &&
+                        typeof _sourceMember.value === 'object'
+                    ) {
+                        mergeCodeInfos(
+                            _targetMember,
+                            _sourceMember
+                        );
+                    }
+                    break;
+            }
+            _merged = true;
+        }
+
+        if (!_merged) {
+            _mergedMember = newCodeInfo(_sourceMember as Partial<ArrayInfo>);
+            _mergedMember.meta.merged = true;
+            _targetMembers.push(_mergedMember);
+            addInfoScopes(targetInfo, [_mergedMember]);
+        }
+
+    }
+
+    return targetInfo;
+}
+
+
+/**
+ * Merge multiple DocletInfo objects into the first.
+ *
+ * @param targetDoclet
+ * Doclet information to add to.
+ *
+ * @param sourceDoclets
+ * Doclet informations to add.
+ *
+ * @return
+ * First DocletObject as reference.
+ */
+function mergeDocletInfos (
+    targetDoclet?: DocletInfo,
+    ...sourceDoclets: Array<DocletInfo>
+): DocletInfo {
+    targetDoclet = targetDoclet || newDocletInfo();
+
+    const targetTags = targetDoclet.tags;
+
+    let productTagLine: (string|undefined);
+    let sourceTags: Record<string,Array<string>>;
+    let targetTag: Array<string>;
+
+    for (const sourceDoclet of sourceDoclets) {
+        productTagLine = extractTagText(sourceDoclet, 'product', true);
+
+        if (
+            productTagLine &&
+            !isProductRelated(`{${productTagLine}}`)
+        ) {
+            continue;
+        }
+
+        sourceTags = sourceDoclet.tags;
+
+        for (const tag of Object.keys(sourceTags)) {
+            targetTag = targetTags[tag] = targetTags[tag] || [];
+            for (const value of sourceTags[tag]) {
+                if (
+                    !targetTag.includes(value) &&
+                    isProductRelated(value)
+                ) {
+                    targetTag.push(value);
+                }
+            }
+        }
+    }
+
+    targetDoclet.meta.merged = true;
+
+    return targetDoclet;
+}
+
+
+/**
+ * Creates a new code or source information object.
+ *
+ * @param template
+ * Information to apply.
+ *
+ * @return
+ * New information.
+ */
+function newCodeInfo<T> (
+    template?: Partial<T>
+): T {
+    const clone = {
+        kind: 'Object',
+        meta: newMeta(),
+        ...structuredClone({
+            ...template,
+            node: void 0 // Avoid clone of native TSNode.
+        })
+    } as T;
+
+    delete (clone as Record<string, unknown>).node; // Clean-up
+
+    return clone;
+}
+
+
+/**
+ * Creates a new DocletInfo object.
+ *
+ * @param template
+ * Doclet information to apply.
+ *
+ * @return
+ * The new doclet information.
+ */
+function newDocletInfo (
+    template: Partial<DocletInfo> = {}
+): DocletInfo {
+    const clone: DocletInfo = {
+        kind: 'Doclet',
+        tags: {},
+        meta: newMeta(),
+        ...structuredClone({
+            ...template,
+            node: void 0 // Avoid clone of native TSNode.
+        })
+    };
+
+    delete clone.node; // Clean-up
+
+    return clone;
+}
+
+
+/**
+ * Creates a new Meta object.
+ *
+ * @param template
+ * Meta to apply.
+ *
+ * @return
+ * New meta.
+ */
+function newMeta (
+    template: Partial<Meta> = {}
+): Meta {
+    return {
+        begin: 0,
+        end: 0,
+        file: '',
+        overhead: 0,
+        syntax: 0,
+        ...structuredClone(template)
+    };
+}
+
+
+/**
+ * Removes all doclets from source code.
+ *
+ * @param sourceCode
+ * Source code to remove doclets from.
+ *
+ * @return
+ * Source code without doclets.
+ */
+export function removeAllDoclets (
+    sourceCode: string
+): string {
+    return sourceCode
+        .replace(/\n *\/\*\*.*?\*\//gsu, '')
+        .replace(/\n(\(?)''\1;[^\n]*/gsu, '')
+        .replace(/\n\s+\n/gsu, '\n\n');
+}
+
+
+/**
+ * Removes a tag from a DocletInfo object.
+ *
+ * @param doclet
+ * Doclet information to modify.
+ *
+ * @param tag
+ * Tag to remove.
+ *
+ * @return
+ * Removed tag text.
+ */
+export function removeTag (
+    doclet: DocletInfo,
+    tag: string
+): Array<string> {
+    const tags = doclet.tags;
+
+    if (tags) {
+        const text = tags[tag];
+
+        delete tags[tag];
+
+        return text;
+    }
+
+    return [];
+}
+
+
+/**
+ * Resets the products array and source cache for a new session.
+ */
+export function reset (): void {
+
+    PRODUCTS.length = 0;
+
+    for (const key of Object.keys(SOURCE_CACHE)) {
+        delete SOURCE_CACHE[key];
+    }
+
+}
+
+
+/**
+ * Resolves a reference relative to the given information.
+ *
+ * @param scopeInfo
+ * Scope information to use.
+ *
+ * @param reference
+ * Reference name or information to resolve.
+ *
+ * @return
+ * Resolved information or `undefined`.
+ */
+export function resolveReference (
+    scopeInfo: (CodeInfo|SourceInfo),
+    reference: (string|ReferenceInfo)
+): (CodeInfo|undefined) {
+    const _sourceInfo = (
+        scopeInfo.kind === 'Source' ?
+            scopeInfo :
+            getSourceInfo(scopeInfo.meta.file)
+    );
+
+    let _hasThis = false;
+    let _referenceName = (
+        typeof reference === 'string' ?
+            reference :
+            reference.name
+    );
+
+    const _referenceSplit = _referenceName.split(/\W+/gsu);
+
+    if (_referenceSplit.indexOf('this') === 0) {
+        _hasThis = true;
+        _referenceName = _referenceName.substring(5);
+        _referenceSplit.shift();
+    }
+
+    let _resolvedInfo: (CodeInfo|undefined);
+    let _scopePath = extractInfoScopePath(scopeInfo);
+
+    // First search in inner scopes.
+    while (_scopePath) {
+
+        _resolvedInfo = resolveReferenceInChildInfos(
+            _sourceInfo,
+            _sourceInfo.code,
+            (
+                _referenceName ?
+                    `${_scopePath}.${_referenceName}` :
+                    _scopePath
+            )
+        );
+
+        if (_resolvedInfo) {
+            return _resolvedInfo;
+        }
+
+        _scopePath = _scopePath.substring(0, _scopePath.lastIndexOf('.'));
+
+    }
+
+    // Did not found this in inner scopes.
+    if (_hasThis) {
+        return void 0;
+    }
+
+    // Search in source scope.
+    return resolveReferenceInChildInfos(
+        _sourceInfo,
+        _sourceInfo.code,
+        _referenceName
+    );
+}
+
+
+/**
+ * Resolves a reference relative to the given informations.
+ *
+ * @param scopeInfo
+ * Scope information to use.
+ *
+ * @param childInfos
+ * Child informations to use.
+ *
+ * @param referenceName
+ * Reference name to resolve.
+ *
+ * @return
+ * Resolved information or `undefined`.
+ */
+function resolveReferenceInChildInfos (
+    scopeInfo: (NamespaceInfo|SourceInfo),
+    childInfos: Array<CodeInfo>,
+    referenceName: string
+): (CodeInfo|undefined) {
+    const _referenceSplit = referenceName.split(/\W+/gsu);
+    const _referenceCurrent = _referenceSplit.shift();
+    const _referenceNext = _referenceSplit.join('.');
+
+    let _resolvedInfo: (CodeInfo|undefined);
+    let _sourceInfo: (SourceInfo|undefined);
+
+    for (const _childInfo of childInfos) {
+        switch (_childInfo.kind) {
+
+            case 'Class':
+            case 'Interface':
+            case 'Namespace':
+                if (extractInfoName(_childInfo) === _referenceCurrent) {
+                    if (_referenceNext) {
+                        _resolvedInfo = resolveReferenceInChildInfos(
+                            (
+                                _childInfo.kind === 'Namespace' ?
+                                    _childInfo :
+                                    scopeInfo
+                            ),
+                            _childInfo.members,
+                            _referenceNext
+                        );
+                        if (_resolvedInfo) {
+                            return _resolvedInfo;
+                        }
+                    } else {
+                        return _childInfo;
+                    }
+                }
+                continue;
+
+            case 'Deconstruct':
+                _resolvedInfo = resolveReferenceInDeconstructInfo(
+                    scopeInfo,
+                    _childInfo,
+                    referenceName
+                );
+                if (_resolvedInfo) {
+                    return _resolvedInfo;
+                }
+                continue;
+
+            case 'Export':
+                _resolvedInfo = resolveReferenceInExportInfo(
+                    scopeInfo,
+                    _childInfo,
+                    referenceName
+                );
+                if (_resolvedInfo) {
+                    return _resolvedInfo;
+                }
+                continue;
+
+            case 'Import':
+                _resolvedInfo =
+                    resolveReferenceInImportInfo(_childInfo, referenceName);
+                if (_resolvedInfo) {
+                    return _resolvedInfo;
+                }
+                continue;
+
+            case 'Module':
+                continue;
+
+            case 'Property':
+            case 'Variable':
+                if (extractInfoName(_childInfo) === _referenceCurrent) {
+                    if (!_referenceNext) {
+                        return _childInfo;
+                    }
+                    if (_childInfo.value && typeof _childInfo.value === 'object') {
+                        return resolveReferenceInChildInfos(
+                            scopeInfo,
+                            [_childInfo.value],
+                            _referenceNext
+                        );
+                    }
+                }
+                continue;
+
+            case 'Reference':
+                if (scopeInfo.kind === 'Source') {
+                    if (_childInfo.meta.file !== scopeInfo.path) {
+                        // Search in original file
+                        _sourceInfo = getSourceInfo(
+                            _childInfo.meta.file,
+                            void 0,
+                            !!_childInfo.node
+                        );
+                        if (_sourceInfo) {
+                            _resolvedInfo =
+                                resolveReference(_sourceInfo, _childInfo.name);
+                            if (_resolvedInfo) {
+                                return _resolvedInfo;
+                            }
+                        }
+                    }
+                    // Search in source scope
+                    if (scopeInfo.kind === 'Source') {
+                        _resolvedInfo = resolveReference(scopeInfo, _childInfo);
+                        if (_resolvedInfo) {
+                            return _resolvedInfo;
+                        }
+                    }
+                } else {
+                    // Search in original file
+                    if (_childInfo.meta.file !== scopeInfo.meta.file) {
+                        _resolvedInfo = resolveReference(
+                            getSourceInfo(
+                                _childInfo.meta.file,
+                                void 0,
+                                !!_childInfo.node
+                            ),
+                            _childInfo.name
+                        );
+                        if (_resolvedInfo) {
+                            return _resolvedInfo;
+                        }
+                    }
+                    // Search in namespace
+                    _resolvedInfo = resolveReferenceInChildInfos(
+                        scopeInfo,
+                        scopeInfo.members,
+                        _childInfo.name
+                    );
+                    if (_resolvedInfo) {
+                        return _resolvedInfo;
+                    }
+                    // Search in outer scope of namespace
+                    _sourceInfo = getSourceInfo(
+                        scopeInfo.meta.file,
+                        void 0,
+                        !!scopeInfo.node
+                    );
+                    if (_sourceInfo) {
+                        _resolvedInfo = resolveReferenceInChildInfos(
+                            _sourceInfo,
+                            _sourceInfo.code,
+                            _childInfo.name
+                        );
+                        if (_resolvedInfo) {
+                            return _resolvedInfo;
+                        }
+                    }
+                }
+                continue;
+
+            case 'Object':
+                _resolvedInfo = resolveReferenceInObjectInfo(
+                    scopeInfo,
+                    _childInfo,
+                    referenceName
+                );
+                if (_resolvedInfo) {
+                    return _resolvedInfo;
+                }
+                continue;
+
+            case 'TypeAlias':
+                if (extractInfoName(_childInfo) === _referenceCurrent) {
+                    _resolvedInfo = resolveReferenceInType(
+                        scopeInfo,
+                        (_childInfo.value || []),
+                        _referenceNext
+                    );
+                    if (_resolvedInfo) {
+                        return _resolvedInfo;
+                    }
+                }
+                continue;
+
+            default:
+                if (extractInfoName(_childInfo) === referenceName) {
+                    return _childInfo;
+                }
+                continue;
+
+        }
+    }
+
+    return void 0;
+}
+
+
+/**
+ * Resolves a reference relative to the given informations.
+ *
+ * @param scopeInfo
+ * Scope information to use.
+ *
+ * @param deconstructInfo
+ * Deconstruct information to use.
+ *
+ * @param referenceName
+ * Reference name to resolve.
+ *
+ * @return
+ * Resolved information or `undefined`.
+ */
+function resolveReferenceInDeconstructInfo (
+    scopeInfo: (NamespaceInfo|SourceInfo),
+    deconstructInfo: DeconstructInfo,
+    referenceName: string
+): (CodeInfo|undefined) {
+    const _deconstructs = deconstructInfo.deconstructs;
+    const _referenceSplit = referenceName.split(/\W+/gsu);
+    const _referenceCurrent = _referenceSplit.shift();
+    const _referenceNext = _referenceSplit.join('.');
+
+    let _found: (string|undefined);
+
+    for (const _original of Object.keys(_deconstructs || [])) {
+        if (_deconstructs[_original] === _referenceCurrent) {
+            _found = _original;
+            break;
+        }
+    }
+
+    if (_found) {
+
+        if (_referenceNext) {
+            return resolveReferenceInChildInfos(
+                scopeInfo,
+                (
+                    scopeInfo.kind === 'Source' ?
+                        scopeInfo.code :
+                        scopeInfo.members
+                ),
+                (
+                    deconstructInfo.from ?
+                        `${_found}.${_referenceNext}` :
+                        _found
+                )
+            );
+        }
+
+    }
+
+    return void 0;
+}
+
+
+/**
+ * Resolves a reference relative to the given informations.
+ *
+ * @param scopeInfo
+ * Scope information to use.
+ *
+ * @param exportInfo
+ * Export information to use.
+ *
+ * @param referenceName
+ * Reference name to resolve.
+ *
+ * @return
+ * Resolved information or `undefined`.
+ */
+function resolveReferenceInExportInfo (
+    scopeInfo: (NamespaceInfo|SourceInfo),
+    exportInfo: ExportInfo,
+    referenceName: string
+): (CodeInfo|undefined) {
+    const _referenceSplit = referenceName.split(/\W+/gsu);
+    const _referenceCurrent = _referenceSplit.shift();
+    const _referenceNext = _referenceSplit.join('.');
+
+    if (
+        _referenceCurrent !== 'default' ||
+        !exportInfo.flags ||
+        !exportInfo.flags.includes('default')
+    ) {
+        return void 0;
+    }
+
+    const _exportValue = exportInfo.value;
+
+    if (
+        !_exportValue ||
+        typeof _exportValue !== 'object'
+    ) {
+        return exportInfo;
+    }
+
+    if (_exportValue.kind === 'Reference') {
+        return resolveReferenceInChildInfos(
+            scopeInfo,
+            (
+                scopeInfo.kind === 'Source' ?
+                    scopeInfo.code :
+                    scopeInfo.members
+            ),
+            (
+                _referenceNext ?
+                    `${_exportValue.name}.${_referenceNext}` :
+                    _exportValue.name
+            )
+        );
+    }
+
+    if (_referenceNext) {
+        return resolveReferenceInChildInfos(
+            scopeInfo,
+            [_exportValue],
+            _referenceNext
+        );
+    }
+
+    return _exportValue;
+}
+
+
+/**
+ * Resolves a reference relative to the given informations.
+ *
+ * @param importInfo
+ * Import information to use.
+ *
+ * @param referenceName
+ * Reference name to resolve.
+ *
+ * @return
+ * Resolved information or `undefined`.
+ */
+function resolveReferenceInImportInfo (
+    importInfo: ImportInfo,
+    referenceName: string
+): CodeInfo|undefined {
+    const _referenceSplit = referenceName.split(/\W+/gsu);
+    const _referenceCurrent = _referenceSplit.shift();
+    const _referenceNext = _referenceSplit.join('.');
+
+    let _found: (string|undefined);
+
+    for (const _original of Object.keys(importInfo.imports || [])) {
+        if (importInfo.imports[_original] === _referenceCurrent) {
+            _found = _original;
+            break;
+        }
+    }
+
+    if (_found) {
+        const _from = Path.join(
+            Path.dirname(importInfo.meta.file),
+            importInfo.from
+        );
+
+        let _sourceInfo: (SourceInfo|undefined);
+
+        if (
+            _from.match(SOURCE_EXTENSION) &&
+            FS.lstatSync(Path.join(_from.replace(JSX, '\.t$1'))).isFile()
+        ) {
+            _sourceInfo = getSourceInfo(
+                _from.replace(JSX, '\.t$1'),
+                void 0,
+                !!importInfo.node
+            );
+        } else if (FS.lstatSync(Path.join(`${_from}.ts`)).isFile()) {
+            _sourceInfo =
+                getSourceInfo(`${_from}.ts`, void 0, !!importInfo.node);
+        } else if (FS.lstatSync(Path.join(`${_from}.d.ts`)).isFile()) {
+            _sourceInfo =
+                getSourceInfo(`${_from}.d.ts`, void 0, !!importInfo.node);
+        } else {
+            return importInfo;
+        }
+
+        return resolveReferenceInChildInfos(
+            _sourceInfo,
+            _sourceInfo.code,
+            (_referenceNext ? `${_found}.${_referenceNext}` : _found)
+        );
+    }
+
+    return void 0;
+}
+
+
+/**
+ * Resolves a reference relative to the given informations.
+ *
+ * @param scopeInfo
+ * Scope information to use.
+ *
+ * @param objectInfo
+ * Object information to use.
+ *
+ * @param referenceName
+ * Reference name to resolve.
+ *
+ * @return
+ * Resolved information or `undefined`.
+ */
+function resolveReferenceInObjectInfo (
+    scopeInfo: (NamespaceInfo|SourceInfo),
+    objectInfo: ObjectInfo,
+    referenceName: string
+): (CodeInfo|undefined) {
+    const _referenceSplit = referenceName.split(/\W+/gsu);
+    const _nextReferenceName = _referenceSplit.shift();
+    const _restReferenceName = _referenceSplit.join('.');
+
+    for (const _member of objectInfo.members) {
+        if (extractInfoName(_member) === _nextReferenceName) {
+            if (!_restReferenceName) {
+                return _member;
+            }
+            if (_member.kind === 'Property') {
+                return resolveReferenceInChildInfos(
+                    scopeInfo,
+                    [_member],
+                    _restReferenceName
+                );
+            }
+        }
+    }
+
+    return void 0;
+}
+
+
+/**
+ * Resolves a reference relative to the given informations.
+ *
+ * @param scopeInfo
+ * Scope information to use.
+ *
+ * @param types
+ * Type information to resolve.
+ *
+ * @param referenceName
+ * Reference name to resolve.
+ *
+ * @return
+ * Resolved information or `undefined`.
+ */
+function resolveReferenceInType (
+    scopeInfo: (NamespaceInfo|SourceInfo),
+    types: Array<string>,
+    referenceName?: string
+): (CodeInfo|undefined) {
+    const _resolvedInfos: Array<CodeInfo> = [];
+
+    let _resolvedInfo: (CodeInfo|undefined);
+
+    for (const _type of extractTypes(types)) {
+
+        _resolvedInfo = resolveReference(
+            scopeInfo,
+            (referenceName ? `${_type}.${referenceName}` : _type)
+        );
+
+        if (_resolvedInfo) {
+            _resolvedInfos.push(_resolvedInfo);
+        }
+
+    }
+
+    if (_resolvedInfos.length > 1) {
+        return {
+            kind: 'Array',
+            meta: newMeta(scopeInfo.kind === 'Source' ? void 0 : scopeInfo.meta),
+            value: _resolvedInfos.slice() as Array<Value>
+        };
+    }
+
+    return _resolvedInfos[0];
+}
+
+
+/**
+ * Sanitize source path from file extensions.
+ *
+ * @param sourcePath
+ * Source path to sanitize.
+ *
+ * @return
+ * Sanitized source path.
+ */
+function sanitizeSourcePath (
+    sourcePath: string
+): string {
+    return sourcePath.replace(SOURCE_EXTENSION, '');
+}
+
+
+/**
+ * Sanitize text from surrounding quote characters.
+ *
+ * @param text
+ * Text to sanitize.
+ *
+ * @return
+ * Sanitized text.
+ */
+function sanitizeText (
+    text: string
+): string {
+    return ('' + text).replace(SANITIZE_TEXT, '$2');
+}
+
+
+/**
+ * Sanitize type from surrounding paranthesis characters.
+ *
+ * @param type
+ * Type to sanitize.
+ *
+ * @return
+ * Sanitized type.
+ */
+function sanitizeType (
+    type: string
+): string {
+    type = trimBetween(`${type}`, true);
+
+    if (type.includes('=>')) {
+        return type.trim();
+    }
+
+    return type.replace(new RegExp(SANITIZE_TYPE.source, 'gu'), '$1').trim();
+}
+
+
+/**
+ * Removes all spaces in the given text.
+ *
+ * @param text
+ * Text to trim.
+ *
+ * @param keepSeparate
+ * Replaces spaces with a single space character.
+ *
+ * @return
+ * Trimmed text.
+ */
+function trimBetween (
+    text: string,
+    keepSeparate?: boolean
+): string {
+    return text.replace(/\s+/gsu, (keepSeparate ? ' ' : ''));
+}
+
+
+/**
+ * Compiles doclet information into a code string.
+ *
+ * @see changeSourceCode
+ *
+ * @param doclet
+ * Doclet information to compile.
+ *
+ * @param indent
+ * Indent styling.
+ *
+ * @return
+ * Doclet string.
+ */
+export function toDocletString (
+    doclet: DocletInfo,
+    indent: (number|string) = 0
+): string {
+
+    if (typeof indent === 'number') {
+        indent = ''.padEnd(indent, ' ');
+    }
+
+    if (indent[0] !== '\n') {
+        indent = '\n' + indent;
+    }
+
+    const tags = doclet.tags;
+    const tagKeys = Object.keys(tags);
+
+    let compiled = indent + '/**';
+
+    if (
+        tags.description &&
+        (
+            tags.description.length <= 1 ||
+            tags.description[1][0] !== '{'
+        )
+    ) {
+        compiled += (
+            indent + ' * ' +
+            tags.description
+                .join('\n\n')
+                .trim()
+                .split('\n')
+                .join(indent + ' * ')
+        );
+        tagKeys.splice(tagKeys.indexOf('description'), 1);
+    }
+
+    for (const tag of tagKeys) {
+        for (const text of tags[tag]) {
+            compiled += (
+                indent + ' *' +
+                indent + ' * @' + tag + ' ' +
+                text
+                    .trim()
+                    .split('\n')
+                    .map(line => line.trim())
+                    .join(indent + ' * ' + ''.padEnd(tag.length + 2, ' '))
+            );
+        }
+    }
+
+    compiled = compiled
+        .split('\n')
+        .map(line => {
+            line = line.trimEnd();
+            if (line.length > 80) {
+                const br = line.substring(0, 80).lastIndexOf(' ');
+                if (br >= 40) {
+                    return (
+                        line.substring(0, br) +
+                        indent + ' * ' + line.substring(br)
+                    );
+                }
+            }
+            return line;
+        })
+        .join('\n');
+
+    return compiled + indent + ' */\n';
+}
+
+
+/* *
+ *
+ *  Default Export
+ *
+ * */
+
+
+export * as default from './TS';