From 6fdf789f545fe9baa1d5cd028dc3b3eddb690937 Mon Sep 17 00:00:00 2001
From: Andy <anhans@microsoft.com>
Date: Thu, 6 Oct 2016 07:07:45 -0700
Subject: [PATCH 01/24] Types 2.0: Move UUID.js and add type definitions for
 npm package uuid (#11785)

* Move UUID.js type definitions from uuid to uuidjs

Issue: #10766

* Add type definitions for npm package: uuid

Issue: #10766

* Minor fix in uuidjs tests file

* Clean up UUID types

* Convert to external module
* Formatting fixes
* Allow the `export = uuid` to be called as a function directly
---
 uuid/index.d.ts                | 101 +++++++++------------------------
 uuid/tsconfig.json             |   2 +-
 uuid/uuid-tests.ts             |  31 ++++++++++
 {uuid => uuidjs}/UUID-tests.ts |   2 +-
 uuidjs/index.d.ts              |  82 ++++++++++++++++++++++++++
 uuidjs/tsconfig.json           |  19 +++++++
 6 files changed, 161 insertions(+), 76 deletions(-)
 create mode 100644 uuid/uuid-tests.ts
 rename {uuid => uuidjs}/UUID-tests.ts (98%)
 create mode 100644 uuidjs/index.d.ts
 create mode 100644 uuidjs/tsconfig.json

diff --git a/uuid/index.d.ts b/uuid/index.d.ts
index 24ab5eb160..2fd5467e3e 100644
--- a/uuid/index.d.ts
+++ b/uuid/index.d.ts
@@ -1,82 +1,35 @@
-// Type definitions for UUID.js v3.3.0
-// Project: https://github.com/LiosK/UUID.js
-// Definitions by: Jason Jarrett <https://github.com/staxmanade/>
+// Type definitions for uuid v2.0.3
+// Project: https://github.com/defunctzombie/node-uuid
+// Definitions by: Oliver Hoffmann <https://github.com/iamolivinius/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
+/// <reference types="node" />
 
+declare namespace uuid {
+	interface V1Options {
+		node?: number[];
+		clockseq?: number;
+		msecs?: number | Date;
+		nsecs?: number;
+	}
 
-interface UUID {
-    intFields: UUIDArray<number>;
-    bitFields: UUIDArray<string>;
-    hexFields: UUIDArray<string>;
-    version: number;
-    bitString: string;
-    hexString: string;
-    urn: string;
+	type V4Options = { random: number[] } | { rng: () => number[]; }
 
+	interface UuidStatic {
+		(options?: V4Options): string;
+		(options: V4Options | null, buffer: number[], offset?: number): number[];
+		(options: V4Options | null, buffer: Buffer, offset?: number): Buffer;
 
-    /**
-     * Tests if two {@link UUID} objects are equal.
-     * @param {UUID} uuid
-     * @returns {bool} True if two {@link UUID} objects are equal.
-     */
-    equals(uuid: UUID): boolean;
-
-    /**
-     * Returns UUID string representation.
-     * @returns {string} {@link UUID#hexString}.
-     */
-    toString(): string;
+		v1(options?: V1Options): string;
+		v1(options: V1Options | null, buffer: number[], offset?: number): number[];
+		v1(options: V1Options | null, buffer: Buffer, offset?: number): Buffer;
+		v4: UuidStatic;
+		parse(id: string): number[];
+		parse(id: string, buffer: number[], offset?: number): number[];
+		parse(id: string, buffer: Buffer, offset?: number): Buffer;
+		unparse(buffer: number[] | Buffer, offset?: number): string;
+	}
 }
 
-interface UUIDArray<T> extends Array<T> {
-    timeLow: string;
-    timeMid: string;
-    timeHiAndVersion: string;
-    clockSeqHiAndReserved: string;
-    clockSeqLow: string;
-    node: string;
-}
-
-/**
- * The simplest function to get an UUID string.
- * @returns {string} A version 4 UUID string.
- */
-export declare function generate(): string;
-
-/**
- * Generates a version 4 {@link UUID}.
- * @returns {UUID} A version 4 {@link UUID} object.
- * @since 3.0
- */
-export declare function genV4(): UUID;
-
-
-/**
- * Generates a version 1 {@link UUID}.
- * @returns {UUID} A version 1 {@link UUID} object.
- * @since 3.0
- */
-export declare function genV1(): UUID;
-
-/**
- * Converts hexadecimal UUID string to an {@link UUID} object.
- * @param {string} uuid UUID hexadecimal string representation ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
- * @returns {UUID} {@link UUID} object or null.
- * @since 3.0
- */
-export declare function parse(uuid: string): UUID;
-
-
-/**
- * Re-initializes version 1 UUID state.
- * @since 3.0
- */
-export declare function resetState(): void;
-
-/**
- * Reinstalls {@link UUID.generate} method to emulate the interface of UUID.js version 2.x.
- * @since 3.1
- * @deprecated Version 2.x. compatible interface is not recommended.
- */
-export declare function makeBackwardCompatible(): void;
+declare const uuid: uuid.UuidStatic
+export = uuid
diff --git a/uuid/tsconfig.json b/uuid/tsconfig.json
index 07fa3344c9..02a01e4383 100644
--- a/uuid/tsconfig.json
+++ b/uuid/tsconfig.json
@@ -16,4 +16,4 @@
         "index.d.ts",
         "uuid-tests.ts"
     ]
-}
\ No newline at end of file
+}
diff --git a/uuid/uuid-tests.ts b/uuid/uuid-tests.ts
new file mode 100644
index 0000000000..2dd5ea7f46
--- /dev/null
+++ b/uuid/uuid-tests.ts
@@ -0,0 +1,31 @@
+import uuid = require('uuid');
+
+let uuidv1: string = uuid.v1();
+
+uuidv1 = uuid.v1({
+	node: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab],
+	clockseq: 0x1234,
+	msecs: new Date('2011-11-01').getTime(),
+	nsecs: 5678
+});
+
+let bufferv1: number[] = new Array(32);
+bufferv1 = uuid.v1(null, bufferv1);
+bufferv1 = uuid.v1(null, bufferv1, 16);
+
+let uuidv4: string = uuid.v4();
+
+const randoms = [
+	0x10, 0x91, 0x56, 0xbe, 0xc4, 0xfb, 0xc1, 0xea,
+	0x71, 0xb4, 0xef, 0xe1, 0x67, 0x1c, 0x58, 0x36
+];
+uuidv4 = uuid({ random: randoms });
+uuidv4 = uuid({ rng: () => randoms })
+
+let bufferv4: number[] = new Array(32);
+bufferv4 = uuid(null, bufferv4);
+bufferv4 = uuid(null, bufferv4, 16);
+
+let nodeBufferv4 = Buffer.alloc(32);
+nodeBufferv4 = uuid.v4(null, nodeBufferv4);
+nodeBufferv4 = uuid.v4(null, nodeBufferv4, 16);
diff --git a/uuid/UUID-tests.ts b/uuidjs/UUID-tests.ts
similarity index 98%
rename from uuid/UUID-tests.ts
rename to uuidjs/UUID-tests.ts
index 2ba8fa57eb..51bed1c700 100644
--- a/uuid/UUID-tests.ts
+++ b/uuidjs/UUID-tests.ts
@@ -1,4 +1,4 @@
-import UUID = require("uuid");
+import UUID = require("uuidjs");
 
 const uuid1: string = UUID.generate()
 const uuid2: UUID.UUID = UUID.genV4()
diff --git a/uuidjs/index.d.ts b/uuidjs/index.d.ts
new file mode 100644
index 0000000000..24ab5eb160
--- /dev/null
+++ b/uuidjs/index.d.ts
@@ -0,0 +1,82 @@
+// Type definitions for UUID.js v3.3.0
+// Project: https://github.com/LiosK/UUID.js
+// Definitions by: Jason Jarrett <https://github.com/staxmanade/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+
+interface UUID {
+    intFields: UUIDArray<number>;
+    bitFields: UUIDArray<string>;
+    hexFields: UUIDArray<string>;
+    version: number;
+    bitString: string;
+    hexString: string;
+    urn: string;
+
+
+    /**
+     * Tests if two {@link UUID} objects are equal.
+     * @param {UUID} uuid
+     * @returns {bool} True if two {@link UUID} objects are equal.
+     */
+    equals(uuid: UUID): boolean;
+
+    /**
+     * Returns UUID string representation.
+     * @returns {string} {@link UUID#hexString}.
+     */
+    toString(): string;
+}
+
+interface UUIDArray<T> extends Array<T> {
+    timeLow: string;
+    timeMid: string;
+    timeHiAndVersion: string;
+    clockSeqHiAndReserved: string;
+    clockSeqLow: string;
+    node: string;
+}
+
+/**
+ * The simplest function to get an UUID string.
+ * @returns {string} A version 4 UUID string.
+ */
+export declare function generate(): string;
+
+/**
+ * Generates a version 4 {@link UUID}.
+ * @returns {UUID} A version 4 {@link UUID} object.
+ * @since 3.0
+ */
+export declare function genV4(): UUID;
+
+
+/**
+ * Generates a version 1 {@link UUID}.
+ * @returns {UUID} A version 1 {@link UUID} object.
+ * @since 3.0
+ */
+export declare function genV1(): UUID;
+
+/**
+ * Converts hexadecimal UUID string to an {@link UUID} object.
+ * @param {string} uuid UUID hexadecimal string representation ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
+ * @returns {UUID} {@link UUID} object or null.
+ * @since 3.0
+ */
+export declare function parse(uuid: string): UUID;
+
+
+/**
+ * Re-initializes version 1 UUID state.
+ * @since 3.0
+ */
+export declare function resetState(): void;
+
+/**
+ * Reinstalls {@link UUID.generate} method to emulate the interface of UUID.js version 2.x.
+ * @since 3.1
+ * @deprecated Version 2.x. compatible interface is not recommended.
+ */
+export declare function makeBackwardCompatible(): void;
diff --git a/uuidjs/tsconfig.json b/uuidjs/tsconfig.json
new file mode 100644
index 0000000000..559d117755
--- /dev/null
+++ b/uuidjs/tsconfig.json
@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "UUID-tests.ts"
+    ]
+}

From 026bbfeb7a0467c63cdd1df563129bb6499b6709 Mon Sep 17 00:00:00 2001
From: Birunthan Mohanathas <birunthan@mohanathas.com>
Date: Thu, 6 Oct 2016 07:37:30 -0700
Subject: [PATCH 02/24] Update Electron.WebContents (#11748)

* electron: Remove WebContents.getFavicon()

This was removed in electron/electron#1554

* electron: Add missing WebContents.{isDestroyed,isFocused}

See http://electron.atom.io/docs/api/web-contents
---
 electron/index.d.ts | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/electron/index.d.ts b/electron/index.d.ts
index 3344847224..612e9e4ab0 100644
--- a/electron/index.d.ts
+++ b/electron/index.d.ts
@@ -3967,9 +3967,13 @@ declare namespace Electron {
 		 */
 		getTitle(): string;
 		/**
-		 * @returns The favicon of the web page.
+		 * @returns Whether the web page is destroyed.
 		 */
-		getFavicon(): NativeImage;
+		isDestroyed(): boolean;
+		/**
+		 * @returns Whether the web page is focused.
+		 */
+		isFocused(): boolean;
 		/**
 		 * @returns Whether web page is still loading resources.
 		 */

From 6881f23823d26e08544e2eae0776b4be45e0b1fc Mon Sep 17 00:00:00 2001
From: Rogier Schouten <rogierschouten@users.noreply.github.com>
Date: Thu, 6 Oct 2016 18:41:35 +0200
Subject: [PATCH 03/24] update lolex typings to 1.5.1 (#11762)

---
 lolex/index.d.ts     |  7 ++++++-
 lolex/lolex-tests.ts | 11 +++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/lolex/index.d.ts b/lolex/index.d.ts
index 27052b54a5..544fb88fb6 100644
--- a/lolex/index.d.ts
+++ b/lolex/index.d.ts
@@ -1,10 +1,12 @@
-// Type definitions for lolex 1.2.1
+// Type definitions for lolex 1.5.1
 // Project: https://github.com/sinonjs/lolex
 // Definitions by: Wim Looman <https://github.com/Nemo157>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 
 export interface Clock {
+    now: number;
+
     setTimeout(callback: () => any, timeout: number): number;
     setInterval(callback: () => any, timeout: number): number;
     setImmediate(callback: () => any): number;
@@ -13,6 +15,9 @@ export interface Clock {
     clearInterval(id: number): void;
     clearImmediate(id: number): void;
 
+    setSystemTime(now: number): void;
+    setSystemTime(date: Date): void;
+
     tick(ms: number): void;
     uninstall(): void;
 }
diff --git a/lolex/lolex-tests.ts b/lolex/lolex-tests.ts
index 8f2c96a1c7..00feecfdd6 100644
--- a/lolex/lolex-tests.ts
+++ b/lolex/lolex-tests.ts
@@ -57,6 +57,11 @@ clock = lolex.install(window, Date.now(), ['setTimeout', 'clearTimeout']);
 clock = lolex.install(Date.now());
 clock = lolex.install(Date.now(), ['setTimeout', 'clearTimeout']);
 
+/**
+ * clock.now
+ */
+var n: number = clock.now;
+
 
 var id: number;
 /**
@@ -100,6 +105,11 @@ id = clock.setImmediate(() => {});
 
 clock.clearImmediate(id);
 
+/**
+ * clock.setSystemTime
+ */
+clock.setSystemTime(0);
+clock.setSystemTime(new Date());
 
 /**
  * clock.tick(time)
@@ -113,3 +123,4 @@ clock.tick(1000);
  */
 
 clock.uninstall();
+

From 159ba3fc8f85b39df08cf4d69fe689c78414bb6e Mon Sep 17 00:00:00 2001
From: Rogier Schouten <rogierschouten@users.noreply.github.com>
Date: Thu, 6 Oct 2016 18:42:04 +0200
Subject: [PATCH 04/24] add method privateKeyToOpenSSH() to node-forge (#11763)

---
 node-forge/index.d.ts          | 7 +++++++
 node-forge/node-forge-tests.ts | 2 ++
 2 files changed, 9 insertions(+)

diff --git a/node-forge/index.d.ts b/node-forge/index.d.ts
index 7e0cae19df..b39ede7ac4 100644
--- a/node-forge/index.d.ts
+++ b/node-forge/index.d.ts
@@ -34,4 +34,11 @@ declare module "node-forge" {
       export function generateKeyPair(options?: GenerateKeyPairOptions, callback?: (err: Error, keypair: KeyPair) => void): KeyPair;
     }
   }
+
+  export namespace ssh {
+    /**
+     * Encodes a private RSA key as an OpenSSH file.
+     */
+    export function privateKeyToOpenSSH(privateKey?: string, passphrase?: string): string;
+  }
 }
diff --git a/node-forge/node-forge-tests.ts b/node-forge/node-forge-tests.ts
index 16538ad84f..7ed36e50e2 100644
--- a/node-forge/node-forge-tests.ts
+++ b/node-forge/node-forge-tests.ts
@@ -3,3 +3,5 @@ import * as forge from "node-forge";
 let keypair = forge.pki.rsa.generateKeyPair({bits: 512});
 let privateKeyPem = forge.pki.privateKeyToPem(keypair.privateKey);
 let publicKeyPem = forge.pki.publicKeyToPem(keypair.publicKey);
+
+let x: string = forge.ssh.privateKeyToOpenSSH();

From dc86842627e2c900098652a43558bbccedc3dbb4 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Thu, 6 Oct 2016 09:43:47 -0700
Subject: [PATCH 05/24] Make moment dependency use open ranges (#11547)

* Make moment dependency use `>` instead of fixed version

* Remove unused file

* Use moment.MomentFormatSpecification

* Add dependency on moment
---
 angular-bootstrap-calendar/package.json        |  2 +-
 bootstrap.v3.datetimepicker/package.json       |  2 +-
 business-rules-engine/package.json             |  2 +-
 daterangepicker/package.json                   |  2 +-
 eonasdan-bootstrap-datetimepicker/package.json |  2 +-
 fullcalendar/package.json                      |  2 +-
 jquery.livestampjs/package.json                |  2 +-
 moment-jalaali/package.json                    |  2 +-
 moment-range/package.json                      |  2 +-
 moment-timezone/index.d.ts                     | 11 ++++-------
 moment-timezone/package.json                   |  2 +-
 pikaday/package.json                           |  2 +-
 react-datepicker/package.json                  |  2 +-
 react-daterange-picker/package.json            |  8 ++++----
 react-daterange-picker/tsconfig.json           |  3 +++
 twix/package.json                              |  2 +-
 16 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/angular-bootstrap-calendar/package.json b/angular-bootstrap-calendar/package.json
index 992b24d513..4c6d24a445 100644
--- a/angular-bootstrap-calendar/package.json
+++ b/angular-bootstrap-calendar/package.json
@@ -1,5 +1,5 @@
 {
     "dependencies": {
-        "moment": "2.14.*"
+        "moment": ">=2.14.0"
     }
 }
\ No newline at end of file
diff --git a/bootstrap.v3.datetimepicker/package.json b/bootstrap.v3.datetimepicker/package.json
index 992b24d513..4c6d24a445 100644
--- a/bootstrap.v3.datetimepicker/package.json
+++ b/bootstrap.v3.datetimepicker/package.json
@@ -1,5 +1,5 @@
 {
     "dependencies": {
-        "moment": "2.14.*"
+        "moment": ">=2.14.0"
     }
 }
\ No newline at end of file
diff --git a/business-rules-engine/package.json b/business-rules-engine/package.json
index c4decef904..d33ff913ce 100644
--- a/business-rules-engine/package.json
+++ b/business-rules-engine/package.json
@@ -1,5 +1,5 @@
 {
     "dependencies": {
-        "moment": "2.14.*"
+        "moment": ">=2.14.0"
     }
 }
diff --git a/daterangepicker/package.json b/daterangepicker/package.json
index 992b24d513..4c6d24a445 100644
--- a/daterangepicker/package.json
+++ b/daterangepicker/package.json
@@ -1,5 +1,5 @@
 {
     "dependencies": {
-        "moment": "2.14.*"
+        "moment": ">=2.14.0"
     }
 }
\ No newline at end of file
diff --git a/eonasdan-bootstrap-datetimepicker/package.json b/eonasdan-bootstrap-datetimepicker/package.json
index 992b24d513..4c6d24a445 100644
--- a/eonasdan-bootstrap-datetimepicker/package.json
+++ b/eonasdan-bootstrap-datetimepicker/package.json
@@ -1,5 +1,5 @@
 {
     "dependencies": {
-        "moment": "2.14.*"
+        "moment": ">=2.14.0"
     }
 }
\ No newline at end of file
diff --git a/fullcalendar/package.json b/fullcalendar/package.json
index c4decef904..d33ff913ce 100644
--- a/fullcalendar/package.json
+++ b/fullcalendar/package.json
@@ -1,5 +1,5 @@
 {
     "dependencies": {
-        "moment": "2.14.*"
+        "moment": ">=2.14.0"
     }
 }
diff --git a/jquery.livestampjs/package.json b/jquery.livestampjs/package.json
index c4decef904..d33ff913ce 100644
--- a/jquery.livestampjs/package.json
+++ b/jquery.livestampjs/package.json
@@ -1,5 +1,5 @@
 {
     "dependencies": {
-        "moment": "2.14.*"
+        "moment": ">=2.14.0"
     }
 }
diff --git a/moment-jalaali/package.json b/moment-jalaali/package.json
index 992b24d513..4c6d24a445 100644
--- a/moment-jalaali/package.json
+++ b/moment-jalaali/package.json
@@ -1,5 +1,5 @@
 {
     "dependencies": {
-        "moment": "2.14.*"
+        "moment": ">=2.14.0"
     }
 }
\ No newline at end of file
diff --git a/moment-range/package.json b/moment-range/package.json
index 992b24d513..4c6d24a445 100644
--- a/moment-range/package.json
+++ b/moment-range/package.json
@@ -1,5 +1,5 @@
 {
     "dependencies": {
-        "moment": "2.14.*"
+        "moment": ">=2.14.0"
     }
 }
\ No newline at end of file
diff --git a/moment-timezone/index.d.ts b/moment-timezone/index.d.ts
index 030c09270b..6d45938c18 100644
--- a/moment-timezone/index.d.ts
+++ b/moment-timezone/index.d.ts
@@ -20,19 +20,16 @@ declare namespace MomentTimezone {
         parse(timestamp: number): number
     }
 
-    type MomentFormatSpecification =
-        string | (() => void) | (string | (() => void))[];
-
     interface MomentTimezone {
         (): moment.Moment;
         (timezone: string): moment.Moment;
         (date: number, timezone: string): moment.Moment;
         (date: number[], timezone: string): moment.Moment;
         (date: string, timezone: string): moment.Moment;
-        (date: string, format: MomentFormatSpecification, timezone: string): moment.Moment;
-        (date: string, format: MomentFormatSpecification, strict: boolean, timezone: string): moment.Moment;
-        (date: string, format: MomentFormatSpecification, language: string, timezone: string): moment.Moment;
-        (date: string, format: MomentFormatSpecification, language: string, strict: boolean, timezone: string): moment.Moment;
+        (date: string, format: moment.MomentFormatSpecification, timezone: string): moment.Moment;
+        (date: string, format: moment.MomentFormatSpecification, strict: boolean, timezone: string): moment.Moment;
+        (date: string, format: moment.MomentFormatSpecification, language: string, timezone: string): moment.Moment;
+        (date: string, format: moment.MomentFormatSpecification, language: string, strict: boolean, timezone: string): moment.Moment;
         (date: Date, timezone: string): moment.Moment;
         (date: moment.Moment, timezone: string): moment.Moment;
         (date: Object, timezone: string): moment.Moment;
diff --git a/moment-timezone/package.json b/moment-timezone/package.json
index c4decef904..d33ff913ce 100644
--- a/moment-timezone/package.json
+++ b/moment-timezone/package.json
@@ -1,5 +1,5 @@
 {
     "dependencies": {
-        "moment": "2.14.*"
+        "moment": ">=2.14.0"
     }
 }
diff --git a/pikaday/package.json b/pikaday/package.json
index c4decef904..d33ff913ce 100644
--- a/pikaday/package.json
+++ b/pikaday/package.json
@@ -1,5 +1,5 @@
 {
     "dependencies": {
-        "moment": "2.14.*"
+        "moment": ">=2.14.0"
     }
 }
diff --git a/react-datepicker/package.json b/react-datepicker/package.json
index 992b24d513..4c6d24a445 100644
--- a/react-datepicker/package.json
+++ b/react-datepicker/package.json
@@ -1,5 +1,5 @@
 {
     "dependencies": {
-        "moment": "2.14.*"
+        "moment": ">=2.14.0"
     }
 }
\ No newline at end of file
diff --git a/react-daterange-picker/package.json b/react-daterange-picker/package.json
index bfdab7b7fe..4c6d24a445 100644
--- a/react-daterange-picker/package.json
+++ b/react-daterange-picker/package.json
@@ -1,5 +1,5 @@
 {
-  "scripts": {
-    "postinstall": "cd ../moment-range && npm install"
-  }
-}
+    "dependencies": {
+        "moment": ">=2.14.0"
+    }
+}
\ No newline at end of file
diff --git a/react-daterange-picker/tsconfig.json b/react-daterange-picker/tsconfig.json
index b0493165b7..658e569c10 100644
--- a/react-daterange-picker/tsconfig.json
+++ b/react-daterange-picker/tsconfig.json
@@ -8,6 +8,9 @@
         "typeRoots": [
             "../"
         ],
+        "paths": {
+            "*": ["*", "react-daterange-picker/node_modules/*"]
+        },
         "types": ["moment-range", "react"],
         "noEmit": true,
         "forceConsistentCasingInFileNames": true,
diff --git a/twix/package.json b/twix/package.json
index 992b24d513..4c6d24a445 100644
--- a/twix/package.json
+++ b/twix/package.json
@@ -1,5 +1,5 @@
 {
     "dependencies": {
-        "moment": "2.14.*"
+        "moment": ">=2.14.0"
     }
 }
\ No newline at end of file

From 9d5fc54dd54647206ad9b83514b11a4548867216 Mon Sep 17 00:00:00 2001
From: Guilherme Oenning <me@goenning.net>
Date: Thu, 6 Oct 2016 13:54:55 -0300
Subject: [PATCH 06/24] headers was renamted to header. closes #11159 (#11773)

---
 jsonwebtoken/index.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/jsonwebtoken/index.d.ts b/jsonwebtoken/index.d.ts
index 4cdbf3d924..15790f7547 100644
--- a/jsonwebtoken/index.d.ts
+++ b/jsonwebtoken/index.d.ts
@@ -46,7 +46,7 @@ export interface SignOptions {
     issuer?: string;
     jwtid?: string;
     noTimestamp?: boolean;
-    headers?: Object;
+    header?: Object;
     encoding?: string;
 }
 

From 428195bee21d60868efcb2dbcb90b7ab01b88aa4 Mon Sep 17 00:00:00 2001
From: Rogier Schouten <rogierschouten@users.noreply.github.com>
Date: Thu, 6 Oct 2016 18:56:16 +0200
Subject: [PATCH 07/24] Improve temp function signatures (#11774)

---
 temp/index.d.ts    | 45 ++++++++++++++++++++++++++++-----------------
 temp/temp-tests.ts |  9 +++++----
 2 files changed, 33 insertions(+), 21 deletions(-)

diff --git a/temp/index.d.ts b/temp/index.d.ts
index bb2f1abbf7..a6b6f42ace 100644
--- a/temp/index.d.ts
+++ b/temp/index.d.ts
@@ -8,34 +8,45 @@
 import * as temp from "temp";
 import * as fs from "fs";
 
+export interface OpenFile {
+  path: string;
+  fd: number;
+}
+
+export interface Stats {
+  files: number;
+  dirs: number;
+}
+
 export interface AffixOptions {
-    prefix?: string;
-    suffix?: string;
-    dir?: string;
+  prefix?: string;
+  suffix?: string;
+  dir?: string;
 }
 
 export declare var dir: string;
 
 export declare function track(value?: boolean): typeof temp;
 
-export declare function mkdir(affixes: string, callback?: (err: any, dirPath: string) => void): void;
-export declare function mkdir(affixes: AffixOptions, callback?: (err: any, dirPath: string) => void): void;
+export declare function mkdir(affixes?: string, callback?: (err: any, dirPath: string) => void): void;
+export declare function mkdir(affixes?: AffixOptions, callback?: (err: any, dirPath: string) => void): void;
 
-export declare function mkdirSync(affixes: string): string;
-export declare function mkdirSync(affixes: AffixOptions): string;
+export declare function mkdirSync(affixes?: string): string;
+export declare function mkdirSync(affixes?: AffixOptions): string;
 
-export declare function open(affixes: string, callback?: (err: any, result: { path: string, fd: number }) => void): void;
-export declare function open(affixes: AffixOptions, callback?: (err: any, result: { path: string, fd: number }) => void): void;
+export declare function open(affixes?: string, callback?: (err: any, result: OpenFile) => void): void;
+export declare function open(affixes?: AffixOptions, callback?: (err: any, result: OpenFile) => void): void;
 
-export declare function openSync(affixes: string): { path: string, fd: number };
-export declare function openSync(affixes: AffixOptions): { path: string, fd: number };
+export declare function openSync(affixes?: string): OpenFile;
+export declare function openSync(affixes?: AffixOptions): OpenFile;
 
-export declare function path(affixes: string, defaultPrefix?: string): string;
-export declare function path(affixes: AffixOptions, defaultPrefix?: string): string;
+export declare function path(affixes?: string, defaultPrefix?: string): string;
+export declare function path(affixes?: AffixOptions, defaultPrefix?: string): string;
 
-export declare function cleanup(callback?: (result: boolean | { files: number, dirs?: number }) => void): void;
+export declare function cleanup(callback?: (result: boolean | Stats) => void): void;
 
-export declare function cleanupSync(): boolean | { files: number, dirs: number };
+export declare function cleanupSync(): boolean | Stats;
+
+export declare function createWriteStream(affixes?: string): fs.WriteStream;
+export declare function createWriteStream(affixes?: AffixOptions): fs.WriteStream;
 
-export declare function createWriteStream(affixes: string): fs.WriteStream;
-export declare function createWriteStream(affixes: AffixOptions): fs.WriteStream;
diff --git a/temp/temp-tests.ts b/temp/temp-tests.ts
index 3f8ed01327..78eff82298 100644
--- a/temp/temp-tests.ts
+++ b/temp/temp-tests.ts
@@ -16,7 +16,7 @@ function testCleanup() {
 }
 
 function testCleanupSync() {
-    const cleanupResult = temp.cleanupSync()
+    const cleanupResult: boolean | temp.Stats = temp.cleanupSync()
     if (typeof cleanupResult === "boolean") {
         const x = cleanupResult === true;
     }
@@ -42,13 +42,14 @@ function testOpen() {
 }
 
 function testOpenSync() {
-    const { fd: openFd1, path: openPath1 } = temp.openSync({ dir: "tempDir", prefix: "pref", suffix: "suff" });
-    const { fd: openFd2, path: openPath2 } = temp.openSync("str");
+    const f1: temp.OpenFile = temp.openSync({ dir: "tempDir", prefix: "pref", suffix: "suff" });
+    const f2: temp.OpenFile = temp.openSync("str");
 }
 
 function testCreateWriteStream() {
     const stream = temp.createWriteStream("HelloStreamAffix");
     stream.write("data");
+    const stream2 = temp.createWriteStream();
 }
 
 function testMkdir() {
@@ -73,4 +74,4 @@ function testTrack() {
     const tempChained = temp.track().track(true).track(false);
     tempChained.dir;
     tempChained.cleanupSync();
-}
\ No newline at end of file
+}

From e3b20d93a9c3e7dacb693cccc13d9bb3ad2ec7cc Mon Sep 17 00:00:00 2001
From: Rogier Schouten <rogierschouten@users.noreply.github.com>
Date: Thu, 6 Oct 2016 18:56:44 +0200
Subject: [PATCH 08/24] Allow to use with commonjs (#11775)

---
 mobile-detect/index.d.ts | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/mobile-detect/index.d.ts b/mobile-detect/index.d.ts
index 5e3df3377a..e85b1afc27 100644
--- a/mobile-detect/index.d.ts
+++ b/mobile-detect/index.d.ts
@@ -18,3 +18,6 @@ declare class MobileDetect {
 	version(value: string): number;
 	versionStr(value: string): string;
 }
+	
+export = MobileDetect;
+export as namespace MobileDetect;
\ No newline at end of file

From 1be288e7e16a232a4dfd38700c4ab46000e9c503 Mon Sep 17 00:00:00 2001
From: mgroenhoff <melvingroenhoff@gmail.com>
Date: Thu, 6 Oct 2016 19:03:03 +0200
Subject: [PATCH 09/24] Add missing terminalWidth method to yargs. (#11779)

---
 yargs/index.d.ts     | 2 ++
 yargs/yargs-tests.ts | 8 ++++++++
 2 files changed, 10 insertions(+)

diff --git a/yargs/index.d.ts b/yargs/index.d.ts
index 7fda2c8320..df84b8dc3d 100644
--- a/yargs/index.d.ts
+++ b/yargs/index.d.ts
@@ -16,6 +16,8 @@ declare namespace yargs {
 
         detectLocale(detect: boolean): Argv;
 
+        terminalWidth(): number;
+
         alias(shortName: string, longName: string): Argv;
         alias(aliases: { [shortName: string]: string }): Argv;
         alias(aliases: { [shortName: string]: string[] }): Argv;
diff --git a/yargs/yargs-tests.ts b/yargs/yargs-tests.ts
index c31ce4b997..e2fedd7b66 100644
--- a/yargs/yargs-tests.ts
+++ b/yargs/yargs-tests.ts
@@ -270,6 +270,14 @@ function Argv$version() {
 		.version(function () { return '1.0.0'; }, '--version', 'description');
 }
 
+function Argv$wrap() {
+	var argv1 = yargs
+		.wrap(null);
+
+	var argv2 = yargs
+		.wrap(yargs.terminalWidth());
+}
+
 function Argv$locale() {
 	var argv = yargs
 		.usage('./$0 - follow ye instructions true')

From 086bf3e5816861d59a532f2a57d4524e9f54be1f Mon Sep 17 00:00:00 2001
From: Filipe Silva <filipematossilva@gmail.com>
Date: Thu, 6 Oct 2016 22:32:08 +0100
Subject: [PATCH 10/24] selenium-webdriver: allow <T>=><R> in map (#11770)

* selenium-webdriver: allow <T>=><R> in map

Followup from https://github.com/DefinitelyTyped/DefinitelyTyped/pull/11726#issuecomment-251919529

The fix in https://github.com/DefinitelyTyped/DefinitelyTyped/pull/11726 seems to have uncovered a bug in the `map` typings, where the return type is expected to be the same as the argument type.

This is incorrect as you can map from one type to another.

* Change un-inferred type to any
---
 selenium-webdriver/index.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/selenium-webdriver/index.d.ts b/selenium-webdriver/index.d.ts
index b8acad06d4..97722de9b6 100644
--- a/selenium-webdriver/index.d.ts
+++ b/selenium-webdriver/index.d.ts
@@ -2174,7 +2174,7 @@ declare namespace webdriver {
          *     {@code fn}.
          * @template TYPE, SELF
          */
-        function map<T>(arr: Array<T>|Promise<Array<T>>, fn: (self: any, type: any, index: number, array: any[]) => any, opt_self?: any): Promise<T[]>
+        function map<T>(arr: Array<T>|Promise<Array<T>>, fn: (self: any, type: any, index: number, array: T[]) => any, opt_self?: any): Promise<any[]>
 
         /**
          * Creates a promise that has been rejected with the given reason.
@@ -2250,7 +2250,7 @@ declare namespace webdriver {
          *     rejected.
          * @return {!ManagedPromise} A new promise.
          */
-        function when<T,R>(value: T|Promise<T>, opt_callback?: (value: T) => any, opt_errback?: (error: any) => any): Promise<R>;
+        function when<T>(value: T|Promise<T>, opt_callback?: (value: T) => any, opt_errback?: (error: any) => any): Promise<any>;
 
         /**
          * Returns a promise that will be resolved with the input value in a

From fd855bd6319fbf9d4706d5f4b586ffdab7526402 Mon Sep 17 00:00:00 2001
From: Jeongho Nam <samchon@samchon.org>
Date: Sat, 8 Oct 2016 02:02:27 +0900
Subject: [PATCH 11/24] TypeScript-STL & Samchon-Framework (#11818)

For TS2.0
---
 samchon-collection/samchon-collection.d.ts |     6 +-
 samchon-framework/index.d.ts               | 10266 +++++++++-----
 typescript-stl/index.d.ts                  | 13713 ++++++++++---------
 3 files changed, 13963 insertions(+), 10022 deletions(-)

diff --git a/samchon-collection/samchon-collection.d.ts b/samchon-collection/samchon-collection.d.ts
index 5f62a81d42..6d6d7e78e2 100644
--- a/samchon-collection/samchon-collection.d.ts
+++ b/samchon-collection/samchon-collection.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Samchon Collection v0.0.2
+// Type definitions for Samchon Collection v0.0.4
 // Project: https://github.com/samchon/framework
 // Definitions by: Jeongho Nam <http://samchon.org>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -7,7 +7,7 @@
 
 declare module "samchon-collection"
 {
-	import collection = samchon.collection;
-	export = collection;
+	import collections = samchon.collections;
+	export = collections;
 }
 
diff --git a/samchon-framework/index.d.ts b/samchon-framework/index.d.ts
index b34eec8e6f..fb3e02bf53 100644
--- a/samchon-framework/index.d.ts
+++ b/samchon-framework/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Samchon Framework v2.0.0-beta.8
+// Type definitions for Samchon Framework v2.0.0-gamma.4
 // Project: https://github.com/samchon/framework
 // Definitions by: Jeongho Nam <http://samchon.org>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -7,63 +7,110 @@
 
 declare module "samchon-framework"
 {
-        export = samchon;
+	export = samchon;
 }
 
 /**
  * <h1> Samchon-Framework </h1>
  *
- * <p> <a href="https://nodei.co/npm/samchon-framework">
- *	<img src="https://nodei.co/npm/samchon-framework.png?downloads=true&downloadRank=true&stars=true"> </a> </p>
+ * <a href="https://nodei.co/npm/samchon-framework">
+ *	<img src="https://nodei.co/npm/samchon-framework.png?downloads=true&downloadRank=true&stars=true"> </a>
  *
- * <p> Samchon, a SDN (Software Defined Network) framework. </p>
+ * Samchon, a SDN (Software Defined Network) framework.
  *
- * <p> With Samchon Framework, you can implement distributed processing system within framework of OOD like
- * handling S/W objects (classes). You can realize cloud and distributed system very easily with provided
- * system templates and even integration with C++ is possible. </p>
+ * With Samchon Framework, you can implement distributed processing system within framework of OOD like handling S/W
+ * objects (classes). You can realize cloud and distributed system very easily with provided system templates and even
+ * integration with C++ is possible.
  *
- * <p> The goal, ultimate utilization model of Samchon Framework is, building cloud system with NodeJS and
- * takING heavy works to C++ distributed systems with provided modules (those are system templates). </p>
+ * The goal, ultimate utilization model of Samchon Framework is, building cloud system with NodeJS and taking heavy works
+ * to C++ distributed systems with provided modules (those are system templates).
  *
  * @git https://github.com/samchon/framework
  * @author Jeongho Nam <http://samchon.org>
  */
 declare namespace samchon {
     /**
-     * <p> Running on Node. </p>
+     * Running on Node.
      *
-     * <p> Test whether the JavaScript is running on Node. </p>
+     * Test whether the JavaScript is running on Node.
      *
      * @references http://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser
      */
     function is_node(): boolean;
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     /**
      * A {@link Vector} who can detect element I/O events.
      *
-     * <ul>
-     *	<li> <i>insert</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link insert} </li>
-     *		<li> {@link push} </li>
-     *		<li> {@link push_back} </li>
-     *		<li> {@link unshift} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link clear} </li>
-     *		<li> {@link erase} </li>
-     *		<li> {@link pop_back} </li>
-     *		<li> {@link shift} </li>
-     *		<li> {@link pop} </li>
-     *		<li> {@link splice} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link sort} </li>
-     *	</ul></li>
-     * </ul>
+     * Below is the list of methods who are dispatching {@link CollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   -  {@link insert}
+     *   -  {@link push}
+     *   -  {@link push_back}
+     *   -  {@link unshift}
+     * - *erase* typed events:
+     *   -  {@link assign}
+     *   -  {@link clear}
+     *   -  {@link erase}
+     *   - {@link pop_back}
+     *   - {@link shift}
+     *   - {@link pop}
+     *   - {@link splice}
+     * - *refresh* typed events:
+     *   - {@link refresh}
      *
+     * #### [Inherited] {@link Vector}
+     * {@link Vector Vectors}s are sequence containers representing arrays that can change in size.
+     *
+     * Just like arrays, {@link Vector}s use contiguous storage locations for their elements, which means that their
+     * elements can also be accessed using offsets on regular pointers to its elements, and just as efficiently as in
+     * arrays. But unlike arrays, their size can change dynamically, with their storage being handled automatically
+     * by the container.
+     *
+     * Internally, {@link Vector}s use a dynamically allocated array to store their elements. This array may need to
+     * be reallocated in order to grow in size when new elements are inserted, which implies allocating a new array
+     * and moving all elements to it. This is a relatively expensive task in terms of processing time, and thus,
+     * {@link Vector}s do not reallocate each time an element is added to the container.
+     *
+     * Instead, {@link Vector} containers may allocate some extra storage to accommodate for possible growth, and
+     * thus the container may have an actual {@link capacity} greater than the storage strictly needed to contain its
+     * elements (i.e., its {@link size}). Libraries can implement different strategies for growth to balance between
+     * memory usage and reallocations, but in any case, reallocations should only happen at logarithmically growing
+     * intervals of {@link size} so that the insertion of individual elements at the end of the {@link Vector} can be
+     * provided with amortized constant time complexity (see {@link push_back push_back()}).
+     *
+     * Therefore, compared to arrays, {@link Vector}s consume more memory in exchange for the ability to manage
+     * storage and grow dynamically in an efficient way.
+     *
+     * Compared to the other dynamic sequence containers ({@link Deque}s, {@link List}s), {@link Vector Vectors} are
+     * very efficient accessing its elements (just like arrays) and relatively efficient adding or removing elements
+     * from its end. For operations that involve inserting or removing elements at positions other than the end, they
+     * perform worse than the others, and have less consistent iterators and references than {@link List}s.
+     *
+     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Sequence </dt>
+     *	<dd>
+     *		Elements in sequence containers are ordered in a strict linear sequence. Individual elements are
+     *		accessed by their position in this sequence.
+     *	</dd>
+     *
+     *	<dt> Dynamic array </dt>
+     *	<dd>
+     *		Allows direct access to any element in the sequence, even through pointer arithmetics, and provides
+     *		relatively fast addition/removal of elements at the end of the sequence.
+     *	</dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @reference http://www.cplusplus.com/reference/vector/vector
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
      * @author Jeongho Nam <http://samchon.org>
      */
     class ArrayCollection<T> extends std.Vector<T> implements ICollection<T> {
@@ -74,7 +121,7 @@ declare namespace samchon.collection {
         /**
          * @inheritdoc
          */
-        push<U extends T>(...items: U[]): number;
+        push(...items: T[]): number;
         /**
          * @inheritdoc
          */
@@ -170,6 +217,7 @@ declare namespace samchon.library {
      * A basic event class of Samchon Framework.
      *
      * @reference https://developer.mozilla.org/en-US/docs/Web/API/Event
+     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Library-EventDispatcher
      * @author Jeongho Nam <http://samchon.org>
      */
     class BasicEvent {
@@ -201,7 +249,7 @@ declare namespace samchon.library {
         /**
          * @inheritdoc
          */
-        type: string;
+        readonly type: string;
         /**
          * @inheritdoc
          */
@@ -209,89 +257,98 @@ declare namespace samchon.library {
         /**
          * @inheritdoc
          */
-        currentTarget: IEventDispatcher;
+        readonly currentTarget: IEventDispatcher;
         /**
          * @inheritdoc
          */
-        isTrusted: boolean;
+        readonly isTrusted: boolean;
         /**
          * @inheritdoc
          */
-        bubbles: boolean;
+        readonly bubbles: boolean;
         /**
          * @inheritdoc
          */
-        cancelable: boolean;
+        readonly cancelable: boolean;
         /**
          * @inheritdoc
          */
-        eventPhase: number;
+        readonly eventPhase: number;
         /**
          * @inheritdoc
          */
-        defaultPrevented: boolean;
+        readonly defaultPrevented: boolean;
         /**
          * @inheritdoc
          */
-        srcElement: Element;
+        readonly srcElement: Element;
         /**
          * @inheritdoc
          */
-        cancelBubble: boolean;
+        readonly cancelBubble: boolean;
         /**
          * @inheritdoc
          */
-        timeStamp: number;
+        readonly timeStamp: number;
         /**
          * Don't know what it is.
          */
-        returnValue: boolean;
+        readonly returnValue: boolean;
     }
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     /**
      * Type of function pointer for listener of {@link CollectionEvent CollectionEvents}.
      */
     type CollectionEventListener<T> = (event: CollectionEvent<T>) => void;
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     /**
+     * An event occured in a {@link ICollection collection} object.
+     *
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
      * @author Jeongho Nam <http://samchon.org>
      */
     class CollectionEvent<T> extends library.BasicEvent {
         /**
          * @hidden
          */
-        protected first_: std.Iterator<T>;
+        private first_;
+        /**
+         * @hidden
+         */
+        private last_;
         /**
          * @hidden
          */
-        protected last_: std.Iterator<T>;
         private temporary_container_;
+        /**
+         * @hidden
+         */
         private origin_first_;
         /**
          * Initialization Constructor.
          *
          * @param type Type of collection event.
-         * @param first
-         * @param last
+         * @param first An {@link Iterator} to the initial position in this {@link CollectionEvent}.
+         * @param last An {@link Iterator} to the final position in this {@link CollectionEvent}.
          */
         constructor(type: string, first: std.Iterator<T>, last: std.Iterator<T>);
         constructor(type: "insert", first: std.Iterator<T>, last: std.Iterator<T>);
         constructor(type: "erase", first: std.Iterator<T>, last: std.Iterator<T>);
         constructor(type: "refresh", first: std.Iterator<T>, last: std.Iterator<T>);
         /**
-         * Get associative target, the container.
+         * Associative target, the {@link ICollection collection}.
          */
-        target: ICollection<T>;
+        readonly target: ICollection<T>;
         /**
-         * Get range of the first.
+         * An {@link Iterator} to the initial position in this {@link CollectionEvent}.
          */
-        first: std.Iterator<T>;
+        readonly first: std.Iterator<T>;
         /**
-         * Get range of the last.
+         * An {@link Iterator} to the final position in this {@link CollectionEvent}.
          */
-        last: std.Iterator<T>;
+        readonly last: std.Iterator<T>;
         /**
          * @inheritdoc
          */
@@ -301,34 +358,78 @@ declare namespace samchon.collection {
 /**
  * @hidden
  */
-declare namespace samchon.collection.CollectionEvent {
+declare namespace samchon.collections.CollectionEvent {
     const INSERT: "insert";
     const ERASE: "erase";
     const REFRESH: "refresh";
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     /**
      * A {@link Deque} who can detect element I/O events.
      *
-     * <p> Below are list of methods who are dispatching {@link CollectionEvent}: </p>
+     * Below is the list of methods who are dispatching {@link CollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link push}
+     *   - {@link push_front}
+     *   - {@link push_back}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     *   - {@link pop_front}
+     *   - {@link pop_back}
+     * - *refresh* typed events:
+     *   - {@link refresh}
      *
-     * <ul>
-     *	<li> <i>insert</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link insert} </li>
-     *		<li> {@link push} </li>
-     *		<li> {@link push_front} </li>
-     *		<li> {@link push_back} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link clear} </li>
-     *		<li> {@link erase} </li>
-     *		<li> {@link pop_front} </li>
-     *		<li> {@link pop_back} </li>
-     *	</ul></li>
-     * </ul>
+     * #### [Inherited] {@link Deque}
+     * {@link Deque} (usually pronounced like "*deck*") is an irregular acronym of **d**ouble-**e**nded **q**ueue.
+     * Double-ended queues are sequence containers with dynamic sizes that can be expanded or contracted on both ends
+     * (either its front or its back).
      *
+     * Specific libraries may implement deques in different ways, generally as some form of dynamic array. But in any
+     * case, they allow for the individual elements to be accessed directly through random access iterators, with
+     * storage handled automatically by expanding and contracting the container as needed.
+     *
+     * Therefore, they provide a functionality similar to vectors, but with efficient insertion and deletion of
+     * elements also at the beginning of the sequence, and not only at its end. But, unlike {@link Vector Vectors},
+     * {@link Deque Deques} are not guaranteed to store all its elements in contiguous storage locations: accessing
+     * elements in a <u>deque</u> by offsetting a pointer to another element causes undefined behavior.
+     *
+     * Both {@link Vector}s and {@link Deque}s provide a very similar interface and can be used for similar purposes,
+     * but internally both work in quite different ways: While {@link Vector}s use a single array that needs to be
+     * occasionally reallocated for growth, the elements of a {@link Deque} can be scattered in different chunks of
+     * storage, with the container keeping the necessary information internally to provide direct access to any of its
+     * elements in constant time and with a uniform sequential interface (through iterators). Therefore,
+     * {@link Deque Deques} are a little more complex internally than {@link Vector}s, but this allows them to grow
+     * more efficiently under certain circumstances, especially with very long sequences, where reallocations become
+     * more expensive.
+     *
+     * For operations that involve frequent insertion or removals of elements at positions other than the beginning or
+     * the end, {@link Deque Deques} perform worse and have less consistent iterators and references than
+     * {@link List Lists}.
+     *
+     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Sequence </dt>
+     *	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements
+     *		 are accessed by their position in this sequence. </dd>
+     *
+     *	<dt> Dynamic array </dt>
+     *	<dd> Generally implemented as a dynamic array, it allows direct access to any element in the
+     *		 sequence and provides relatively fast addition/removal of elements at the beginning or the end
+     *		 of the sequence. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @reference http://www.cplusplus.com/reference/deque/deque/
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
      * @author Jeongho Nam <http://samchon.org>
      */
     class DequeCollection<T> extends std.Deque<T> implements ICollection<T> {
@@ -339,7 +440,7 @@ declare namespace samchon.collection {
         /**
          * @inheritdoc
          */
-        push<U extends T>(...items: U[]): number;
+        push(...items: T[]): number;
         /**
          * @inheritdoc
          */
@@ -418,30 +519,72 @@ declare namespace samchon.collection {
         removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
     }
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     /**
      * A {@link HashMap} who can detect element I/O events.
      *
-     * <ul>
-     *	<li> <i>insert</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link insert} </li>
-     *		<li> {@link push} </li>
-     *		<li> {@link set} </li>
-     *		<li> {@link insert_or_assign} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link clear} </li>
-     *		<li> {@link erase} </li>
-     *		<li> {@link extract} </li>
-     *	</ul></li>
-     *	<li> <i>refresh</i> typed events: <ul>
-     *		<li> {@link set} </li>
-     *		<li> {@link insert_or_assign} </li>
-     *	</ul></li>
-     * </ul>
+     * Below is the list of methods who are dispatching {@link MapCollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link insert_or_assign}
+     *   - {@link emplace}
+     *   - {@link set}
+     *   - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     *   - {@link extract}
+     * - *refresh* typed events:
+     *   - {@link refresh}
      *
+     * #### [Inherited] {@link HashMap}
+     * {@link HashMap HashMaps} are associative containers that store elements formed by the combination of a
+     * *key value* and a *mapped value*, and which allows for fast retrieval of individual elements based on their
+     * *keys*.
+     *
+     * In an {@link HashMap}, the *key value* is generally used to uniquely identify the element, while the
+     * *mapped value* is an object with the content associated to this *key*. Types of *key* and *mapped value* may
+     * differ.
+     *
+     * Internally, the elements in the {@link HashMap} are not sorted in any particular order with respect to either
+     * their *key* or *mapped values*, but organized into *buckets* depending on their hash values to allow for fast
+     * access to individual elements directly by their *key values* (with a constant average time complexity on
+     * average).
+     *
+     * {@link HashMap} containers are faster than {@link TreeMap} containers to access individual elements by their
+     * *key*, although they are generally less efficient for range iteration through a subset of their elements.
+     *
+     *  <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     * 	<dt> Associative </dt>
+     * 	<dd> Elements in associative containers are referenced by their *key* and not by their absolute
+     *		 position in the container. </dd>
+     *
+     * 	<dt> Hashed </dt>
+     * 	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
+     *		 by their *key*. </dd>
+     *
+     * 	<dt> Map </dt>
+     * 	<dd> Each element associates a *key* to a *mapped value*:
+     *		 *Keys* are meant to identify the elements whose main content is the *mapped value*. </dd>
+     *
+     * 	<dt> Unique keys </dt>
+     * 	<dd> No two elements in the container can have equivalent keys. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the key values.
+     *				Each element in an {@link HashMap} is uniquely identified by its key value.
+     * @param <T> Type of the mapped value.
+     *			  Each element in an {@link HashMap} is used to store some data as its mapped value.
+     *
+     * @reference http://www.cplusplus.com/reference/unordered_map/unordered_map
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
      * @author Jeongho Nam <http://samchon.org>
      */
     class HashMapCollection<Key, T> extends std.HashMap<Key, T> implements ICollection<std.Pair<Key, T>> {
@@ -507,23 +650,69 @@ declare namespace samchon.collection {
         removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
     }
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     /**
      * A {@link HashMultiMap} who can detect element I/O events.
      *
-     * <ul>
-     *	<li> <i>insert</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link insert} </li>
-     *		<li> {@link push} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link clear} </li>
-     *		<li> {@link erase} </li>
-     *	</ul></li>
-     * </ul>
+     * Below is the list of methods who are dispatching {@link MapCollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link emplace}
+     *   - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     * - *refresh* typed events:
+     *   - {@link refresh}
      *
+     * #### [Inherited] {@link HashMultiMap}
+     * {@link HashMultiMap HashMultiMap}s are associative containers that store elements formed by the combination of
+     * a *key value* and a *mapped value*, much like {@link HashMultiMap} containers, but allowing different elements
+     * to have equivalent *keys*.
+     *
+     * In an {@link HashMultiMap}, the *key value* is generally used to uniquely identify the element, while the
+     * *mapped value* is an object with the content associated to this *key*. Types of *key* and *mapped value* may
+     * differ.
+     *
+     * Internally, the elements in the {@link HashMultiMap} are not sorted in any particular order with respect to
+     * either their *key* or *mapped values*, but organized into *buckets* depending on their hash values to allow for
+     * fast access to individual elements directly by their *key values* (with a constant average time complexity on
+     * average).
+     *
+     * Elements with equivalent *keys* are grouped together in the same bucket and in such a way that an iterator can
+     * iterate through all of them. Iterators in the container are doubly linked iterators.
+     *
+     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their *key* and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Hashed </dt>
+     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
+     *		 by their *key*. </dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd> Each element associates a *key* to a *mapped value*:
+     *		 *Keys* are meant to identify the elements whose main content is the *mapped value*. </dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> The container can hold multiple elements with equivalent *keys*. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the key values.
+     *				Each element in an {@link HashMultiMap} is identified by a key value.
+     * @param <T> Type of the mapped value.
+     *			  Each element in an {@link HashMultiMap} is used to store some data as its mapped value.
+     *
+     * @reference http://www.cplusplus.com/reference/unordered_map/unordered_multimap
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
      * @author Jeongho Nam <http://samchon.org>
      */
     class HashMultiMapCollection<Key, T> extends std.HashMap<Key, T> implements ICollection<std.Pair<Key, T>> {
@@ -589,23 +778,64 @@ declare namespace samchon.collection {
         removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
     }
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     /**
      * A {@link HashMultiSet} who can detect element I/O events.
      *
-     * <ul>
-     *	<li> <i>insert</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link insert} </li>
-     *		<li> {@link push} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link clear} </li>
-     *		<li> {@link erase} </li>
-     *	</ul></li>
-     * </ul>
+     * Below is the list of methods who are dispatching {@link CollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     * - *refresh* typed events:
+     *   - {@link refresh}
      *
+     * #### [Inherited] {@link HashMultiSet}
+     * {@link HashMultiSet HashMultiSets} are containers that store elements in no particular order, allowing fast
+     * retrieval of individual elements based on their value, much like {@link HashMultiSet} containers, but allowing
+     * different elements to have equivalent values.
+     *
+     * In an {@link HashMultiSet}, the value of an element is at the same time its *key*, used to identify it. *Keys*
+     * are immutable, therefore, the elements in an {@link HashMultiSet} cannot be modified once in the container -
+     * they can be inserted and removed, though.
+     *
+     * Internally, the elements in the {@link HashMultiSet} are not sorted in any particular, but organized into
+     * *buckets* depending on their hash values to allow for fast access to individual elements directly by their
+     * *values* (with a constant average time complexity on average).
+     *
+     * Elements with equivalent values are grouped together in the same bucket and in such a way that an iterator can
+     * iterate through all of them. Iterators in the container are doubly linked iterators.
+     *
+     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their *key* and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Hashed </dt>
+     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
+     *		 by their *key*. </dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the *key* used to identify it. </dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> The container can hold multiple elements with equivalent *keys*. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *		   Each element in an {@link UnorderedMultiSet} is also identified by this value..
+     *
+     * @reference http://www.cplusplus.com/reference/unordered_set/unordered_multiset
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
      * @author Jeongho Nam <http://samchon.org>
      */
     class HashMultiSetCollection<T> extends std.HashMultiSet<T> implements ICollection<T> {
@@ -671,24 +901,65 @@ declare namespace samchon.collection {
         removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
     }
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     /**
      * A {@link HashSet} who can detect element I/O events.
      *
-     * <ul>
-     *	<li> <i>insert</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link insert} </li>
-     *		<li> {@link push} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link clear} </li>
-     *		<li> {@link erase} </li>
-     *		<li> {@link extract} </li>
-     *	</ul></li>
-     * </ul>
+     * Below is the list of methods who are dispatching {@link CollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link push}
+     *   - {@link insert_or_assign}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     *   - {@link extract}
+     * - *refresh* typed events:
+     *   - {@link refresh}
      *
+     * #### [Inherited] {@link HashSet}
+     * {@link HashSet HashSets} are containers that store unique elements in no particular order, and which allow for
+     * fast retrieval of individual elements based on their value.
+     *
+     * In an {@link HashSet}, the value of an element is at the same time its *key*, that identifies it uniquely.
+     * Keys are immutable, therefore, the elements in an {@link HashSet} cannot be modified once in the container -
+     * they can be inserted and removed, though.
+     *
+     * Internally, the elements in the {@link HashSet} are not sorted in any particular order, but organized into
+     * buckets depending on their hash values to allow for fast access to individual elements directly by their
+     * *values* (with a constant average time complexity on average).
+     *
+     * {@link HashSet} containers are faster than {@link TreeSet} containers to access individual elements by their
+     * *key*, although they are generally less efficient for range iteration through a subset of their elements.
+     *
+     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their *key* and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Hashed </dt>
+     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
+     *		 by their *key*. </dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the *key* used to identify it. </dd>
+     *
+     *	<dt> Unique keys </dt>
+     *	<dd> No two elements in the container can have equivalent *keys*. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *			  Each element in an {@link HashSet} is also uniquely identified by this value.
+     *
+     * @reference http://www.cplusplus.com/reference/unordered_set/unordered_set
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
      * @author Jeongho Nam <http://samchon.org>
      */
     class HashSetCollection<T> extends std.HashSet<T> implements ICollection<T> {
@@ -754,75 +1025,73 @@ declare namespace samchon.collection {
         removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
     }
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     /**
      * An interface for {@link IContainer containers} who can detect element I/O events.
      *
-     * <p> Below are list of methods who are dispatching {@link CollectionEvent}: </p>
-     *
-     * <ul>
-     *	<li> <i>insert</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link insert} </li>
-     *		<li> {@link push} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link clear} </li>
-     *		<li> {@link erase} </li>
-     *	</ul></li>
+     * Below are list of methods who are dispatching {@link CollectionEvent}:
+     * - *insert* typed events:
+     *	 - {@link assign}
+     *   - {@link insert}
+     *	 - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     * - *refresh* typed events:
+     *   - {@link refresh}
      *
      * @author Jeongho Nam <http://samchon.org>
      */
     interface ICollection<T> extends std.base.IContainer<T>, library.IEventDispatcher {
         /**
-         * <p> Dispatch a {@link CollectionEvent} with <i>refresh</i> typed. </p>
+         * Dispatch a {@link CollectionEvent} with *refresh* typed.
          *
-         * <p> {@link ICollection} dispatches {@link CollectionEvent} typed <i>insert</i> or <i>erase</i> whenever
-         * elements I/O has occured. However, unlike those elements I/O events, content change in element level can't be
-         * detected. There's no way to detect those events automatically by {@link IContainer}. </p>
+         * {@link ICollection} dispatches {@link CollectionEvent} typed *insert* or *erase* whenever elements I/O has
+         * occured. However, unlike those elements I/O events, content change in element level can't be detected.
+         * There's no way to detect those events automatically by {@link IContainer}.
          *
-         * <p> If you want to dispatch those typed events (notifying change on contents in element level), you've to
-         * dispatch <i>refresh</i> typed event manually, by yourself. Call {@link refresh refresh()} with specified
+         * If you want to dispatch those typed events (notifying change on contents in element level), you've to
+         * dispatch *refresh* typed event manually, by yourself. Call {@link refresh refresh()} with specified
          * iterators who're pointing the elements whose content have changed. Then a {@link CollectionEvent} with
-         * <i>refresh</i> typed will be dispatched. </p>
+         * *refresh* typed will be dispatched.
          *
-         * <p> If you don't specify any iterator, then the range of the <i>refresh<i> event will be all elements in this
-         * {@link ICollection collection}; {@link begin begin()} to {@link end end()}. </p>
+         * If you don't specify any iterator, then the range of the *refresh* event will be all elements in this
+         * {@link ICollection collection}; {@link begin begin()} to {@link end end()}.
          */
         refresh(): void;
         /**
-         * <p> Dispatch a {@link CollectionEvent} with <i>refresh</i> typed. </p>
+         * Dispatch a {@link CollectionEvent} with *refresh* typed.
          *
-         * <p> {@link ICollection} dispatches {@link CollectionEvent} typed <i>insert</i> or <i>erase</i> whenever
-         * elements I/O has occured. However, unlike those elements I/O events, content change in element level can't be
-         * detected. There's no way to detect those events automatically by {@link IContainer}. </p>
+         * {@link ICollection} dispatches {@link CollectionEvent} typed *insert* or *erase* whenever elements I/O has
+         * occured. However, unlike those elements I/O events, content change in element level can't be detected.
+         * There's no way to detect those events automatically by {@link IContainer}.
          *
-         * <p> If you want to dispatch those typed events (notifying change on contents in element level), you've to
-         * dispatch <i>refresh</i> typed event manually, by yourself. Call {@link refresh refresh()} with specified
+         * If you want to dispatch those typed events (notifying change on contents in element level), you've to
+         * dispatch *refresh* typed event manually, by yourself. Call {@link refresh refresh()} with specified
          * iterators who're pointing the elements whose content have changed. Then a {@link CollectionEvent} with
-         * <i>refresh</i> typed will be dispatched. </p>
+         * *refresh* typed will be dispatched.
          *
          * @param it An iterator targeting the content changed element.
          */
         refresh(it: std.Iterator<T>): void;
         /**
-         * <p> Dispatch a {@link CollectionEvent} with <i>refresh</i> typed. </p>
+         * Dispatch a {@link CollectionEvent} with *refresh* typed.
          *
-         * <p> {@link ICollection} dispatches {@link CollectionEvent} typed <i>insert</i> or <i>erase</i> whenever
-         * elements I/O has occured. However, unlike those elements I/O events, content change in element level can't be
-         * detected. There's no way to detect those events automatically by {@link IContainer}. </p>
+         * {@link ICollection} dispatches {@link CollectionEvent} typed *insert* or *erase* whenever elements I/O has
+         * occured. However, unlike those elements I/O events, content change in element level can't be detected.
+         * There's no way to detect those events automatically by {@link IContainer}.
          *
-         * <p> If you want to dispatch those typed events (notifying change on contents in element level), you've to
-         * dispatch <i>refresh</i> typed event manually, by yourself. Call {@link refresh refresh()} with specified
+         * If you want to dispatch those typed events (notifying change on contents in element level), you've to
+         * dispatch *refresh* typed event manually, by yourself. Call {@link refresh refresh()} with specified
          * iterators who're pointing the elements whose content have changed. Then a {@link CollectionEvent} with
-         * <i>refresh</i> typed will be dispatched. </p>
+         * *refresh* typed will be dispatched.
          *
          * @param first An Iterator to the initial position in a sequence of the content changed elmeents.
          * @param last An {@link Iterator} to the final position in a sequence of the content changed elements. The range
-         *			   used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
-         *			   <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by
-         *			   <i>last</i>.
+         *			   used is [*first*, *last*), which contains all the elements between *first* and
+         *			   *last*, including the element pointed by *first* but not the element pointed by
+         *			   *last*.
          */
         refresh(first: std.Iterator<T>, last: std.Iterator<T>): void;
         /**
@@ -858,39 +1127,84 @@ declare namespace samchon.collection {
      * @hidden
      */
     namespace ICollection {
+        /**
+         * @hidden
+         */
         function _Dispatch_CollectionEvent<T>(collection: ICollection<T>, type: string, first: std.Iterator<T>, last: std.Iterator<T>): void;
+        /**
+         * @hidden
+         */
         function _Dispatch_MapCollectionEvent<Key, T>(collection: ICollection<std.Pair<Key, T>>, type: string, first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
     }
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     /**
      * A {@link List} who can detect element I/O events.
      *
-     * <ul>
-     *	<li> <i>insert</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link insert} </li>
-     *		<li> {@link push} </li>
-     *		<li> {@link push_front} </li>
-     *		<li> {@link push_back} </li>
-     *		<li> {@link merge} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link clear} </li>
-     *		<li> {@link erase} </li>
-     *		<li> {@link pop_front} </li>
-     *		<li> {@link pop_back} </li>
-     *		<li> {@link unique} </li>
-     *		<li> {@link remove} </li>
-     *		<li> {@link remove_if} </li>
-     *		<li> {@link splice} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link sort} </li>
-     *	</ul></li>
-     * </ul>
+     * Below is the list of methods who are dispatching {@link CollectionEvent}:
+     *	- *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link push}
+     *   - {@link push_front}
+     *   - {@link push_back}
+     *   - {@link merge}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     *   - {@link pop_front}
+     *   - {@link pop_back}
+     *   - {@link unique}
+     *   - {@link remove}
+     *   - {@link remove_if}
+     *   - {@link splice}
+     * - *refresh* typed events:
+     *   - {@link refresh}
+     *   - {@link sort}
      *
+     * #### [Inherited] {@link List}
+     * {@link List Lists} are sequence containers that allow constant time insert and erase operations anywhere within
+     * the sequence, and iteration in both directions.
+     *
+     * List containers are implemented as doubly-linked lists; Doubly linked lists can store each of the elements they
+     * contain in different and unrelated storage locations. The ordering is kept internally by the association to
+     * each element of a link to the element preceding it and a link to the element following it.
+     *
+     * They are very similar to forward_list: The main difference being that forward_list objects are single-linked
+     * lists, and thus they can only be iterated forwards, in exchange for being somewhat smaller and more efficient.
+     *
+     * Compared to other base standard sequence containers (array, vector and deque), lists perform generally better
+     * in inserting, extracting and moving elements in any position within the container for which an iterator has
+     * already been obtained, and therefore also in algorithms that make intensive use of these, like sorting
+     * algorithms.
+     *
+     * The main drawback of lists and forward_lists compared to these other sequence containers is that they lack
+     * direct access to the elements by their position; For example, to access the sixth element in a list, one has to
+     * iterate from a known position (like the beginning or the end) to that position, which takes linear time in the
+     * distance between these. They also consume some extra memory to keep the linking information associated to each
+     * element (which may be an important factor for large lists of small-sized elements).
+     *
+     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     * 	<dt> Sequence </dt>
+     * 	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements are accessed by
+     *		 their position in this sequence. </dd>
+     *
+     * 	<dt> Doubly-linked list </dt>
+     *	<dd> Each element keeps information on how to locate the next and the previous elements, allowing constant time
+     *		 insert and erase operations before or after a specific element (even of entire ranges), but no direct random
+     *		 access. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @reference http://www.cplusplus.com/reference/list/list/
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
      * @author Jeongho Nam <http://samchon.org>
      */
     class ListCollection<T> extends std.List<T> implements ICollection<T> {
@@ -901,7 +1215,7 @@ declare namespace samchon.collection {
         /**
          * @inheritdoc
          */
-        push<U extends T>(...items: T[]): number;
+        push(...items: T[]): number;
         /**
          * @inheritdoc
          */
@@ -988,43 +1302,90 @@ declare namespace samchon.collection {
         removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
     }
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     type MapCollectionEventListener<Key, T> = (event: MapCollectionEvent<Key, T>) => void;
+    /**
+     * An event occured in a {@link MapContainer map container} object.
+     *
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
+     * @author Jeongho Nam <http://samchon.org>
+     */
     class MapCollectionEvent<Key, T> extends CollectionEvent<std.Pair<Key, T>> {
         /**
          * @inheritdoc
          */
-        first: std.MapIterator<Key, T>;
+        readonly first: std.MapIterator<Key, T>;
         /**
          * @inheritdoc
          */
-        last: std.MapIterator<Key, T>;
+        readonly last: std.MapIterator<Key, T>;
     }
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     /**
      * A {@link TreeMap} who can detect element I/O events.
      *
-     * <ul>
-     *	<li> <i>insert</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link insert} </li>
-     *		<li> {@link push} </li>
-     *		<li> {@link set} </li>
-     *		<li> {@link insert_or_assign} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link clear} </li>
-     *		<li> {@link erase} </li>
-     *		<li> {@link extract} </li>
-     *	</ul></li>
-     *	<li> <i>refresh</i> typed events: <ul>
-     *		<li> {@link set} </li>
-     *		<li> {@link insert_or_assign} </li>
-     *	</ul></li>
-     * </ul>
+     * Below is the list of methods who are dispatching {@link MapCollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link insert_or_assign}
+     *   - {@link emplace}
+     *   - {@link set}
+     *   - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     *   - {@link extract}
+     * - *refresh* typed events:
+     *   - {@link refresh}
      *
+     * #### [Inherited] {@link TreeMap}
+     * {@link TreeMap TreeMaps} are associative containers that store elements formed by a combination of a
+     * *key value* (*Key*) and a *mapped value* (*T*), following order.
+     *
+     * In a {@link TreeMap}, the *key values* are generally used to sort and uniquely identify the elements, while the
+     * *mapped values* store the content associated to this key. The types of *key* and *mapped value* may differ, and
+     * are grouped together in member type *value_type*, which is a {@link Pair} type combining both:
+     *
+     * ```typedef Pair<Key, T> value_type;```
+     *
+     * Internally, the elements in a {@link TreeMap} are always sorted by its *key* following a *strict weak ordering*
+     * criterion indicated by its internal comparison method {@link less}.
+     *
+     * {@link TreeMap} containers are generally slower than {@link HashMap HashMap} containers to access individual
+     * elements by their *key*, but they allow the direct iteration on subsets based on their order.
+     *
+     * {@link TreeMap}s are typically implemented as binary search trees.
+     *
+     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their *key* and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Ordered </dt>
+     *	<dd> The elements in the container follow a strict order at all times. All inserted elements are
+     *		 given a position in this order. </dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd> Each element associates a *key* to a *mapped value*:
+     *		 *Keys* are meant to identify the elements whose main content is the *mapped value*. </dd>
+     *
+     *	<dt> Unique keys </dt>
+     *	<dd> No two elements in the container can have equivalent *keys*. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
+     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
+     *
+     * @reference http://www.cplusplus.com/reference/map/map
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
      * @author Jeongho Nam <http://samchon.org>
      */
     class TreeMapCollection<Key, T> extends std.TreeMap<Key, T> implements ICollection<std.Pair<Key, T>> {
@@ -1090,23 +1451,75 @@ declare namespace samchon.collection {
         removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
     }
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     /**
      * A {@link TreeMultiMap} who can detect element I/O events.
      *
-     * <ul>
-     *	<li> <i>insert</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link insert} </li>
-     *		<li> {@link push} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link clear} </li>
-     *		<li> {@link erase} </li>
-     *	</ul></li>
-     * </ul>
+     * Below is the list of methods who are dispatching {@link MapCollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link emplace}
+     *   - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     * - *refresh* typed events:
+     *   - {@link refresh}
      *
+     * #### [Inherited] {@link TreeMultiMap}
+     * {@link TreeMultiMap TreeMultiMaps} are associative containers that store elements formed by a combination of a
+     * *key value* and a *mapped value*, following a specific order, and where multiple elements can have equivalent
+     * keys.
+     *
+     * In a {@link TreeMultiMap}, the *key values* are generally used to sort and uniquely identify the elements,
+     * while the *mapped values* store the content associated to this *key*. The types of *key* and *mapped value* may
+     * differ, and are grouped together in member type ```value_type```, which is a {@link Pair} type combining both:
+     *
+     * ```typedef Pair<const Key, T> value_type;```
+     *
+     * Internally, the elements in a {@link TreeMultiMap}are always sorted by its key following a strict weak ordering
+     * criterion indicated by its internal comparison method (of {@link less}).
+     *
+     * {@link TreeMultiMap}containers are generally slower than {@link HashMap} containers to access individual
+     * elements by their *key*, but they allow the direct iteration on subsets based on their order.
+     *
+     * {@link TreeMultiMap TreeMultiMaps} are typically implemented as binary search trees.
+     *
+     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank"> <
+     * img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their *key* and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Ordered </dt>
+     *	<dd>
+     *		The elements in the container follow a strict order at all times. All inserted elements are
+     *		given a position in this order.
+     *	</dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd>
+     *		Each element associates a *key* to a *mapped value*:
+     *		*Keys* are meant to identify the elements whose main content is the *mapped value*.
+     *	</dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> Multiple elements in the container can have equivalent *keys*. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
+     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
+     *
+     * @reference http://www.cplusplus.com/reference/map/multimap
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
      * @author Jeongho Nam <http://samchon.org>
      */
     class TreeMultiMapCollection<Key, T> extends std.TreeMultiMap<Key, T> implements ICollection<std.Pair<Key, T>> {
@@ -1172,23 +1585,67 @@ declare namespace samchon.collection {
         removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
     }
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     /**
      * A {@link TreeMultiSet} who can detect element I/O events.
      *
-     * <ul>
-     *	<li> <i>insert</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link insert} </li>
-     *		<li> {@link push} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link clear} </li>
-     *		<li> {@link erase} </li>
-     *	</ul></li>
-     * </ul>
+     * Below is the list of methods who are dispatching {@link CollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     * - *refresh* typed events:
+     *   - {@link refresh}
      *
+     * #### [Inherited] {@link TreeMultiSet}
+     * {@link TreeMultiSet TreeMultiSets} are containers that store elements following a specific order, and where
+     * multiple elements can have equivalent values.
+     *
+     * In a {@link TreeMultiSet}, the value of an element also identifies it (the value is itself the *key*, of type
+     * *T*). The value of the elements in a {@link TreeMultiSet} cannot be modified once in the container (the
+     * elements are always const), but they can be inserted or removed from the container.
+     *
+     * Internally, the elements in a {@link TreeMultiSet TreeMultiSets} are always sorted following a strict weak
+     * ordering criterion indicated by its internal comparison method (of {@link IComparable.less less}).
+     *
+     * {@link TreeMultiSet} containers are generally slower than {@link HashMultiSet} containers to access individual
+     * elements by their *key*, but they allow the direct iteration on subsets based on their order.
+     *
+     * <p> {@link TreeMultiSet TreeMultiSets} are typically implemented as binary search trees. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /> </a></p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their *key* and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Ordered </dt>
+     *	<dd>
+     *		The elements in the container follow a strict order at all times. All inserted elements are
+     *		given a position in this order.
+     *	</dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the *key* used to identify it. </dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> Multiple elements in the container can have equivalent *keys*. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements. Each element in a {@link TreeMultiSet} container is also identified
+     *			  by this value (each value is itself also the element's *key*).
+     *
+     * @reference http://www.cplusplus.com/reference/set/multiset
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
      * @author Jeongho Nam <http://samchon.org>
      */
     class TreeMultiSetCollection<T> extends std.TreeMultiSet<T> implements ICollection<T> {
@@ -1254,24 +1711,69 @@ declare namespace samchon.collection {
         removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
     }
 }
-declare namespace samchon.collection {
+declare namespace samchon.collections {
     /**
      * A {@link TreeMap} who can detect element I/O events.
      *
-     * <ul>
-     *	<li> <i>insert</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link insert} </li>
-     *		<li> {@link push} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link clear} </li>
-     *		<li> {@link erase} </li>
-     *		<li> {@link extract} </li>
-     *	</ul></li>
-     * </ul>
+     * Below is the list of methods who are dispatching {@link CollectionEvent}:
+     * - *insert* typed events:
+     *   - {@link assign}
+     *   - {@link insert}
+     *   - {@link insert_or_assign}
+     *   - {@link push}
+     * - *erase* typed events:
+     *   - {@link assign}
+     *   - {@link clear}
+     *   - {@link erase}
+     *   - {@link extract}
+     * - *refresh* typed events:
+     *   - {@link refresh}
      *
+     * #### [Inherited] {@link TreeSet}
+     * {@link TreeSet TreeSets} are containers that store unique elements following a specific order.
+     *
+     * In a {@link TreeSet}, the value of an element also identifies it (the value is itself the *key*, of type *T*),
+     * and each value must be unique. The value of the elements in a {@link TreeSet} cannot be modified once in the
+     * container (the elements are always const), but they can be inserted or removed from the container.
+     *
+     * Internally, the elements in a {@link TreeSet} are always sorted following a specific strict weak ordering
+     * criterion indicated by its internal comparison method (of {@link less}).
+     *
+     * {@link TreeSet} containers are generally slower than {@link HashSet} containers to access individual elements
+     * by their *key*, but they allow the direct iteration on subsets based on their order.
+     *
+     * {@link TreeSet}s are typically implemented as binary search trees.
+     *
+     * <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" />
+     * </a>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their *key* and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Ordered </dt>
+     *	<dd>
+     *		The elements in the container follow a strict order at all times. All inserted elements are
+     *		given a position in this order.
+     *	</dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the *key* used to identify it. </dd>
+     *
+     *	<dt> Unique keys </dt>
+     *	<dd> No two elements in the container can have equivalent *keys*. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *			  Each element in an {@link TreeSet} is also uniquely identified by this value.
+     *
+     * @reference http://www.cplusplus.com/reference/set/set
+     * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections)
      * @author Jeongho Nam <http://samchon.org>
      */
     class TreeSetCollection<T> extends std.TreeSet<T> implements ICollection<T> {
@@ -1339,483 +1841,9 @@ declare namespace samchon.collection {
 }
 declare namespace samchon.library {
     /**
-     * <p> XML is a class representing a tree structued xml objects. </p>
-     * <p> The XML class provides methods and properties for working with XML objects. </p>
+     * Case generator.
      *
-     * <p> The XML class (along with the XMLList and Namespace) implements
-     * the powerful XML-handling standard defined in ECMAScript for XML (E4X) specification. </p>
-     *
-     * <p> XML class has a recursive, hierarchical relationship. </p>
-     *
-     * <p> Relationships between XML and XMLList </p>
-     * <ul>
-     *	<li> XML is <code>std.HashMap<string, XMLList></code> </li>
-     *  <li> XMLList is <code>std.Deque<XML></code> </li>
-     * </ul>
-     *
-     * <h4> Note </h4>
-     * <p> Do not abuse values for expressing member variables. </p>
-     *
-     * <table>
-     *	<tr>
-     *		<th>Standard Usage</th>
-     *		<th>Non-standard usage abusing value</th>
-     *	</tr>
-     *	<tr>
-     *		<td>
-     * <code>
-     * <memberList>
-     *	<member id='jhnam88' name='Jeongho+Nam' birthdate='1988-03-11' />
-     *	<member id='master' name='Administartor' birthdate='2011-07-28' />
-     * </memberList>
-     * </code>
-     *		</td>
-     *		<td>
-     * <code>
-     * <memberList>
-     *	<member>
-     *		<id>jhnam88</id>
-     *		<name>Jeongho Nam</name>
-     *		<birthdate>1988-03-11</birthdate>
-     *	</member>
-     *	<member>
-     *		<id>master</id>
-     *		<name>Administartor</name>
-     *		<birthdate>2011-07-28</birthdate>
-     *	</member>
-     * </memberList>
-     * </code>
-     *		</td>
-     *	</tr>
-     * </table>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class XML extends std.HashMap<string, XMLList> {
-        /**
-         * <p> Tag name of the XML. </p>
-         *
-         * <ul>
-         *	<li> \<<b>tag</b> label='property' /\>: tag => \"tag\" </li>
-         *  <li> \<<b>price</b> high='1500' low='1300' open='1450' close='1320' /\>: tag => \"price\" </li>
-         * </ul>
-         */
-        private tag_;
-        /**
-         * <p> Value of the XML. </p>
-         *
-         * <ul>
-         *  <li> \<parameter name='age' type='int'\><b>26</b>\</parameter\>: value => 26 </li>
-         *	<li> \<price high='1500' low='1300' open='1450' close='1320' /\>: value => null </li>
-         * </ul>
-         */
-        private value_;
-        /**
-         * <p> Properties belongs to the XML. </p>
-         * <p> A Dictionary of properties accessing each property by its key. </p>
-         *
-         * <ul>
-         *	<li> \<price <b>high='1500' low='1300' open='1450' close='1320'</b> /\>:
-         *		propertyMap => {{\"high\": 1500}, {\"low\": 1300}, {\"open\": 1450}, {\"close\", 1320}} </li>
-         *	<li> \<member <b>id='jhnam88' name='Jeongho+Nam' comment='Hello.+My+name+is+Jeongho+Nam'</b> \>:
-         *		propertyMap => {{\"id\", \"jhnam88\"}, {\"name\", \"Jeongho Nam <http://samchon.org>\"},
-         *					 {\"comment\", \"Hello. My name is Jeongho Nam <http://samchon.org>\"}} </li>
-         * </ul>
-         */
-        private property_map_;
-        /**
-         * <p> Default Constructor. </p>
-         *
-         * <p> If the string parameter is not omitted, constructs its tag, value and
-         * properties by parsing the string. If there's children, then construct the
-         * children XML, XMLList objects, too. </p>
-         *
-         * @param str A string to be parsed
-         */
-        constructor(str?: string);
-        /**
-         * <p> Construct XML objects by parsing a string. </p>
-         */
-        private construct(str);
-        /**
-         * <p> Parse and fetch a tag. </p>
-         */
-        private parseTag(str);
-        /**
-         * <p> Parse and fetch properties. </p>
-         */
-        private parseProperty(str);
-        /**
-         * <p> Parse and fetch a value. </p>
-         */
-        private parseValue(str);
-        /**
-         * <p> Parse and construct children XML objects. </p>
-         */
-        private parseChildren(str);
-        /**
-         * <p> Get tag. </p>
-         */
-        getTag(): string;
-        /**
-         * <p> Get value. </p>
-         */
-        getValue(): string;
-        /**
-         * <p> Test whether a property exists or not. </p>
-         */
-        hasProperty(key: string): boolean;
-        /**
-         * <p> Get property by its key. </p>
-         */
-        getProperty(key: string): string;
-        getPropertyMap(): std.HashMap<string, string>;
-        /**
-         * <p> Set tag (identifier) of the XML. </p>
-         */
-        setTag(str: string): void;
-        /**
-         * <p> Set value of the XML. </p>
-         *
-         * <p> Do not abuse values for expressing member variables. </p>
-         * <table>
-         *	<tr>
-         *		<th>Standard Usage</th>
-         *		<th>Non-standard usage abusing value</th>
-         *	</tr>
-         *	<tr>
-         *		<td>
-         *			\<memberList\>\n
-         *			&nbsp;&nbsp;&nbsp;&nbsp;\<member id='jhnam88' name='Jeongho+Nam' birthdate='1988-03-11' /\>\n
-         *			&nbsp;&nbsp;&nbsp;&nbsp;\<member id='master' name='Administartor' birthdate='2011-07-28' /\>\n
-         *			\</memberList\>
-         *		</td>
-         *		<td>
-         *			\<member\>\n
-         *				\<id\>jhnam88\</id\>\n
-         *				\<name\>Jeongho+Nam\</name\>\n
-         *				\<birthdate\>1988-03-11\</birthdate\>\n
-         *			\</member\>
-         *		</td>
-         *	</tr>
-         * </table>
-         *
-         * @param val A value to set
-         */
-        setValue(str: string): void;
-        /**
-         * <p> Set a property with its key. </p>
-         */
-        setProperty(key: string, value: string): void;
-        /**
-         * <p> Erase a property by its key. </p>
-         *
-         * @param key The key of the property to erase
-         * @throw exception out of range
-         */
-        eraseProperty(key: string): void;
-        push<L extends string, U extends XMLList>(...args: std.Pair<L, U>[]): number;
-        push<L extends string, U extends XMLList>(...args: [L, U][]): number;
-        push(...xmls: XML[]): number;
-        push(...xmlLists: XMLList[]): number;
-        addAllProperties(xml: XML): void;
-        clearProperties(): void;
-        private calcMinIndex(...args);
-        /**
-         * <p> Decode a value. </p>
-         *
-         * <table>
-         *	<tr>
-         *		<th>Encoded</th>
-         *		<th>Decoded</th>
-         *	</tr>
-         *	<tr>
-         *		<td>\&amp;</td>
-         *		<td>\&</td>
-         *	</tr>
-         *	<tr>
-         *		<td>\&lt;</td>
-         *		<td>\<</td>
-         *	</tr>
-         *	<tr>
-         *		<td>\&gt;</td>
-         *		<td>\></td>
-         *	</tr>
-         * </table>
-         *
-         * @return A decoded string represents a value
-         */
-        static decodeValue(str: string): string;
-        /**
-         * <p> Encode a value. </p>
-         *
-         * <table>
-         *	<tr>
-         *		<th>Original</th>
-         *		<th>Encoded</th>
-         *	</tr>
-         *	<tr>
-         *		<td>\&</td>
-         *		<td>\&amp;</td>
-         *	</tr>
-         *	<tr>
-         *		<td>\<</td>
-         *		<td>\&lt;</td>
-         *	</tr>
-         *	<tr>
-         *		<td>\></td>
-         *		<td>\&gt;</td>
-         *	</tr>
-         * </table>
-         *
-         * @return A encoded string represents a value
-         */
-        static encodeValue(str: string): string;
-        /**
-          * <p> Decode a property. </p>
-          *
-          * <table>
-          *	<tr>
-          *		<th>Encoded</th>
-          *		<th>Decoded</th>
-          *	</tr>
-          *	<tr>
-          *		<td>\&amp;</td>
-          *		<td>\&</td>
-          *	</tr>
-          *	<tr>
-          *		<td>\&lt;</td>
-          *		<td>\<</td>
-          *	</tr>
-          *	<tr>
-          *		<td>\&gt;</td>
-          *		<td>\></td>
-          *	</tr>
-          *	<tr>
-          *		<td>&quot;</td>
-          *		<td>\"</td>
-          *	</tr>
-          *	<tr>
-          *		<td>&apos;</td>
-          *		<td>'</td>
-          *	</tr>
-          *	<tr>
-          *		<td>&#x9;</td>
-          *		<td>'</td>
-          *	</tr>
-          *	<tr>
-          *		<td>&apos;</td>
-          *		<td>\\t</td>
-          *	</tr>
-          *	<tr>
-          *		<td>&#xA;</td>
-          *		<td>\\n</td>
-          *	</tr>
-          *	<tr>
-          *		<td>&#xD;</td>
-          *		<td>\\r</td>
-          *	</tr>
-          * </table>
-          *
-          * @return A decoded string represents a property
-          */
-        static decodeProperty(str: string): string;
-        /**
-         * <p> Decode a property. </p>
-         *
-         * <table>
-         *	<tr>
-         *		<th>Original</th>
-         *		<th>Encoded</th>
-         *	</tr>
-         *	<tr>
-         *		<td>\&</td>
-         *		<td>\&amp;</td>
-         *	</tr>
-         *	<tr>
-         *		<td>\<</td>
-         *		<td>\&lt;</td>
-         *	</tr>
-         *	<tr>
-         *		<td>\></td>
-         *		<td>\&gt;</td>
-         *	</tr>
-         *	<tr>
-         *		<td>\"</td>
-         *		<td>&quot;</td>
-         *	</tr>
-         *	<tr>
-         *		<td>'</td>
-         *		<td>&apos;</td>
-         *	</tr>
-         *	<tr>
-         *		<td>'</td>
-         *		<td>&#x9;</td>
-         *	</tr>
-         *	<tr>
-         *		<td>\\t</td>
-         *		<td>&apos;</td>
-         *	</tr>
-         *	<tr>
-         *		<td>\\n</td>
-         *		<td>&#xA;</td>
-         *	</tr>
-         *	<tr>
-         *		<td>\\r</td>
-         *		<td>&#xD;</td>
-         *	</tr>
-         * </table>
-         *
-         * @return A encoded string represents a property
-         */
-        static encodeProperty(str: string): string;
-        /**
-         * <p> Convert the XML to a string. </p>
-         */
-        toString(level?: number): string;
-        /**
-         * <p> Convert the XML to HTML string. </p>
-         */
-        toHTML(level?: number): string;
-    }
-    /**
-     * <p> List of XML(s) having same tag. </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class XMLList extends std.Deque<XML> {
-        getTag(): string;
-        /**
-         * <p> Convert XMLList to string. </p>
-         *
-         * @param level Level(depth) of the XMLList.
-         */
-        toString(level?: number): string;
-        /**
-         * <p> Convert XMLList to HTML string. </p>
-         *
-         * @param level Level(depth) of the XMLList.
-         */
-        toHTML(level?: number): string;
-    }
-}
-declare namespace samchon.collection {
-    /**
-     * An {@link XMLList} who can detect element I/O events.
-     *
-     * <p> Below are list of methods who are dispatching {@link CollectionEvent}: </p>
-     *
-     * <ul>
-     *	<li> <i>insert</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link insert} </li>
-     *		<li> {@link push} </li>
-     *		<li> {@link push_front} </li>
-     *		<li> {@link push_back} </li>
-     *	</ul></li>
-     *	<li> <i>erase</i> typed events: <ul>
-     *		<li> {@link assign} </li>
-     *		<li> {@link clear} </li>
-     *		<li> {@link erase} </li>
-     *		<li> {@link pop_front} </li>
-     *		<li> {@link pop_back} </li>
-     *	</ul></li>
-     * </ul>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class XMLListCollection extends library.XMLList implements ICollection<library.XML> {
-        /**
-         * A chain object taking responsibility of dispatching events.
-         */
-        private event_dispatcher_;
-        /**
-         * @inheritdoc
-         */
-        push<U extends library.XML>(...items: U[]): number;
-        /**
-         * @inheritdoc
-         */
-        push_back(val: library.XML): void;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_repeating_val(position: std.DequeIterator<library.XML>, n: number, val: library.XML): std.DequeIterator<library.XML>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends library.XML, InputIterator extends std.Iterator<U>>(position: std.DequeIterator<library.XML>, begin: InputIterator, end: InputIterator): std.DequeIterator<library.XML>;
-        /**
-         * @inheritdoc
-         */
-        pop_back(): void;
-        /**
-         * @hidden
-         */
-        protected _Erase_by_range(first: std.DequeIterator<library.XML>, last: std.DequeIterator<library.XML>): std.DequeIterator<library.XML>;
-        /**
-         * @hidden
-         */
-        private notify_insert(first, last);
-        /**
-         * @hidden
-         */
-        private notify_erase(first, last);
-        /**
-         * @inheritdoc
-         */
-        hasEventListener(type: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        dispatchEvent(event: library.BasicEvent): boolean;
-        /**
-         * @inheritdoc
-         */
-        refresh(): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(it: std.DequeIterator<library.XML>): void;
-        /**
-         * @inheritdoc
-         */
-        refresh(first: std.DequeIterator<library.XML>, last: std.DequeIterator<library.XML>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<library.XML>): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<library.XML>): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<library.XML>): void;
-        /**
-         * @inheritdoc
-         */
-        addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        addEventListener(type: "insert", listener: CollectionEventListener<library.XML>, thisArg: Object): void;
-        addEventListener(type: "erase", listener: CollectionEventListener<library.XML>, thisArg: Object): void;
-        addEventListener(type: "refresh", listener: CollectionEventListener<library.XML>, thisArg: Object): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<library.XML>): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<library.XML>): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<library.XML>): void;
-        /**
-         * @inheritdoc
-         */
-        removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
-        removeEventListener(type: "insert", listener: CollectionEventListener<library.XML>, thisArg: Object): void;
-        removeEventListener(type: "erase", listener: CollectionEventListener<library.XML>, thisArg: Object): void;
-        removeEventListener(type: "refresh", listener: CollectionEventListener<library.XML>, thisArg: Object): void;
-    }
-}
-declare namespace samchon.library {
-    /**
-     * <p> Case generator. </p>
-     *
-     * <p> {@link CaseGenerator} is an abstract case generator being used like a matrix. </p>
+     * {@link CaseGenerator} is an abstract case generator being used like a matrix.
      * <ul>
      *  <li> n��r(n^r) -> {@link CombinedPermutationGenerator} </li>
      *  <li> nPr -> {@link PermutationGenerator} </li>
@@ -1826,40 +1854,40 @@ declare namespace samchon.library {
      */
     abstract class CaseGenerator {
         /**
-         * <p> Size, the number of all cases. </p>
+         * Size, the number of all cases.
          */
         protected size_: number;
         /**
-         * <p> N, size of the candidates. </p>
+         * N, size of the candidates.
          */
         protected n_: number;
         /**
-         * <p> R, size of elements of each case. </p>
+         * R, size of elements of each case.
          */
         protected r_: number;
         /**
-         * <p> Construct from size of N and R. </p>
+         * Construct from size of N and R.
          *
          * @param n Size of candidates.
          * @param r Size of elements of each case.
          */
         constructor(n: number, r: number);
         /**
-         * <p> Get size of all cases. </p>
+         * Get size of all cases.
          *
          * @return Get a number of the all cases.
          */
         size(): number;
         /**
-         * <p> Get size of the N. </p>
+         * Get size of the N.
          */
         n(): number;
         /**
-         * <p> Get size of the R. </p>
+         * Get size of the R.
          */
         r(): number;
         /**
-         * <p> Get index'th case. </p>
+         * Get index'th case.
          *
          * @param index Index number
          * @return The row of the index'th in combined permuation case
@@ -1867,19 +1895,19 @@ declare namespace samchon.library {
         abstract at(index: number): number[];
     }
     /**
-     * <p> A combined-permutation case generator. </p>
+     * A combined-permutation case generator.
      *
-     * <p> <sub>n</sub>��<sub>r</sub> </p>
+     * <sub>n</sub>��<sub>r</sub>
      *
      * @author Jeongho Nam <http://samchon.org>
      */
     class CombinedPermutationGenerator extends CaseGenerator {
         /**
-         * <p> An array using for dividing each element index. </p>
+         * An array using for dividing each element index.
          */
         private divider_array;
         /**
-         * <p> Construct from size of N and R. </p>
+         * Construct from size of N and R.
          *
          * @param n Size of candidates.
          * @param r Size of elements of each case.
@@ -1888,15 +1916,15 @@ declare namespace samchon.library {
         at(index: number): number[];
     }
     /**
-     * <p> A permutation case generator. </p>
+     * A permutation case generator.
      *
-     * <p> <sub>n</sub>P<sub>r</sub> </p>
+     * <sub>n</sub>P<sub>r</sub>
      *
      * @author Jeongho Nam <http://samchon.org>
      */
     class PermuationGenerator extends CaseGenerator {
         /**
-         * <p> Construct from size of N and R. </p>
+         * Construct from size of N and R.
          *
          * @param n Size of candidates.
          * @param r Size of elements of each case.
@@ -1908,9 +1936,9 @@ declare namespace samchon.library {
         at(index: number): number[];
     }
     /**
-     * <p> Factorial case generator. </p>
+     * Factorial case generator.
      *
-     * <p> n! = <sub>n</sub>P<sub>n</sub> </p>
+     * n! = <sub>n</sub>P<sub>n</sub>
      *
      * @author Jeongho Nam <http://samchon.org>
      */
@@ -1926,87 +1954,87 @@ declare namespace samchon.library {
 declare namespace samchon.library {
     type BasicEventListener = (event: BasicEvent) => void;
     /**
-     * <p> The IEventDispatcher interface defines methods for adding or removing event listeners, checks
-     * whether specific types of event listeners are registered, and dispatches events. </p>
+     * The IEventDispatcher interface defines methods for adding or removing event listeners, checks whether specific
+     * types of event listeners are registered, and dispatches events.
      *
-     * <p> Event targets are an important part of the Flash�� Player and Adobe AIR event model. The event
-     * target serves as the local point for how events flow through the display list hierarchy. When an
-     * event such as a mouse click or a key press occurs, an event object is dispatched into the event flow
-     * from the root of the display list. The event object makes a round-trip journey to the event target,
-     * which is conceptually divided into three phases: the capture phase includes the journey from the
-     * root to the last node before the event target's node; the target phase includes only the event
-     * target node; and the bubbling phase includes any subsequent nodes encountered on the return trip to
-     * the root of the display list. </p>
+     * The event target serves as the local point for how events flow through the display list hierarchy. When an
+     * event such as a mouse click or a key press occurs, an event object is dispatched into the event flow from the
+     * root of the display list. The event object makes a round-trip journey to the event target, which is
+     * conceptually divided into three phases: the capture phase includes the journey from the root to the last node
+     * before the event target's node; the target phase includes only the event target node; and the bubbling phase
+     * includes any subsequent nodes encountered on the return trip to the root of the display list.
      *
-     * <p> In general, the easiest way for a user-defined class to gain event dispatching capabilities is
-     * to extend EventDispatcher. If this is impossible (that is, if the class is already extending another
-     * class), you can instead implement the IEventDispatcher interface, create an EventDispatcher member,
-     * and write simple hooks to route calls into the aggregated EventDispatcher. </p>
+     * In general, the easiest way for a user-defined class to gain event dispatching capabilities is to extend
+     * {@link EventDispatcher}. If this is impossible (that is, if the class is already extending another class), you
+     * can instead implement the {@link IEventDispatcher} interface, create an {@link EventDispatcher} member, and
+     * write simple hooks to route calls into the aggregated {@link EventDispatcher}.
      *
      * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/events/IEventDispatcher.html
+     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Library-EventDispatcher
      * @author Migrated by Jeongho Nam <http://samchon.org>
      */
     interface IEventDispatcher {
         /**
-         * <p> Checks whether the EventDispatcher object has any listeners registered for a specific type
-         * of event. This allows you to determine where an EventDispatcher object has altered handling of
-         * an event type in the event flow hierarchy. To determine whether a specific event type actually
-         * triggers an event listener, use willTrigger(). </p>
+         * Checks whether the {@link EventDispatcher} object has any listeners registered for a specific type of event.
+         * This allows you to determine where an {@link EventDispatcher} object has altered handling of an event type
+         * in the event flow hierarchy. To determine whether a specific event type actually triggers an event listener,
+         * use {@link willTrigger willTrigger()}.
          *
-         * <p> The difference between hasEventListener() and willTrigger() is that hasEventListener()
-         * examines only the object to which it belongs, whereas willTrigger() examines the entire event
-         * flow for the event specified by the type parameter. </p>
+         * The difference between {@link hasEventListener hasEventListener()} and {@link willTrigger willTrigger()} is
+         * that {@link hasEventListener} examines only the object to which it belongs, whereas {@link willTrigger}
+         * examines the entire event flow for the event specified by the type parameter.
          *
          * @param type The type of event.
          */
         hasEventListener(type: string): boolean;
         /**
-         * <p> Dispatches an event into the event flow. </p>
-         * <p> The event target is the EventDispatcher object upon which the dispatchEvent() method is called. </p>
+         * Dispatches an event into the event flow.
          *
-         * @param event The Event object that is dispatched into the event flow. If the event is being
-         *			  redispatched, a clone of the event is created automatically. After an event is
-         *			  dispatched, its target property cannot be changed, so you must create a new copy
-         *			  of the event for redispatching to work.
+         * The event target is the {@link EventDispatcher} object upon which the {@link dispatchEvent dispatchEvent()}
+         * method is called.
+         *
+         * @param event The {@link BasicEvent} object that is dispatched into the event flow. If the event is being
+         *				redispatched, a clone of the event is created automatically. After an event is dispatched, its
+         *				target property cannot be changed, so you must create a new copy
+         *				of the event for redispatching to work.
          */
         dispatchEvent(event: library.BasicEvent): boolean;
         /**
-         * <p> Registers an event listener object with an EventDispatcher object so that the listener
-         * receives notification of an event. You can register event listeners on all nodes in the display
-         * list for a specific type of event, phase, and priority.
+         * Registers an event listener object with an {@link EventDispatcher} object so that the listener receives
+         * notification of an event. You can register event listeners on all nodes in the display list for a specific
+         * type of event, phase, and priority.
          *
-         * <p> After you successfully register an event listener, you cannot change its priority through
-         * additional calls to addEventListener(). To change a listener's priority, you must first call
-         * removeEventListener(). Then you can register the listener again with the new priority level. </p>
+         * After you successfully register an event listener, you cannot change its priority through additional calls
+         * to {@link addEventListener addEventListener()|} To change a listener's priority, you must first call
+         * {@link removeEventListener removeEventListener()}. Then you can register the listener again with the new
+         * priority level.
          *
-         * <p> Keep in mind that after the listener is registered, subsequent calls to addEventListener()
-         * with a different type or useCapture value result in the creation of a separate listener
-         * registration. For example, if you first register a listener with useCapture set to true,
-         * it listens only during the capture phase. If you call addEventListener() again using the same
-         * listener object, but with useCapture set to false, you have two separate listeners: one that
-         * listens during the capture phase and another that listens during the target and bubbling phases. </p>
+         * Keep in mind that after the listener is registered, subsequent calls to {@link addEventListener} with a
+         * different type or useCapture value result in the creation of a separate listener registration. For example,
+         * if you first register a listener with useCapture set to true, it listens only during the capture phase. If
+         * you call {@link addEventListener} again using the same listener object, but with useCapture set to false,
+         * you have two separate listeners: one that listens during the capture phase and another that listens during
+         * the target and bubbling phases.
          *
-         * <p> You cannot register an event listener for only the target phase or the bubbling phase.
-         * Those phases are coupled during registration because bubbling applies only to the ancestors of
-         * the target node. </p>
+         * You cannot register an event listener for only the target phase or the bubbling phase. Those phases are
+         * coupled during registration because bubbling applies only to the ancestors of the target node.
          *
-         * <p> If you no longer need an event listener, remove it by calling removeEventListener(), or
-         * memory problems could result. Event listeners are not automatically removed from memory because
-         * the garbage collector does not remove the listener as long as the dispatching object exists
-         * (unless the useWeakReference parameter is set to true). </p>
+         * If you no longer need an event listener, remove it by calling {@link removeEventListener}, or memory
+         * problems could result. Event listeners are not automatically removed from memory because the garbage
+         * collector does not remove the listener as long as the dispatching object exists (unless the
+         * useWeakReference parameter is set to true).
          *
-         * <p> Copying an EventDispatcher instance does not copy the event listeners attached to it. (If
-         * your newly created node needs an event listener, you must attach the listener after creating
-         * the node.) However, if you move an EventDispatcher instance, the event listeners attached to
-         * it move along with it. </p>
+         * Copying an {@link EventDispatcher} instance does not copy the event listeners attached to it. (If your n
+         * ewly created node needs an event listener, you must attach the listener after creating the node.) However,
+         * if you move an {@link EventDispatcher} instance, the event listeners attached to it move along with it.
          *
-         * <p> If the event listener is being registered on a node while an event is also being processed
-         * on this node, the event listener is not triggered during the current phase but may be triggered
-         * during a later phase in the event flow, such as the bubbling phase. </p>
+         * If the event listener is being registered on a node while an event is also being processed on this node,
+         * the event listener is not triggered during the current phase but may be triggered during a later phase in
+         * the event flow, such as the bubbling phase.
          *
-         * <p> If an event listener is removed from a node while an event is being processed on the node,
-         * it is still triggered by the current actions. After it is removed, the event listener is never
-         * invoked again (unless it is registered again for future processing). </p>
+         * If an event listener is removed from a node while an event is being processed on the node, it is still
+         * triggered by the current actions. After it is removed, the event listener is never invoked again (unless it
+         * is registered again for future processing).
          *
          * @param event The type of event.
          * @param listener The listener function that processes the event.
@@ -2015,121 +2043,97 @@ declare namespace samchon.library {
          */
         addEventListener(type: string, listener: library.BasicEventListener): void;
         /**
-         * <p> Registers an event listener object with an EventDispatcher object so that the listener
-         * receives notification of an event. You can register event listeners on all nodes in the display
-         * list for a specific type of event, phase, and priority.
+         * Registers an event listener object with an {@link EventDispatcher} object so that the listener receives
+         * notification of an event. You can register event listeners on all nodes in the display list for a specific
+         * type of event, phase, and priority.
          *
-         * <p> After you successfully register an event listener, you cannot change its priority through
-         * additional calls to addEventListener(). To change a listener's priority, you must first call
-         * removeEventListener(). Then you can register the listener again with the new priority level. </p>
+         * After you successfully register an event listener, you cannot change its priority through additional calls
+         * to {@link addEventListener addEventListener()|} To change a listener's priority, you must first call
+         * {@link removeEventListener removeEventListener()}. Then you can register the listener again with the new
+         * priority level.
          *
-         * <p> Keep in mind that after the listener is registered, subsequent calls to addEventListener()
-         * with a different type or useCapture value result in the creation of a separate listener
-         * registration. For example, if you first register a listener with useCapture set to true,
-         * it listens only during the capture phase. If you call addEventListener() again using the same
-         * listener object, but with useCapture set to false, you have two separate listeners: one that
-         * listens during the capture phase and another that listens during the target and bubbling phases. </p>
+         * Keep in mind that after the listener is registered, subsequent calls to {@link addEventListener} with a
+         * different type or useCapture value result in the creation of a separate listener registration. For example,
+         * if you first register a listener with useCapture set to true, it listens only during the capture phase. If
+         * you call {@link addEventListener} again using the same listener object, but with useCapture set to false,
+         * you have two separate listeners: one that listens during the capture phase and another that listens during
+         * the target and bubbling phases.
          *
-         * <p> You cannot register an event listener for only the target phase or the bubbling phase.
-         * Those phases are coupled during registration because bubbling applies only to the ancestors of
-         * the target node. </p>
+         * You cannot register an event listener for only the target phase or the bubbling phase. Those phases are
+         * coupled during registration because bubbling applies only to the ancestors of the target node.
          *
-         * <p> If you no longer need an event listener, remove it by calling removeEventListener(), or
-         * memory problems could result. Event listeners are not automatically removed from memory because
-         * the garbage collector does not remove the listener as long as the dispatching object exists
-         * (unless the useWeakReference parameter is set to true). </p>
+         * If you no longer need an event listener, remove it by calling {@link removeEventListener}, or memory
+         * problems could result. Event listeners are not automatically removed from memory because the garbage
+         * collector does not remove the listener as long as the dispatching object exists (unless the
+         * useWeakReference parameter is set to true).
          *
-         * <p> Copying an EventDispatcher instance does not copy the event listeners attached to it. (If
-         * your newly created node needs an event listener, you must attach the listener after creating
-         * the node.) However, if you move an EventDispatcher instance, the event listeners attached to
-         * it move along with it. </p>
+         * Copying an {@link EventDispatcher} instance does not copy the event listeners attached to it. (If your n
+         * ewly created node needs an event listener, you must attach the listener after creating the node.) However,
+         * if you move an {@link EventDispatcher} instance, the event listeners attached to it move along with it.
          *
-         * <p> If the event listener is being registered on a node while an event is also being processed
-         * on this node, the event listener is not triggered during the current phase but may be triggered
-         * during a later phase in the event flow, such as the bubbling phase. </p>
+         * If the event listener is being registered on a node while an event is also being processed on this node,
+         * the event listener is not triggered during the current phase but may be triggered during a later phase in
+         * the event flow, such as the bubbling phase.
          *
-         * <p> If an event listener is removed from a node while an event is being processed on the node,
-         * it is still triggered by the current actions. After it is removed, the event listener is never
-         * invoked again (unless it is registered again for future processing). </p>
+         * If an event listener is removed from a node while an event is being processed on the node, it is still
+         * triggered by the current actions. After it is removed, the event listener is never invoked again (unless it
+         * is registered again for future processing).
          *
          * @param event The type of event.
          * @param listener The listener function that processes the event.
          *				 This function must accept an Event object as its only parameter and must return
          *				 nothing.
-         * @param thisArg The object to be used as the <b>this</b> object.
+         * @param thisArg The object to be used as the **this** object.
          */
         addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
         /**
-         * Removes a listener from the EventDispatcher object. If there is no matching listener registered
-         * with the EventDispatcher object, a call to this method has no effect.
+         * Removes a listener from the {@link EventDispatcher} object. If there is no matching listener registered
+         * with the {@link EventDispatcher} object, a call to this method has no effect.
          *
          * @param type The type of event.
          * @param listener The listener object to remove.
          */
         removeEventListener(type: string, listener: library.BasicEventListener): void;
         /**
-         * Removes a listener from the EventDispatcher object. If there is no matching listener registered
-         * with the EventDispatcher object, a call to this method has no effect.
+         * Removes a listener from the {@link EventDispatcher} object. If there is no matching listener registered
+         * with the {@link EventDispatcher} object, a call to this method has no effect.
          *
          * @param type The type of event.
          * @param listener The listener object to remove.
-         * @param thisArg The object to be used as the <b>this</b> object.
+         * @param thisArg The object to be used as the **this** object.
          */
         removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
     }
     /**
-     * <p> Registers an event listener object with an EventDispatcher object so that the listener
-     * receives notification of an event. You can register event listeners on all nodes in the display
-     * list for a specific type of event, phase, and priority. </p>
+     * The {@link EventDispatcher} class is the base class for all classes that dispatch events. The
+     * {@link EventDispatcher} class implements the {@link IEventDispatcher} interface and is the base class for the
+     * {@link DisplayObject} class. The {@link EventDispatcher} class allows any object on the display list to be an
+     * event target and as such, to use the methods of the {@link IEventDispatcher} interface.
      *
-     * <p> After you successfully register an event listener, you cannot change its priority through
-     * additional calls to addEventListener(). To change a listener's priority, you must first call
-     * removeListener(). Then you can register the listener again with the new priority level. </p>
+     * The event target serves as the local point for how events flow through the display list hierarchy. When an
+     * event such as a mouse click or a key press occurs, an event object is dispatched into the event flow from the
+     * root of the display list. The event object makes a round-trip journey to the event target, which is
+     * conceptually divided into three phases: the capture phase includes the journey from the root to the last node
+     * before the event target's node; the target phase includes only the event target node; and the bubbling phase
+     * includes any subsequent nodes encountered on the return trip to the root of the display list.
      *
-     * Keep in mind that after the listener is registered, subsequent calls to <code>addEventListener()</code>
-     * with a different type or useCapture value result in the creation of a separate listener registration.
-     * For example, if you first register a listener with useCapture set to true, it listens only during the
-     * capture phase. If you call addEventListener() again using the same listener object, but with
-     * useCapture set to false, you have two separate listeners: one that listens during the capture
-     * phase and another that listens during the target and bubbling phases.
-     *
-     * <p> You cannot register an event listener for only the target phase or the bubbling phase. Those
-     * phases are coupled during registration because bubbling applies only to the ancestors of the
-     * target node. </p>
-     *
-     * <p> If you no longer need an event listener, remove it by calling <code>removeEventListener()</code>,
-     * or memory problems could result. Event listeners are not automatically removed from memory
-     * because the garbage collector does not remove the listener as long as the dispatching object
-     * exists (unless the useWeakReference parameter is set to true). </p>
-     *
-     * <p> Copying an EventDispatcher instance does not copy the event listeners attached to it. (If your
-     * newly created node needs an event listener, you must attach the listener after creating the
-     * node.) However, if you move an EventDispatcher instance, the event listeners attached to it move
-     * along with it. </p>
-     *
-     * <p> If the event listener is being registered on a node while an event is being processed on
-     * this node, the event listener is not triggered during the current phase but can be triggered
-     * during a later phase in the event flow, such as the bubbling phase. </p>
-     *
-     * <p> If an event listener is removed from a node while an event is being processed on the node, it is
-     * still triggered by the current actions. After it is removed, the event listener is never invoked
-     * again (unless registered again for future processing). </p>
-     *
-     * <ul>
-     *  <li> Made by AS3 - http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/events/EventDispatcher.html
-     * </ul>
+     * In general, the easiest way for a user-defined class to gain event dispatching capabilities is to extend
+     * {@link EventDispatcher}. If this is impossible (that is, if the class is already extending another class), you
+     * can instead implement the {@link IEventDispatcher} interface, create an {@link EventDispatcher} member, and
+     * write simple hooks to route calls into the aggregated {@link EventDispatcher}.
      *
+     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/events/EventDispatcher.html
      * @author Migrated by Jeongho Nam <http://samchon.org>
      */
     class EventDispatcher implements IEventDispatcher {
         /**
-         * The origin object who issuing events.
+         * @hidden
          */
-        protected event_dispatcher_: IEventDispatcher;
+        private event_dispatcher_;
         /**
-         * Container of listeners.
+         * @hidden
          */
-        protected event_listeners_: std.HashMap<string, std.HashSet<std.Pair<library.BasicEventListener, Object>>>;
+        private event_listeners_;
         /**
          * Default Constructor.
          */
@@ -2168,19 +2172,19 @@ declare namespace samchon.library {
 }
 declare namespace samchon.library {
     /**
-     * <p> The {@link FileReference} class provides a means to load and save files in browser level. </p>
+     * The {@link FileReference} class provides a means to load and save files in browser level.
      *
-     * <p> The {@link FileReference} class provides a means to {@link load} and {@link save} files in browser level. A
+     * The {@link FileReference} class provides a means to {@link load} and {@link save} files in browser level. A
      * browser-system dialog box prompts the user to select a file to {@link load} or a location for {@link svae}. Each
      * {@link FileReference} object refers to a single file on the user's disk and has properties that contain
      * information about the file's size, type, name, creation date, modification date, and creator type (Macintosh only).
-     * </p>
      *
-     * <p> FileReference instances are created in the following ways: </p>
+     *
+     * FileReference instances are created in the following ways:
      * <ul>
      *	<li>
      *		When you use the new operator with the {@link FileReference} constructor:
-     *		<code>var myFileReference = new FileReference();</code>
+     *		<code>let myFileReference: FileReference = new FileReference();</code>
      *	</li>
      *	<li>
      *		When you call the {@link FileReferenceList.browse} method, which creates an array of {@link FileReference}
@@ -2188,23 +2192,23 @@ declare namespace samchon.library {
      *	</li>
      * </ul>
      *
-     * <p> During a load operation, all the properties of a {@link FileReference} object are populated by calls to the
+     * During a load operation, all the properties of a {@link FileReference} object are populated by calls to the
      * {@link FileReference.browse} or {@link FileReferenceList.browse} methods. During a save operation, the name
      * property is populated when the select event is dispatched; all other properties are populated when the complete
-     * event is dispatched. </p>
+     * event is dispatched.
      *
-     * <p> The {@link browse browse()} method opens an browser-system dialog box that prompts the user to select a file
+     * The {@link browse browse()} method opens an browser-system dialog box that prompts the user to select a file
      * for {@link load}. The {@link FileReference.browse} method lets the user select a single file; the
      * {@link FileReferenceList.browse} method lets the user select multiple files. After a successful call to the
      * {@link browse browse()} method, call the {@link FileReference.load} method to load one file at a time. The
      * {@link FileReference.save} method prompts the user for a location to save the file and initiates downloading from
-     * a binary or string data. </p>
+     * a binary or string data.
      *
-     * <p> The {@link FileReference} and {@link FileReferenceList} classes do not let you set the default file location
+     * The {@link FileReference} and {@link FileReferenceList} classes do not let you set the default file location
      * for the dialog box that the {@link browse} or {@link save} methods generate. The default location shown in the
      * dialog box is the most recently browsed folder, if that location can be determined, or the desktop. The classes do
      * not allow you to read from or write to the transferred file. They do not allow the browser that initiated the
-     * {@link load} or {@link save} to access the loaded or saved file or the file's location on the user's disk. </p>
+     * {@link load} or {@link save} to access the loaded or saved file or the file's location on the user's disk.
      *
      * @references http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/FileReference.html
      * @author Jeongho Nam <http://samchon.org>
@@ -2223,148 +2227,144 @@ declare namespace samchon.library {
          */
         constructor();
         /**
-         * <p> The data from the loaded file after a successful call to the {@link load load()} method. </p>
+         * The data from the loaded file after a successful call to the {@link load load()} method.
          *
-         * <p> If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
-         * an {@link LogicError exception} will be thrown when you try to get the value of this property. </p>
+         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
+         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
+         *
+         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
          *
-         * <p> All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
-         * </p>
          */
-        data: any;
+        readonly data: any;
         /**
-         * <p> The name of the file on the local disk. </p>
+         * The name of the file on the local disk.
          *
-         * <p> If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
-         * an {@link LogicError exception} will be thrown when you try to get the value of this property. </p>
+         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
+         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
+         *
+         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
          *
-         * <p> All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
-         * </p>
          */
-        name: string;
+        readonly name: string;
         /**
-         * <p> The filename extension. </p>
+         * The filename extension.
          *
-         * <p> A file's extension is the part of the name following (and not including) the final dot (&quot;.&quot;). If
-         * there is no dot in the filename, the extension is <code>null</code>. </p>
+         * A file's extension is the part of the name following (and not including) the final dot (&quot;.&quot;). If
+         * there is no dot in the filename, the extension is <code>null</code>.
          *
-         * <p> If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
-         * an {@link LogicError exception} will be thrown when you try to get the value of this property. </p>
+         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
+         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
+         *
+         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
          *
-         * <p> All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
-         * </p>
          */
-        extension: string;
+        readonly extension: string;
         /**
-         * <p> The file type, metadata of the {@link extension}. </p>
+         * The file type, metadata of the {@link extension}.
          *
-         * <p> If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
-         * an {@link LogicError exception} will be thrown when you try to get the value of this property. </p>
+         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
+         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
+         *
+         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
          *
-         * <p> All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
-         * </p>
          */
-        type: string;
+        readonly type: string;
         /**
-         * <p> The size of the file on the local disk in bytes. </p>
+         * The size of the file on the local disk in bytes.
          *
-         * <p> If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
-         * an {@link LogicError exception} will be thrown when you try to get the value of this property. </p>
+         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
+         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
+         *
+         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
          *
-         * <p> All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
-         * </p>
          */
-        size: number;
+        readonly size: number;
         /**
-         * <p> The date that the file on the local disk was last modified. </p>
+         * The date that the file on the local disk was last modified.
          *
-         * <p> If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
-         * an {@link LogicError exception} will be thrown when you try to get the value of this property. </p>
+         * If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
+         * an {@link LogicError exception} will be thrown when you try to get the value of this property.
+         *
+         * All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
          *
-         * <p> All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
-         * </p>
          */
-        modificationDate: Date;
+        readonly modificationDate: Date;
         /**
-         * @hidden
-         */
-        _Set_file(val: File): void;
-        /**
-         * <p> Displays a file-browsing dialog box that lets the user select a file to upload. The dialog box is native
+         * Displays a file-browsing dialog box that lets the user select a file to upload. The dialog box is native
          * to the user's browser system. The user can select a file on the local computer or from other systems, for
-         * example, through a UNC path on Windows. </p>
+         * example, through a UNC path on Windows.
          *
-         * <p> When you call this method and the user successfully selects a file, the properties of this
+         * When you call this method and the user successfully selects a file, the properties of this
          * {@link FileReference} object are populated with the properties of that file. Each subsequent time that the
          * {@link FileReference.browse} method is called, the {@link FileReference} object's properties are reset to
          * the file that the user selects in the dialog box. Only one {@link browse browse()} can be performed at a time
-         * (because only one dialog box can be invoked at a time). </p>
+         * (because only one dialog box can be invoked at a time).
          *
-         * <p> Using the <i>typeFilter parameter</i>, you can determine which files the dialog box displays. </p>
+         * Using the *typeFilter parameter*, you can determine which files the dialog box displays.
          *
          * @param typeFilter An array of filter strings used to filter the files that are displayed in the dialog box.
          *					 If you omit this parameter, all files are displayed.
          */
         browse(...typeFilter: string[]): void;
         /**
-         * <p> Starts the load of a local file selected by a user. </p>
+         * Starts the load of a local file selected by a user.
          *
-         * <p> You must call the {@link FileReference.browse} or {@link FileReferenceList.browse} method before you call
-         * the {@link load load()} method. </p>
+         * You must call the {@link FileReference.browse} or {@link FileReferenceList.browse} method before you call
+         * the {@link load load()} method.
          *
-         * <p> Listeners receive events to indicate the progress, success, or failure of the load. Although you can use
+         * Listeners receive events to indicate the progress, success, or failure of the load. Although you can use
          * the {@link FileReferenceList} object to let users select multiple files to load, you must {@link load} the
          * {@link FileReferenceList files} one by one. To {@link load} the files one by one, iterate through the
-         * {@link FileReferenceList.fileList} array of {@link FileReference} objects. </p>
+         * {@link FileReferenceList.fileList} array of {@link FileReference} objects.
          *
-         * <p> If the file finishes loading successfully, its contents are stored in the {@link data} property. </p>
+         * If the file finishes loading successfully, its contents are stored in the {@link data} property.
          */
         load(): void;
         /**
-         * <p> Save a file to local filesystem. </p>
+         * Save a file to local filesystem.
          *
-         * <p> {@link FileReference.save} implemented the save function by downloading a file from a hidden anchor tag.
-         * However, the plan, future's {@link FileReference} will follow such rule: </p>
+         * {@link FileReference.save} implemented the save function by downloading a file from a hidden anchor tag.
+         * However, the plan, future's {@link FileReference} will follow such rule:
          *
-         * <p> Opens a dialog box that lets the user save a file to the local filesystem. </p>
+         * Opens a dialog box that lets the user save a file to the local filesystem.
          *
-         * <p> The {@link save save()} method first opens an browser-system dialog box that asks the user to enter a
+         * The {@link save save()} method first opens an browser-system dialog box that asks the user to enter a
          * filename and select a location on the local computer to save the file. When the user selects a location and
          * confirms the save operation (for example, by clicking Save), the save process begins. Listeners receive events
          * to indicate the progress, success, or failure of the save operation. To ascertain the status of the dialog box
          * and the save operation after calling {@link save save()}, your code must listen for events such as cancel,
-         * open, progress, and complete. </p>
+         * open, progress, and complete.
          *
-         * <p> When the file is saved successfully, the properties of the {@link FileReference} object are populated with
-         * the properties of the local file. The complete event is dispatched if the save is successful. </p>
+         * When the file is saved successfully, the properties of the {@link FileReference} object are populated with
+         * the properties of the local file. The complete event is dispatched if the save is successful.
          *
-         * <p> Only one {@link browse browse()} or {@link save()} session can be performed at a time (because only one
-         * dialog box can be invoked at a time). </p>
+         * Only one {@link browse browse()} or {@link save()} session can be performed at a time (because only one
+         * dialog box can be invoked at a time).
          *
          * @param data The data to be saved. The data can be in one of several formats, and will be treated appropriately.
          * @param fileName File name to be saved.
          */
         save(data: string, fileName: string): void;
         /**
-         * <p> Save a file to local filesystem. </p>
+         * Save a file to local filesystem.
          *
-         * <p> {@link FileReference.save} implemented the save function by downloading a file from a hidden anchor tag.
-         * However, the plan, future's {@link FileReference} will follow such rule: </p>
+         * {@link FileReference.save} implemented the save function by downloading a file from a hidden anchor tag.
+         * However, the plan, future's {@link FileReference} will follow such rule:
          *
-         * <p> Opens a dialog box that lets the user save a file to the local filesystem. </p>
+         * Opens a dialog box that lets the user save a file to the local filesystem.
          *
-         * <p> The {@link save save()} method first opens an browser-system dialog box that asks the user to enter a
+         * The {@link save save()} method first opens an browser-system dialog box that asks the user to enter a
          * filename and select a location on the local computer to save the file. When the user selects a location and
          * confirms the save operation (for example, by clicking Save), the save process begins. Listeners receive events
          * to indicate the progress, success, or failure of the save operation. To ascertain the status of the dialog box
          * and the save operation after calling {@link save save()}, your code must listen for events such as cancel,
-         * open, progress, and complete. </p>
+         * open, progress, and complete.
          *
-         * <p> When the file is saved successfully, the properties of the {@link FileReference} object are populated with
-         * the properties of the local file. The complete event is dispatched if the save is successful. </p>
+         * When the file is saved successfully, the properties of the {@link FileReference} object are populated with
+         * the properties of the local file. The complete event is dispatched if the save is successful.
          *
-         * <p> Only one {@link browse browse()} or {@link save()} session can be performed at a time (because only one
-         * dialog box can be invoked at a time). </p>
+         * Only one {@link browse browse()} or {@link save()} session can be performed at a time (because only one
+         * dialog box can be invoked at a time).
          *
          * @param data The data to be saved. The data can be in one of several formats, and will be treated appropriately.
          * @param fileName File name to be saved.
@@ -2372,13 +2372,13 @@ declare namespace samchon.library {
         static save(data: string, fileName: string): void;
     }
     /**
-     * <p> The {@link FileReferenceList} class provides a means to let users select one or more files for
+     * The {@link FileReferenceList} class provides a means to let users select one or more files for
      * {@link FileReference.load loading}. A {@link FileReferenceList} object represents a group of one or more local
      * files on the user's disk as an array of {@link FileReference} objects. For detailed information and important
      * considerations about {@link FileReference} objects and the FileReference class, which you use with
-     * {@link FileReferenceList}, see the {@link FileReference} class. </p>
+     * {@link FileReferenceList}, see the {@link FileReference} class.
      *
-     * <p> To work with the {@link FileReferenceList} class: </p>
+     * To work with the {@link FileReferenceList} class:
      * <ul>
      *	<li> Instantiate the class: <code>var myFileRef = new FileReferenceList();</code> </li>
      *	<li>
@@ -2392,8 +2392,8 @@ declare namespace samchon.library {
      *	<li> Call {@link FileReference.load} on each element in the {@link fileList} array. </li>
      * </ul>
      *
-     * <p> The {@link FileReferenceList} class includes a {@link browse browse()} method and a {@link fileList} property
-     * for working with multiple files. </p>
+     * The {@link FileReferenceList} class includes a {@link browse browse()} method and a {@link fileList} property
+     * for working with multiple files.
      *
      * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/FileReferenceList.html
      * @author Jeongho Nam <http://samchon.org>
@@ -2408,31 +2408,31 @@ declare namespace samchon.library {
          */
         constructor();
         /**
-         * <p> An array of {@link FileReference} objects. </p>
+         * An array of {@link FileReference} objects.
          *
-         * <p> When the {@link FileReferenceList.browse} method is called and the user has selected one or more files
+         * When the {@link FileReferenceList.browse} method is called and the user has selected one or more files
          * from the dialog box that the {@link browse browse()} method opens, this property is populated with an array of
-         * {@link FileReference} objects, each of which represents the files the user selected. </p>
+         * {@link FileReference} objects, each of which represents the files the user selected.
          *
-         * <p> The {@link fileList} property is populated anew each time {@link browse browse()} is called on that
-         * {@link FileReferenceList} object. </p>
+         * The {@link fileList} property is populated anew each time {@link browse browse()} is called on that
+         * {@link FileReferenceList} object.
          */
-        fileList: std.Vector<FileReference>;
+        readonly fileList: std.Vector<FileReference>;
         /**
-         * <p> Displays a file-browsing dialog box that lets the user select one or more local files to upload. The
-         * dialog box is native to the user's browser system.  </p>
+         * Displays a file-browsing dialog box that lets the user select one or more local files to upload. The
+         * dialog box is native to the user's browser system.
          *
-         * <p> When you call this method and the user successfully selects files, the {@link fileList} property of this
+         * When you call this method and the user successfully selects files, the {@link fileList} property of this
          * {@link FileReferenceList} object is populated with an array of {@link FileReference} objects, one for each
          * file that the user selects. Each subsequent time that the {@link FileReferenceList.browse} method is called,
          * the {@link FileReferenceList.fileList} property is reset to the file(s) that the user selects in the dialog
-         * box. </p>
+         * box.
          *
-         * <p> Using the <i>typeFilter</i> parameter, you can determine which files the dialog box displays. </p>
+         * Using the *typeFilter* parameter, you can determine which files the dialog box displays.
          *
-         * <p> Only one {@link FileReference.browse}, {@link FileReference.load}, or {@link FileReferenceList.browse}
+         * Only one {@link FileReference.browse}, {@link FileReference.load}, or {@link FileReferenceList.browse}
          * session can be performed at a time on a {@link FileReferenceList} object (because only one dialog box can be
-         * opened at a time). </p>
+         * opened at a time).
          *
          * @param typeFilter An array of filter strings used to filter the files that are displayed in the dialog box.
          *					 If you omit this parameter, all files are displayed.
@@ -2442,16 +2442,15 @@ declare namespace samchon.library {
 }
 declare namespace samchon.library {
     /**
-     * <p> A genetic algorithm class. </p>
+     * A genetic algorithm class.
      *
-     * @details
-     * <p> In the field of artificial intelligence, a genetic algorithm (GA) is a search heuristic that mimics the
+     * In the field of artificial intelligence, a genetic algorithm (GA) is a search heuristic that mimics the
      * process of natural selection. This heuristic (also sometimes called a metaheuristic) is routinely used to generate
-     * useful solutions to optimization and search problems. </p>
+     * useful solutions to optimization and search problems.
      *
-     * <p> Genetic algorithms belong to the larger class of evolutionary algorithms (EA), which generate solutions to
+     * Genetic algorithms belong to the larger class of evolutionary algorithms (EA), which generate solutions to
      * optimization problems using techniques inspired by natural evolution, such as inheritance, {@link mutate mutation},
-     * {@link selection}, and {@link crossover}. </p>
+     * {@link selection}, and {@link crossover}.
      *
      * @reference https://en.wikipedia.org/wiki/Genetic_algorithm
      * @author Jeongho Nam <http://samchon.org>
@@ -2488,22 +2487,22 @@ declare namespace samchon.library {
          */
         constructor(unique?: boolean, mutation_rate?: number, tournament?: number);
         /**
-         * <p> Evolove <i>GeneArray</i>. </p>
+         * Evolove *GeneArray*.
          *
-         * <p> Convenient method accessing to {@link evolvePopulation evolvePopulation()}. </p>
+         * Convenient method accessing to {@link evolvePopulation evolvePopulation()}.
          *
          * @param individual An initial set of genes; sequence listing.
          * @param population Size of population in a generation.
          * @param generation Size of generation in evolution.
          * @param compare A comparison function returns whether left gene is more optimal.
          *
-         * @return An evolved <i>GeneArray</i>, optimally.
+         * @return An evolved *GeneArray*, optimally.
          *
          * @see {@link GAPopulation.compare}
          */
         evolveGeneArray<T, GeneArray extends std.base.IArrayContainer<T>>(individual: GeneArray, population: number, generation: number, compare?: (left: T, right: T) => boolean): GeneArray;
         /**
-         * Evolve <i>population</i>, a mass of <i>GeneArraies</i>.
+         * Evolve *population*, a mass of *GeneArraies*.
          *
          * @param population An initial population.
          * @param compare A comparison function returns whether left gene is more optimal.
@@ -2514,11 +2513,11 @@ declare namespace samchon.library {
          */
         evolvePopulation<T, GeneArray extends std.base.IArrayContainer<T>>(population: GAPopulation<T, GeneArray>, compare?: (left: T, right: T) => boolean): GAPopulation<T, GeneArray>;
         /**
-         * <p> Select the best GeneArray in <i>population</i> from tournament. </p>
+         * Select the best GeneArray in *population* from tournament.
          *
-         * <p> {@link selection Selection} is the stage of a genetic algorithm in which individual genomes are chosen
+         * {@link selection Selection} is the stage of a genetic algorithm in which individual genomes are chosen
          * from a population for later breeding (using {@linlk crossover} operator). A generic {@link selection}
-         * procedure may be implemented as follows: </p>
+         * procedure may be implemented as follows:
          *
          * <ol>
          *	<li>
@@ -2543,14 +2542,14 @@ declare namespace samchon.library {
          */
         private selection<T, GeneArray>(population);
         /**
-         * <p> Create a new GeneArray by crossing over two <i>GeneArray</i>(s). </p>
+         * Create a new GeneArray by crossing over two *GeneArray*(s).
          *
-         * <p> {@link crossover} is a genetic operator used to vary the programming of a chromosome or chromosomes from
+         * {@link crossover} is a genetic operator used to vary the programming of a chromosome or chromosomes from
          * one generation to the next. It is analogous to reproduction and biological crossover, upon which genetic
-         * algorithms are based. </p>
+         * algorithms are based.
          *
-         * <p> {@link crossover Cross over} is a process of taking more than one parent solutions and producing a child
-         * solution from them. There are methods for selection of the chromosomes. </p>
+         * {@link crossover Cross over} is a process of taking more than one parent solutions and producing a child
+         * solution from them. There are methods for selection of the chromosomes.
          *
          * @param parent1 A parent sequence listing
          * @param parent2 A parent sequence listing
@@ -2559,25 +2558,25 @@ declare namespace samchon.library {
          */
         private crossover<T, GeneArray>(parent1, parent2);
         /**
-         * <p> Cause a mutation on the <i>GeneArray</i>. </p>
+         * Cause a mutation on the *GeneArray*.
          *
-         * <p> {@link mutate Mutation} is a genetic operator used to maintain genetic diversity from one generation of a
-         * population of genetic algorithm chromosomes to the next. It is analogous to biological mutation. </p>
+         * {@link mutate Mutation} is a genetic operator used to maintain genetic diversity from one generation of a
+         * population of genetic algorithm chromosomes to the next. It is analogous to biological mutation.
          *
-         * <p> {@link mutate Mutation} alters one or more gene values in a chromosome from its initial state. In
+         * {@link mutate Mutation} alters one or more gene values in a chromosome from its initial state. In
          * {@link mutate mutation}, the solution may change entirely from the previous solution. Hence GA can come to
-         * better solution by using {@link mutate mutation}. </p>
+         * better solution by using {@link mutate mutation}.
          *
-         * <p> {@link mutate Mutation} occurs during evolution according to a user-definable mutation probability. This
-         * probability should be set low. If it is set too high, the search will turn into a primitive random search. </p>
+         * {@link mutate Mutation} occurs during evolution according to a user-definable mutation probability. This
+         * probability should be set low. If it is set too high, the search will turn into a primitive random search.
          *
          * <h4> Note </h4>
-         * <p> Muttion is pursuing diversity. Mutation is useful for avoiding the following problem. </p>
+         * Muttion is pursuing diversity. Mutation is useful for avoiding the following problem.
          *
-         * <p> When initial set of genes(GeneArray) is far away from optimail, without mutation (only with selection and
-         * crossover), the genetic algorithm has a tend to wandering outside of the optimal. </p>
+         * When initial set of genes(GeneArray) is far away from optimail, without mutation (only with selection and
+         * crossover), the genetic algorithm has a tend to wandering outside of the optimal.
          *
-         * <p> Genes in the GeneArray will be swapped following percentage of the {@link mutation_rate}. </p>
+         * Genes in the GeneArray will be swapped following percentage of the {@link mutation_rate}.
          *
          * @param individual A container of genes to mutate
          *
@@ -2587,18 +2586,18 @@ declare namespace samchon.library {
         private mutate<T, GeneArray>(individual);
     }
     /**
-     * <p> A population in a generation. </p>
+     * A population in a generation.
      *
-     * <p> {@link GAPopulation} is a class representing population of candidate genes (sequence listing) having an array
+     * {@link GAPopulation} is a class representing population of candidate genes (sequence listing) having an array
      * of GeneArray as a member. {@link GAPopulation} also manages initial set of genes and handles fitting test direclty
-     * by the method {@link fitTest fitTest()}. </p>
+     * by the method {@link fitTest fitTest()}.
      *
-     * <p> The success of evolution of genetic algorithm is depend on the {@link GAPopulation}'s initial set and fitting
-     * test. (<i>GeneArray</i> and {@link compare}.) </p>
+     * The success of evolution of genetic algorithm is depend on the {@link GAPopulation}'s initial set and fitting
+     * test. (*GeneArray* and {@link compare}.)
      *
      * <h4> Warning </h4>
-     * <p> Be careful for the mistakes of direction or position of the {@link compare}. </p>
-     * <p> Most of logical errors failed to access optimal solution are occured from those mistakes. </p>
+     * Be careful for the mistakes of direction or position of the {@link compare}.
+     * Most of logical errors failed to access optimal solution are occured from those mistakes.
      *
      * @param <T> Type of gene elements.
      * @param <GeneArray> An array containing genes as elments; sequnce listing.
@@ -2611,10 +2610,10 @@ declare namespace samchon.library {
          */
         private children_;
         /**
-         * <p> A comparison function returns whether left gene is more optimal, greater. </p>
+         * A comparison function returns whether left gene is more optimal, greater.
          *
-         * <p> Default value of this {@link compare} is {@link std.greater}. It means to compare two array
-         * (GeneArray must be a type of {@link std.base.IArrayContainer}). Thus, you've to keep follwing rule. </p>
+         * Default value of this {@link compare} is {@link std.greater}. It means to compare two array
+         * (GeneArray must be a type of {@link std.base.IArrayContainer}). Thus, you've to keep follwing rule.
          *
          * <ul>
          *	<li> GeneArray is implemented from {@link std.base.IArrayContainer}. </li>
@@ -2625,50 +2624,50 @@ declare namespace samchon.library {
          *	<li> GeneArray has custom <code>public less(obj: T): boolean;</code> function. </li>
          * </ul>
          *
-         * <p> If you don't want to follow the rule or want a custom comparison function, you have to realize a
-         * comparison function. </p>
+         * If you don't want to follow the rule or want a custom comparison function, you have to realize a
+         * comparison function.
          */
         private compare_;
         /**
-         * <p> Private constructor with population. </p>
+         * Private constructor with population.
          *
-         * <p> Private constructor of GAPopulation does not create {@link children}. (candidate genes) but only assigns
-         * <i>null</i> repeatedly following the <i>population size</i>. </p>
+         * Private constructor of GAPopulation does not create {@link children}. (candidate genes) but only assigns
+         * *null* repeatedly following the *population size*.
          *
-         * <p> This private constructor is designed only for {@link GeneticAlgorithm}. Don't create {@link GAPopulation}
-         * with this constructor, by yourself. </p>
+         * This private constructor is designed only for {@link GeneticAlgorithm}. Don't create {@link GAPopulation}
+         * with this constructor, by yourself.
          *
          * @param size Size of the population.
          */
         constructor(size: number);
         /**
-         * <p> Construct from a {@link GeneArray} and <i>size of the population</i>. </p>
+         * Construct from a {@link GeneArray} and *size of the population*.
+         *
+         * This public constructor creates *GeneArray(s)* as population (size) having shuffled genes which are
+         * came from the initial set of genes (*geneArray*). It uses {@link std.greater} as default comparison function.
          *
-         * <p> This public constructor creates <i>GeneArray(s)</i> as population (size) having shuffled genes which are
-         * came from the initial set of genes (<i>geneArray</i>). It uses {@link std.greater} as default comparison function.
-         * </p>
          *
          * @param geneArray An initial sequence listing.
          * @param size The size of population to have as children.
          */
         constructor(geneArray: GeneArray, size: number);
         /**
-         * <p> Constructor from a GeneArray, size of the poluation and custom comparison function. </p>
+         * Constructor from a GeneArray, size of the poluation and custom comparison function.
+         *
+         * This public constructor creates *GeneArray(s)* as population (size) having shuffled genes which are
+         * came from the initial set of genes (*geneArray*). The *compare* is used for comparison function.
          *
-         * <p> This public constructor creates <i>GeneArray(s)</i> as population (size) having shuffled genes which are
-         * came from the initial set of genes (<i>geneArray</i>). The <i>compare</i> is used for comparison function.
-         * </p>
          *
          * @param geneArray An initial sequence listing.
          * @param size The size of population to have as children.
          * @param compare A comparison function returns whether left gene is more optimal.
          */
         constructor(geneArray: GeneArray, size: number, compare: (left: GeneArray, right: GeneArray) => boolean);
-        _Get_children(): std.Vector<GeneArray>;
+        children(): std.Vector<GeneArray>;
         /**
-         * Test fitness of each <i>GeneArray</i> in the {@link population}.
+         * Test fitness of each *GeneArray* in the {@link population}.
          *
-         * @return The best <i>GeneArray</i> in the {@link population}.
+         * @return The best *GeneArray* in the {@link population}.
          */
         fitTest(): GeneArray;
         /**
@@ -2679,32 +2678,30 @@ declare namespace samchon.library {
 }
 declare namespace samchon.library {
     /**
-     * <p> A utility class supporting static methods of string. </p>
+     * A utility class supporting static methods of string.
      *
-     * <p> The {@link StringUtil} utility class is an all-static class with methods for working with string objects within
-     * Samchon Framework. You do not create instances of {@link StringUtil}; instead you call methods such as the
-     * <code>StringUtil.substitute()</code> method. </p>
+     * The {@link StringUtil} utility class is an all-static class with methods for working with string objects.
+     * You do not create instances of {@link StringUtil}; instead you call methods such as the
+     * ```StringUtil.substitute()``` method.
      *
      * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/mx/utils/StringUtil.html
      * @author Jeongho Nam <http://samchon.org>
      */
     class StringUtil {
         /**
-         * <p> Generate a substring. </p>
+         * Generate a substring.
          *
-         * <p> Extracts a substring consisting of the characters from specified start to end.
-         * It's same with str.substring( ? = (str.find(start) + start.size()), str.find(end, ?) ) </p>
+         * Extracts a substring consisting of the characters from specified start to end.
+         * It's same with str.substring( ? = (str.find(start) + start.size()), str.find(end, ?) )
          *
-         * <code>
-         let str = between("ABCD[EFGH]IJK", "[", "]");
-         console.log(str); // PRINTS "EFGH"
-         * </code>
+         * ```typescript
+         * let str: string = StringUtil.between("ABCD(EFGH)IJK", "(", ")");
+         * console.log(str); // PRINTS "EFGH"
+         * ```
          *
-         * <ul>
-         *	<li> If start is not specified, extracts from begin of the string to end. </li>
-         *	<li> If end is not specified, extracts from start to end of the string. </li>
-         *	<li> If start and end are all omitted, returns str, itself. </li>
-         * </ul>
+         * - If start is not specified, extracts from begin of the string to end. </li>
+         * - If end is not specified, extracts from start to end of the string. </li>
+         * - If start and end are all omitted, returns str, itself. </li>
          *
          * @param str Target string to be applied between.
          * @param start A string for separating substring at the front.
@@ -2714,15 +2711,15 @@ declare namespace samchon.library {
          */
         static between(str: string, start?: string, end?: string): string;
         /**
-         * <p> Fetch substrings. </p>
+         * Fetch substrings.
          *
-         * <p> Splits a string into an array of substrings dividing by specified delimeters of start and end.
-         * It's the array of substrings adjusted the between. </p>
+         * Splits a string into an array of substrings dividing by specified delimeters of start and end.
+         * It's the array of substrings adjusted the between.
          *
          * <ul>
          *	<li> If startStr is omitted, it's same with the split by endStr not having last item. </li>
          *	<li> If endStr is omitted, it's same with the split by startStr not having first item. </li>
-         *	<li> If startStr and endStar are all omitted, returns <i>str</i>. </li>
+         *	<li> If startStr and endStar are all omitted, returns *str*. </li>
          * </ul>
          *
          * @param str Target string to split by between.
@@ -2770,7 +2767,7 @@ declare namespace samchon.library {
          * @param format The string to make substitutions in. This string can contain special tokens of the form
          *				 <code>{n}</code>, where <code>n</code> is a zero based index, that will be replaced with the
          *				 additional parameters found at that index if specified.
-         * @param args Additional parameters that can be substituted in the <i>format</i> parameter at each
+         * @param args Additional parameters that can be substituted in the *format* parameter at each
          *			   <code>{n}</code> location, where <code>n</code> is an integer (zero based) index value into
          *			   the array of values specified.
          *
@@ -2803,9 +2800,9 @@ declare namespace samchon.library {
          */
         static removeHTMLSpaces(str: string): string;
         /**
-         * <p> Repeat a string. </p>
+         * Repeat a string.
          *
-         * <p> Returns a string consisting of a specified string concatenated with itself a specified number of times. </p>
+         * Returns a string consisting of a specified string concatenated with itself a specified number of times.
          *
          * @param str The string to be repeated.
          * @param n The repeat count.
@@ -2814,9 +2811,9 @@ declare namespace samchon.library {
          */
         static repeat(str: string, n: number): string;
         /**
-         * <p> Number to formatted string with &quot;,&quot; sign. </p>
+         * Number to formatted string with &quot;,&quot; sign.
          *
-         * <p> Returns a string converted from the number rounded off from specified precision with &quot;,&quot; symbols. </p>
+         * Returns a string converted from the number rounded off from specified precision with &quot;,&quot; symbols.
          *
          * @param val A number wants to convert to string.
          * @param precision Target precision of round off.
@@ -2829,14 +2826,12 @@ declare namespace samchon.library {
 }
 declare namespace samchon.library {
     /**
-     * <p> URLVariables class is for representing variables of HTTP. </p>
+     * URLVariables class is for representing variables of HTTP.
      *
-     * <p> URLVariables class allows you to transfer variables between an application and server.
-     * When transfering, URLVariables will be converted to a URI string. </p>
+     * {@link URLVariables} class allows you to transfer variables between an application and server.
      *
-     * <ul>
-     *	<li> URI: Uniform Resource Identifier </li>
-     * </ul>
+     * When transfering, {@link URLVariables} will be converted to a *URI* string.
+     * - URI: Uniform Resource Identifier
      *
      * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/URLVariables.html
      * @author Migrated by Jeongho Nam <http://samchon.org>
@@ -2847,9 +2842,9 @@ declare namespace samchon.library {
          */
         constructor();
         /**
-         * <p> Construct from a URL-encoded string. </p>
+         * Construct from a URL-encoded string.
          *
-         * <p> The {@link decode decode()} method is automatically called to convert the string to properties of the {@link URLVariables} object. </p>
+         * The {@link decode decode()} method is automatically called to convert the string to properties of the {@link URLVariables} object.
          *
          * @param str A URL-encoded string containing name/value pairs.
          */
@@ -2866,48 +2861,371 @@ declare namespace samchon.library {
         toString(): string;
     }
 }
+declare namespace samchon.library {
+    /**
+     * A tree-structured XML object.
+     *
+     * The {@link XML| class contains methods and properties for working with XML objects. The {@link XML} class (along
+     * with the {@link XMLList}) implements the powerful XML-handling standards defined in ECMAScript for XML (E4X)
+     * specification (ECMA-357 edition 2).
+     *
+     * An XML object, it is composed with three members; {@link getTag tag}, {@link getProperty properties} and
+     * {@link getValue value}. As you know, XML is a tree structured data expression method. The tree-stucture;
+     * {@link XML} class realizes it by extending ```std.HashMap<string, XMLList>```. Child {@link XML} objects are
+     * contained in the matched {@link XMLList} object being grouped by their {@link getTag tag name}. The
+     * {@link XMLList} objects, they're stored in the {@link std.HashMap} ({@link XML} itself) with its **key**; common
+     * {@link getTag tag name} of children {@link XML} objects.
+     *
+     * ```typescript
+     * class XML extends std.HashMap<string, XMLList>
+     * {
+     *	private tag_: string;
+     *	private properties_: std.HashMap<string, string>;
+     *	private value_: string;
+     * }
+     * ```
+     *
+     * ```xml
+     * <?xml version="1.0" ?>
+     * <TAG property_name={property_value}>
+     *	<!--
+     *		The cchild XML objects with "CHILD_TAG", They're contained in an XMLList object.
+     *		The XMLList object, it is stored in std.HashMap (XML class itself) with its key "CHILD_TAG"
+     *	-->
+     *	<CHILD_TAG property_name={property_value}>{value}</CHILD_TAG>
+     *  <CHILD_TAG property_name={property_value}>{value}</CHILD_TAG>
+     *	<CHILD_TAG property_name={property_value}>{value}</CHILD_TAG>
+     *
+     *	<!--
+     *		The child XML object named "ANOTHER_TAG", it also belonged to an XMLList ojbect.
+     *		And the XMLList is also being contained in the std.HashMap with its key "ANOTHER_TAG"
+     *	-->
+     *	<ANOTHER_TAG />
+     * </TAG>
+     * ```
+     *
+     * Use the {@link toString toString()} method to return a string representation of the {@link XML} object regardless
+     * of whether the {@link XML} object has simple content or complex content.
+     *
+     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/XML.html
+     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Library-XML
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class XML extends std.HashMap<string, XMLList> {
+        /**
+         * @hidden
+         */
+        private tag_;
+        /**
+         * @hidden
+         */
+        private value_;
+        /**
+         * @hidden
+         */
+        private property_map_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from string.
+         *
+         * Creates {@link XML} object by parsing a string who represents xml structure.
+         *
+         * @param str A string represents XML structure.
+         */
+        constructor(str: string);
+        /**
+         * @hidden
+         */
+        private parse(str);
+        /**
+         * @hidden
+         */
+        private parse_tag(str);
+        /**
+         * @hidden
+         */
+        private parse_properties(str);
+        /**
+         * @hidden
+         */
+        private parse_value(str);
+        /**
+         * @hidden
+         */
+        private parse_children(str);
+        /**
+         * Get tag.
+         *
+         * ```xml
+         * <TAG property_key={property_value}>{value}</TAG>
+         * ```
+         *
+         * @return tag.
+         */
+        getTag(): string;
+        /**
+         * Get value.
+         *
+         * ```xml
+         * <tag property_key={property_value}>{VALUE}</tag>
+         * ```
+         *
+         * @return value.
+         */
+        getValue(): string;
+        /**
+         * Test whether a property exists.
+         *
+         * ```xml
+         * <tag PROPERTY_KEY={property_value}>{value}</tag>
+         * ```
+         *
+         * @return Whether a property has the *key* exists or not.
+         */
+        hasProperty(key: string): boolean;
+        /**
+         * Get property.
+         *
+         * Get property by its *key*, property name. If the matched *key* does not exist, then exception
+         * {@link std.OutOfRange} is thrown. Thus, it would better to test whether the *key* exits or not by calling the
+         * {@link hasProperty hasProperty()} method before calling this {@link getProperty getProperty()}.
+         *
+         * This method can be substituted by {@link getPropertyMap getPropertyMap()} such below:
+         * - ```getPropertyMap().get(key, value);```
+         * - ```getPropertyMap().find(key).second;```
+         *
+         * ```xml
+         * <tag PROPERTY_KEY={PROPERTY_VALUE}>{value}</tag>
+         * ```
+         *
+         * @return Value of the matched property.
+         */
+        getProperty(key: string): string;
+        /**
+         * Get property map.
+         *
+         * ```xml
+         * <tag PROPERTY_KEY1={PROPERTY_VALUE1}
+         *		PROPERTY_KEY2={PROPERTY_VALUE2}
+         *		PROPERTY_KEY3={PROPERTY_VALUE3}>{value}</tag>
+         * ```
+         *
+         * @return {@link HashMap} containing properties' keys and values.
+         */
+        getPropertyMap(): std.HashMap<string, string>;
+        /**
+         * Set tag.
+         *
+         * Set tag name, identifier of this {@link XML} object.
+         *
+         * If this {@link XML} object is belonged to, a child of, an {@link XMLList} and its related {@link XML} objects,
+         * then calling this {@link setTag setTag()} method direclty is not recommended. Erase this {@link XML} object
+         * from parent objects and insert this object again.
+         *
+         * ```xml
+         * <TAG property_key={property_value}>{value}</TAG>
+         * ```
+         *
+         * @param val To be new {@link getTag tag}.
+         */
+        setTag(val: string): void;
+        /**
+         * Set value.
+         *
+         * ```xml
+         * <tag property_key={property_value}>{VALUE}</tag>
+         * ```
+         *
+         * @param val To be new {@link getValue value}.
+         */
+        setValue(val: string): void;
+        /**
+         * Set property.
+         *
+         * Set a property *value* with its *key*. If the *key* already exists, then the *value* will be overwritten to
+         * the property. Otherwise the *key* is not exist yet, then insert the *key* and *value* {@link Pair pair} to
+         * {@link getPropertyMao property map}.
+         *
+         * This method can be substituted by {@link getPropertyMap getPropertyMap()} such below:
+         * - ```getPropertyMap().set(key, value);```
+         * - ```getPropertyMap().emplace(key, value);```
+         * - ```getPropertyMap().insert([key, value]);```
+         * - ```getPropertyMap().insert(std.make_pair(key, value));```
+         *
+         * ```xml
+         * <tag PROPERTY_KEY={PROPERTY_VALUE}>{value}</tag>
+         * ```
+         *
+         * @param key Key, identifier of property to be newly inserted.
+         * @param value Value of new property to be newly inserted.
+         */
+        setProperty(key: string, value: string): void;
+        /**
+         * Erase property.
+         *
+         * Erases a property by its *key*, property name. If the matched *key* does not exist, then exception
+         * {@link std.OutOfRange} is thrown. Thus, it would better to test whether the *key* exits or not by calling the
+         * {@link hasProperty hasProperty()} method before calling this {@link eraseProperty eraseProperty()}.
+         *
+         * This method can be substituted by ``getPropertyMap().erase(key)````.
+         *
+         * ```xml
+         * <tag PROPERTY_KEY={property_value}>{value}</tag>
+         * ```
+         *
+         * @param key Key of the property to erase
+         * @throw {@link std.OutOfRange}
+         */
+        eraseProperty(key: string): void;
+        /**
+         * @hidden
+         */
+        push(...args: std.Pair<string, XMLList>[]): number;
+        /**
+         * @hidden
+         */
+        push(...args: [string, XMLList][]): number;
+        push(...xmls: XML[]): number;
+        push(...xmlLists: XMLList[]): number;
+        /**
+         * Add all properties from other {@link XML} object.
+         *
+         * All the properties in the *obj* are copied to this {@link XML} object. If this {@link XML} object has same
+         * property key in the *obj*, then value of the property will be replaced to *obj*'s own. If you don't want to
+         * overwrite properties with same key, then use {@link getPropertyMap getPropertyMap()} method.
+         *
+         * ```typescript
+         * let x: library.XML;
+         * let y: library.XML;
+         *
+         * x.addAllProperties(y); // duplicated key exists, then overwrites
+         * x.getPropertyMap().insert(y.getPropertyMap().begin(), y.getPropertyMap().end());
+         *	// ducpliated key, then ignores. only non-duplicateds are copied.
+         * ```
+         *
+         * ```xml
+         * <tag PROPERTY_KEY1={property_value1}
+         *		PROPERTY_KEY2={property_value2}
+         *		PROPERTY_KEY3={property_value3}>{value}</tag>
+         * ```
+         *
+         * @param obj Target {@link XML} object to copy properties.
+         */
+        addAllProperties(obj: XML): void;
+        /**
+         * Clear properties.
+         *
+         * Remove all properties. It's same with calling ```getPropertyMap().clear()```.
+         *
+         * ```xml
+         * <tag PROPERTY_KEY1={property_value1}
+         *		PROPERTY_KEY2={property_value2}
+         *		PROPERTY_KEY3={property_value3}>{value}</tag>
+         * ```
+         */
+        clearProperties(): void;
+        /**
+         * @hidden
+         */
+        private compute_min_index(...args);
+        /**
+         * @hidden
+         */
+        private decode_value(str);
+        /**
+         * @hidden
+         */
+        private encode_value(str);
+        /**
+         * @hidden
+         */
+        private decode_property(str);
+        /**
+         * @hidden
+         */
+        private encode_property(str);
+        /**
+         * {@link XML} object to xml string.
+         *
+         * Returns a string representation of the {@link XML} object.
+         *
+         * @param tab Number of tabs to spacing.
+         * @return The string representation of the {@link XML} object.
+         */
+        toString(tab?: number): string;
+    }
+}
+declare namespace samchon.library {
+    /**
+     * List of {@link XML} objects with same tag.
+     *
+     * @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/XMLList.html
+     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Library-XML
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class XMLList extends std.Deque<XML> {
+        /**
+         * Get tag.
+         */
+        getTag(): string;
+        /**
+         * {@link XMLList XML objects} to string.
+         *
+         * Returns a string representation of the {@link XMLList XML objects}.
+         *
+         * @param tab Number of tabs to spacing.
+         * @return The string representation of the {@link XMLList XML objects}.
+         */
+        toString(level?: number): string;
+    }
+}
 declare namespace samchon.protocol {
     /**
-     * <p> An interface of entity. </p>
+     * An interface of entity.
      *
-     * <p> Entity is a class for standardization of expression method using on network I/O by XML. If
+     * Entity is a class for standardization of expression method using on network I/O by XML. If
      * Invoke is a standard message protocol of Samchon Framework which must be kept, Entity is a
      * recommended semi-protocol of message for expressing a data class. Following the semi-protocol
-     * Entity is not imposed but encouraged. </p>
+     * Entity is not imposed but encouraged.
      *
-     * <p> As we could get advantages from standardization of message for network I/O with Invoke,
+     * As we could get advantages from standardization of message for network I/O with Invoke,
      * we can get additional advantage from standardizing expression method of data class with Entity.
      * We do not need to know a part of network communication. Thus, with the Entity, we can only
      * concentrate on entity's own logics and relationships between another entities. Entity does not
-     * need to how network communications are being done. </p>
+     * need to how network communications are being done.
      *
-     * <p> I say repeatedly. Expression method of Entity is recommended, but not imposed. It's a semi
+     * I say repeatedly. Expression method of Entity is recommended, but not imposed. It's a semi
      * protocol for network I/O but not a essential protocol must be kept. The expression method of
-     * Entity, using on network I/O, is expressed by XML string. </p>
+     * Entity, using on network I/O, is expressed by XML string.
      *
-     * <p> If your own network system has a critical performance issue on communication data class,
+     * If your own network system has a critical performance issue on communication data class,
      * it would be better to using binary communication (with ByteArray).
-     * Don't worry about the problem! Invoke also provides methods for binary data (ByteArray). </p>
+     * Don't worry about the problem! Invoke also provides methods for binary data (ByteArray).
+     *
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
      *
      * @author Jeongho Nam <http://samchon.org>
      */
     interface IEntity {
         /**
-         * <p> Construct data of the Entity from a XML object. </p>
+         * Construct data of the Entity from a XML object.
          *
-         * <p> Overrides the construct() method and fetch data of member variables from the XML. </p>
+         * Overrides the construct() method and fetch data of member variables from the XML.
          *
-         * <p> By recommended guidance, data representing member variables are contained in properties
-         * of the put XML object. </p>
+         * By recommended guidance, data representing member variables are contained in properties
+         * of the put XML object.
          *
          * @param xml An xml used to contruct data of entity.
          */
         construct(xml: library.XML): void;
         /**
-         * <p> Get a key that can identify the Entity uniquely. </p>
+         * Get a key that can identify the Entity uniquely.
          *
-         * <p> If identifier of the Entity is not atomic value, returns a paired or tuple object
-         * that can represents the composite identifier. </p>
+         * If identifier of the Entity is not atomic value, returns a paired or tuple object
+         * that can represents the composite identifier.
          *
          * <code>
          * class Point extends Entity
@@ -2924,22 +3242,22 @@ declare namespace samchon.protocol {
          */
         key(): any;
         /**
-         * <p> A tag name when represented by XML. </p>
+         * A tag name when represented by XML.
          *
          * <code> <TAG {...properties} /> </code>
          */
         TAG(): string;
         /**
-         * <p> Get a XML object represents the Entity. </p>
+         * Get a XML object represents the Entity.
          *
-         * <p> A member variable (not object, but atomic value like number, string or date) is categorized
+         * A member variable (not object, but atomic value like number, string or date) is categorized
          * as a property within the framework of entity side. Thus, when overriding a toXML() method and
          * archiving member variables to an XML object to return, puts each variable to be a property
-         * belongs to only a XML object. </p>
+         * belongs to only a XML object.
          *
-         * <p> Don't archive the member variable of atomic value to XML::value causing enormouse creation
+         * Don't archive the member variable of atomic value to XML::value causing enormouse creation
          * of XML objects to number of member variables. An Entity must be represented by only a XML
-         * instance (tag). </p>
+         * instance (tag).
          *
          * <h4> Standard Usage. </h4>
          * <code>
@@ -2975,26 +3293,28 @@ declare namespace samchon.protocol {
         function toXML(entity: IEntity, ...prohibited_names: string[]): library.XML;
     }
     /**
-     * <p> An entity, a standard data class. </p>
+     * An entity, a standard data class.
      *
-     * <p> Entity is a class for standardization of expression method using on network I/O by XML. If
+     * Entity is a class for standardization of expression method using on network I/O by XML. If
      * Invoke is a standard message protocol of Samchon Framework which must be kept, Entity is a
      * recommended semi-protocol of message for expressing a data class. Following the semi-protocol
-     * Entity is not imposed but encouraged. </p>
+     * Entity is not imposed but encouraged.
      *
-     * <p> As we could get advantages from standardization of message for network I/O with Invoke,
+     * As we could get advantages from standardization of message for network I/O with Invoke,
      * we can get additional advantage from standardizing expression method of data class with Entity.
      * We do not need to know a part of network communication. Thus, with the Entity, we can only
      * concentrate on entity's own logics and relationships between another entities. Entity does not
-     * need to how network communications are being done. </p>
+     * need to how network communications are being done.
      *
-     * <p> I say repeatedly. Expression method of Entity is recommended, but not imposed. It's a semi
+     * I say repeatedly. Expression method of Entity is recommended, but not imposed. It's a semi
      * protocol for network I/O but not a essential protocol must be kept. The expression method of
-     * Entity, using on network I/O, is expressed by XML string. </p>
+     * Entity, using on network I/O, is expressed by XML string.
      *
-     * <p> If your own network system has a critical performance issue on communication data class,
+     * If your own network system has a critical performance issue on communication data class,
      * it would be better to using binary communication (with ByteArray).
-     * Don't worry about the problem! Invoke also provides methods for binary data (ByteArray). </p>
+     * Don't worry about the problem! Invoke also provides methods for binary data (ByteArray).
+     *
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
      *
      * @author Jeongho Nam <http://samchon.org>
      */
@@ -3020,130 +3340,742 @@ declare namespace samchon.protocol {
 }
 declare namespace samchon.protocol {
     /**
-     * <p> An interface taking full charge of network communication. </p>
-     *
-     * <p> {@link ICommunicator} is an interface for communicator classes who take full charge of network communication
-     * with external system, without reference to whether the external system is a server or a client. </p>
-     *
-     * <p> Whenever a replied message comes from the external system, the message will be converted to an
-     * {@link Invoke} class and will be shifted to the {@link WebCommunicator.listener listener}'s
-     * {@link IProtocol.replyData replyData()} method. </p>
-     *
-     * <code>
-    interface ICommmunicator
-    {
-        private socket: SomeSocketClass;
-
-        // LISTENER LISTENS INVOKE MESSAGE BY IT'S IProtocol.replyData() METHOD
-        protected listener: IProtocol;
-
-        // YOU CAN DETECT DISCONNECTION BY ENROLLING FUNCTION POINTER TO HERE.
-        public onClose: Function;
-
-        public sendData(invoke: Invoke): void
-        {
-            this.socket.write(invoke);
-        }
-        public replyData(invoke: Invoke): void
-        {
-            // WHENEVER COMMUNICATOR GETS MESSAGE, THEN SHIFT IT TO LISTENER'S replyData() METHOD.
-            this.listener.replyData(invoke);
-        }
+     * @inheritdoc
+     */
+    interface IEntityCollection<T extends IEntity> extends IEntityGroup<T>, collections.ICollection<T> {
     }
-     * </code>
+}
+declare namespace samchon.protocol {
+    /**
+     * @inheritdoc
+     */
+    abstract class EntityArrayCollection<T extends IEntity> extends collections.ArrayCollection<T> implements IEntityCollection<T> {
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * @inheritdoc
+         */
+        abstract createChild(xml: library.XML): T;
+        /**
+         * @inheritdoc
+         */
+        key(): any;
+        /**
+         * @inheritdoc
+         */
+        has(key: any): boolean;
+        /**
+         * @inheritdoc
+         */
+        count(key: any): number;
+        /**
+         * @inheritdoc
+         */
+        get(key: any): T;
+        /**
+         * @inheritdoc
+         */
+        abstract TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        abstract CHILD_TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * @inheritdoc
+     */
+    abstract class EntityListCollection<T extends IEntity> extends collections.ListCollection<T> implements IEntityCollection<T> {
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * @inheritdoc
+         */
+        abstract createChild(xml: library.XML): T;
+        /**
+         * @inheritdoc
+         */
+        key(): any;
+        /**
+         * @inheritdoc
+         */
+        has(key: any): boolean;
+        /**
+         * @inheritdoc
+         */
+        count(key: any): number;
+        /**
+         * @inheritdoc
+         */
+        get(key: any): T;
+        /**
+         * @inheritdoc
+         */
+        abstract TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        abstract CHILD_TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * @inheritdoc
+     */
+    abstract class EntityDequeCollection<T extends IEntity> extends collections.DequeCollection<T> implements IEntityCollection<T> {
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * @inheritdoc
+         */
+        abstract createChild(xml: library.XML): T;
+        /**
+         * @inheritdoc
+         */
+        key(): any;
+        /**
+         * @inheritdoc
+         */
+        has(key: any): boolean;
+        /**
+         * @inheritdoc
+         */
+        count(key: any): number;
+        /**
+         * @inheritdoc
+         */
+        get(key: any): T;
+        /**
+         * @inheritdoc
+         */
+        abstract TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        abstract CHILD_TAG(): string;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+/**
+ * A template for External Systems Manager.
+ *
+ * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+ * @author Jeongho Nam <http://samchon.org>
+ */
+declare namespace samchon.templates.external {
+    /**
+     * An array and manager of {@link ExternalSystem external system drivers}.
      *
-     * <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     * The {@link ExternalSystemArray} is an abstract class containing and managing external system drivers,
+     * {@link ExternalSystem} objects. Within framewokr of network, {@link ExternalSystemArray} represents your system
+     * and children {@link ExternalSystem} objects represent remote, external systems connected with your system.
+     * With this {@link ExternalSystemArray}, you can manage multiple external systems as a group.
+     *
+     * You can specify this {@link ExternalSystemArray} class to be *a server accepting external clients* or
+     * *a client connecting to external servers*. Even both of them is also possible.
+     *
+     * - {@link ExternalClientArray}: A server accepting {@link ExternalSystem external clients}.
+     * - {@link ExternalServerArray}: A client connecting to {@link ExternalServer external servers}.
+     * - {@link ExternalServerClientArray}: Both of them. Accepts {@link ExternalSystem external clients} and connects to
+     *   {@link ExternalServer external servers} at the same time.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Proxy Pattern
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ExternalSystemArray extends protocol.EntityDequeCollection<ExternalSystem> implements protocol.IProtocol {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @hidden
+         */
+        private handle_system_erase(event);
+        /**
+         * Test whether the role exists.
+         *
+         * @param name Name, identifier of target {@link ExternalSystemRole role}.
+         *
+         * @return Whether the role has or not.
+         */
+        hasRole(name: string): boolean;
+        /**
+         * Get a role.
+         *
+         * @param name Name, identifier of target {@link ExternalSystemRole role}.
+         *
+         * @return The specified role.
+         */
+        getRole(name: string): ExternalSystemRole;
+        /**
+         * Send an {@link Invoke} message.
+         *
+         * @param invoke An {@link Invoke} message to send.
+         */
+        sendData(invoke: protocol.Invoke): void;
+        /**
+         * Handle an {@Invoke} message have received.
+         *
+         * @param invoke An {@link Invoke} message have received.
+         */
+        replyData(invoke: protocol.Invoke): void;
+        /**
+         * Tag name of the {@link ExternalSytemArray} in {@link XML}.
+         *
+         * @return *systemArray*.
+         */
+        TAG(): string;
+        /**
+         * Tag name of {@link ExternalSystem children elements} belonged to the {@link ExternalSytemArray} in {@link XML}.
+         *
+         * @return *system*.
+         */
+        CHILD_TAG(): string;
+    }
+}
+/**
+ * A template for Parallel Processing System.
+ *
+ * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
+ * @author Jeongho Nam <http://samchon.org>
+ */
+declare namespace samchon.templates.parallel {
+    /**
+     * Master of Parallel Processing System.
+     *
+     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
+     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
+     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to **slave** systems and the
+     * children {@link ParallelSystem} objects represent the remote **slave** systems, who is being requested the
+     * *parallel processes*.
+     *
+     * You can specify this {@link ParallelSystemArray} class to be *a server accepting parallel clients* or
+     * *a client connecting to parallel servers*. Even both of them is possible. Extends one of them below and overrides
+     * abstract factory method(s) creating the child {@link ParallelSystem} object.
+     *
+     * - {@link ParallelClientArray}: A server accepting {@link ParallelSystem parallel clients}.
+     * - {@link ParallelServerArray}: A client connecting to {@link ParallelServer parallel servers}.
+     * - {@link ParallelServerClientArray}: Both of them. Accepts {@link ParallelSystem parallel clients} and connects to
+     *   {@link ParallelServer parallel servers} at the same time.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
+     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Proxy Pattern
+     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ParallelSystemArray extends external.ExternalSystemArray {
+        /**
+         * @hidden
+         */
+        private history_sequence_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        at(index: number): ParallelSystem;
+        /**
+         * Send an {@link Invoke} message with segment size.
+         *
+         * Sends an {@link Invoke} message requesting a **parallel process** with its *segment size*. The {@link Invoke}
+         * message will be delivered to children {@link ParallelSystem} objects with the *piece size*, which is divided
+         * from the *segment size*, basis on their {@link ParallelSystem.getPerformance performance indices}.
+         *
+         * - If segment size is 100,
+         * - The segment will be allocated such below:
+         *
+         * Name    | Performance index | Number of pieces to be allocated | Formula
+         * --------|-------------------|----------------------------------|--------------
+         * Snail   |                 1 |                               10 | 100 / 10 * 1
+         * Cheetah |                 4 |                               40 | 100 / 10 * 4
+         * Rabbit  |                 3 |                               30 | 100 / 10 * 3
+         * Turtle  |                 2 |                               20 | 100 / 10 * 2
+         *
+         * When the **parallel process** has completed, then this {@link ParallelSystemArraY} will estimate
+         * {@link ParallelSystem.getPerformance performance indices} of {@link ParallelSystem} objects basis on their
+         * execution time.
+         *
+         * @param invoke An {@link Invoke} message requesting parallel process.
+         * @param size Number of pieces to segment.
+         *
+         * @see {@link sendPieceData}, {@link ParallelSystem.getPerformacen}
+         */
+        sendSegmentData(invoke: protocol.Invoke, size: number): void;
+        /**
+         * Send an {@link Invoke} message with range of pieces.
+         *
+         * Sends an {@link Invoke} message requesting a **parallel process** with its *range of pieces [first, last)*.
+         * The {@link Invoke} will be delivered to children {@link ParallelSystem} objects with the newly computed
+         * *range of sub-pieces*, which is divided from the *range of pieces (first to last)*, basis on their
+         * {@link ParallelSystem.getPerformance performance indices}.
+         *
+         * - If indices of pieces are 0 to 50,
+         * - The sub-pieces will be allocated such below:
+         *
+         * Name    | Performance index | Range of sub-pieces to be allocated | Formula
+         * --------|-------------------|-------------------------------------|------------------------
+         * Snail   |                 1 |                            ( 0,  5] | (50 - 0) / 10 * 1
+         * Cheetah |                 4 |                            ( 5, 25] | (50 - 0) / 10 * 4 + 5
+         * Rabbit  |                 3 |                            (25, 40] | (50 - 0) / 10 * 3 + 25
+         * Turtle  |                 2 |                            (40, 50] | (50 - 0) / 10 * 2 + 40
+         *
+         * When the **parallel process** has completed, then this {@link ParallelSystemArraY} will estimate
+         * {@link ParallelSystem.getPerformance performance indices} of {@link ParallelSystem} objects basis on their
+         * execution time.
+         *
+         * @param invoke An {@link Invoke} message requesting parallel process.
+         * @param first Initial piece's index in a section.
+         * @param last Final piece's index in a section. The range used is [*first*, *last*), which contains
+         *			   all the pieces' indices between *first* and *last*, including the piece pointed by index
+         *			   *first*, but not the piece pointed by the index *last*.
+         *
+         * @see {@link sendSegmentData}, {@link ParallelSystem.getPerformacen}
+         */
+        sendPieceData(invoke: protocol.Invoke, first: number, last: number): void;
+        /**
+         * @hidden
+         */
+        protected _Complete_history(history: protocol.InvokeHistory): boolean;
+        /**
+         * @hidden
+         */
+        protected _Normalize_performance(): void;
+    }
+}
+/**
+ * A template for Distributed Processing System.
+ *
+ * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+ * @author Jeongho Nam <http://samchon.org>
+ */
+declare namespace samchon.templates.distributed {
+    /**
+     * Master of Distributed Processing System.
+     *
+     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
+     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
+     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
+     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
+     * requested the *distributed processes*.
+     *
+     * You can specify this {@link DistributedSystemArray} class to be *a server accepting distributed clients* or
+     * *a client connecting to distributed servers*. Even both of them is possible. Extends one of them below and overrides
+     * abstract factory method(s) creating the child {@link DistributedSystem} object.
+     *
+     * - {@link DistributedClientArray}: A server accepting {@link DistributedSystem distributed clients}.
+     * - {@link DistributedServerArray}: A client connecting to {@link DistributedServer distributed servers}.
+     * - {@link DistributedServerClientArray}: Both of them. Accepts {@link DistributedSystem distributed clients} and
+     *   connects to {@link DistributedServer distributed servers} at the same time.
+     *
+     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
+     * **distributed process** through the {@link DistributedProcess} object. You can access the
+     * {@link DistributedProcess} object(s) with those methods:
+     *
+     * - {@link hasRole}
+     * - {@link getRole}
+     * - {@link insertRole}
+     * - {@link eraseRole}
+     * - {@link getRoleMap}
+     *
+     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
+     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
+     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
+     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
+     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Parallel Process
+     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
+     * a **parallel process**, too.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
+     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * #### Proxy Pattern
+     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class DistributedSystemArray extends parallel.ParallelSystemArray {
+        /**
+         * @hidden
+         */
+        private process_map_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * Factory method creating a child {@link DistributedProcess process} object.
+         *
+         * @param xml {@link XML} represents the {@link DistributedProcess child} object.
+         * @return A new {@link DistributedProcess} object.
+         */
+        protected abstract createProcess(xml: library.XML): DistributedProcess;
+        /**
+         * @inheritdoc
+         */
+        at(index: number): DistributedSystem;
+        /**
+         * Get process map.
+         *
+         * Gets an {@link HashMap} containing {@link DistributedProcess} objects with their *key*.
+         *
+         * @return An {@link HasmMap> containing pairs of string and {@link DistributedProcess} object.
+         */
+        getProcessMap(): std.HashMap<string, DistributedProcess>;
+        /**
+         * Test whether the process exists.
+         *
+         * @param name Name, identifier of target {@link DistributedProcess process}.
+         *
+         * @return Whether the process has or not.
+         */
+        hasProcess(name: string): boolean;
+        /**
+         * Get a process.
+         *
+         * @param name Name, identifier of target {@link DistributedProcess process}.
+         *
+         * @return The specified process.
+         */
+        getProcess(name: string): DistributedProcess;
+        /**
+         * Insert a process.
+         *
+         * @param process A process to be inserted.
+         * @return Success flag.
+         */
+        insertProcess(process: DistributedProcess): boolean;
+        /**
+         * Erase a process.
+         *
+         * @param name Name, identifier of target {@link DistributedProcess process}.
+         */
+        eraseProcess(name: string): boolean;
+        /**
+         * @hidden
+         */
+        protected _Complete_history(history: protocol.InvokeHistory): boolean;
+        /**
+         * @hidden
+         */
+        private estimate_role_performance(history);
+        /**
+         * @hidden
+         */
+        private estimate_system_performance(history);
+        /**
+         * @hidden
+         */
+        protected _Normalize_performance(): void;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * Mediator of Distributed Processing System.
+     *
+     * The {@link DistributedSystemArrayMediator} class be a master for its slave systems, and be a slave to its master
+     * system at the same time. This {@link DistributedSystemArrayMediator} be a master system, containing and managing
+     * {@link DistributedSystem} objects, which represent distributed slave systems, by extending
+     * {@link DistributedSystemArray} class. Also, be a slave system through {@link getMediator mediator} object, which is
+     * derived from the {@link SlavSystem} class.
+     *
+     * As a master, you can specify this {@link DistributedSystemArrayMediator} class to be <i>a master server accepting
+     * slave clients<i> or <i>a master client to connecting slave servers</i>. Even both of them is possible. Extends one
+     * of them below and overrides abstract factory method(s) creating the child {@link DistributedSystem} object.
+     *
+     * - {@link DistributedClientArrayMediator}: A server accepting {@link DistributedSystem distributed clients}.
+     * - {@link DistributedServerArrayMediator}: A client connecting to {@link DistributedServer distributed servers}.
+     * - {@link DistributedServerClientArrayMediator}: Both of them. Accepts {@link DistributedSystem distributed clients} and
+     *   connects to {@link DistributedServer distributed servers} at the same time.
+     *
+     * As a slave, you can specify this {@link DistributedSystemArrayMediator} to be <i>a client slave connecting to master
+     * server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
+     * Overrides the {@link createMediator createMediator()} method and return one of them:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * #### [Inherited] {@link DistributedSystemArray}
+     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
+     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
+     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
+     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
+     * requested the *distributed processes*.
+     *
+     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
+     * **distributed process** through the {@link DistributedProcess} object. You can access the
+     * {@link DistributedProcess} object(s) with those methods:
+     *
+     * - {@link hasRole}
+     * - {@link getRole}
+     * - {@link insertRole}
+     * - {@link eraseRole}
+     * - {@link getRoleMap}
+     *
+     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
+     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
+     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
+     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
+     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Parallel Process
+     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
+     * a **parallel process**, too.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
+     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * #### Proxy Pattern
+     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class DistributedSystemArrayMediator extends DistributedSystemArray {
+        /**
+         * @hidden
+         */
+        private mediator_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method creating a {@link MediatorSystem} object.
+         *
+         * The {@link createMediator createMediator()} is an abstract method creating the {@link MediatorSystem} object.
+         *
+         * You know what? this {@link DistributedSystemArrayMediator} class be a master for its slave systems, and be a
+         * slave to its master system at the same time. The {@link MediatorSystem} object makes it possible; be a slave
+         * system. This {@link createMediator} determines specific type of the {@link MediatorSystem}.
+         *
+         * Overrides the {@link createMediator createMediator()} method to create and return one of them following which
+         * protocol and which type of remote connection (server or client) will be used:
+         *
+         * - A client slave connecting to master server:
+         *   - {@link MediatorClient}
+         *   - {@link MediatorWebClient}
+         *   - {@link MediatorSharedWorkerClient}
+         * - A server slave accepting master client:
+         *   - {@link MediatorServer}
+         *   - {@link MediatorWebServer}
+         *   - {@link MediatorSharedWorkerServer}
+         *
+         * @return A newly created {@link MediatorSystem} object.
+         */
+        protected abstract createMediator(): parallel.MediatorSystem;
+        /**
+         * Start mediator.
+         *
+         * If the {@link getMediator mediator} is a type of server, then opens the server accepting master client.
+         * Otherwise, the {@link getMediator mediator} is a type of client, then connects the master server.
+         */
+        protected startMediator(): void;
+        /**
+         * Get {@link MediatorSystem} object.
+         *
+         * When you need to send an {@link Invoke} message to the master system of this
+         * {@link DistributedSystemArrayMediator}, then send to the {@link MediatorSystem} through this
+         * {@link getMediator}.
+         *
+         * ```typescript
+         * this.getMediator().sendData(...);
+         * ```
+         *
+         * @return The {@link MediatorSystem} object.
+         */
+        getMediator(): parallel.MediatorSystem;
+        /**
+         * @hidden
+         */
+        protected _Complete_history(history: parallel.PRInvokeHistory): boolean;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * An interface taking full charge of network communication.
+     *
+     * {@link ICommunicator} is an interface for communicator classes who take full charge of network communication with
+     * remote system, without reference to whether the remote system is a server or a client. Type of the
+     * {@link ICommunicator} is specified to {@link IServerConnector} and {@link IClientDriver} whether the remote system
+     * is a server (that I've to connect) or a client (a client connected to my server).
+     *
+     * Whenever a replied message comes from the remote system, the message will be converted to an {@link Invoke} class
+     * and the {@link Invoke} object will be shifted to the {@link IProtocol listener}'s
+     * {@link IProtocol.replyData IProtocol.replyData()} method.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
      *		  target="_blank">
      *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
      *		 style="max-width: 100%" />
-     * </a> </p>
+     * </a>
      *
-     *
-     * <h2> Basic Components </h2>
-     * <h4> What Basic Components are </h4>
-     * <p> <b>Basic Components</b> are the smallest unit of network communication in this <i>Samchon Framework</i>. With
-     * <b>Basic Components</b>, you can construct any type of network system, even how the network system is enormously
-     * scaled and complicated, by just combinating the <b>Basic Components</b>. </p>
-     *
-     * <p> All the system templates in this framework are also being implemented by utilization of the
-     * <b>Basic Compoonents</b>. </p>
-     *
-     * <ul>
-     *	<li> {@link service Service} </il>
-     *	<li> {@link external External System} </il>
-     *	<li> {@link parallel Parallel System} </il>
-     *	<li> {@link distributed Distributed System} </il>
-     * </ul>
-     *
-     * <p> Note that, whatever the network system what you've to construct is, just concentrate on role of each system
-     * and attach matched <b>Basic Components</b> to the role, within framework of the <b>Object-Oriented Design</b>.
-     * Then construction of the network system will be much easier. </p>
-     *
-     * <ul>
-     *	<li> A system is a server, then use {@link IServer} or {@link IServerBase}. </li>
-     *	<li> A server wants to handle a client has connected, then use {@link IClientDriver}. </li>
-     *	<li> A system is a client connecting to an external server, then use {@link IServerConnector}. </li>
-     *	<li> </li>
-     * </ul>
-     *
-     * <h4> Example - System Templates </h4>
-     * <p> Learning and understanding <i>Basic Components</i> of Samchon Framework, reading source codes and design of
-     * <b>System Templates</b>' modules will be very helpful. </p>
-     *
-     * <table>
-     *	<tr>
-     *		<th> Name </th>
-     *		<th> Source </th>
-     *		<th> API Documents </th>
-     *	</tr>
-     *	<tr>
-     *		<td> Cloud Service </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/service"
-     *				target="_blank"> protocol/service </a> </td>
-     *		<td> {@link protocol.service} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> External System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/external"
-     *				target="_blank"> protocol/external </a> </td>
-     *		<td> {@link protocol.external} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> Parallel System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/parallel"
-     *				target="_blank"> protocol/parallel </a> </td>
-     *		<td> {@link protocol.parallel} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> Distributed System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/distributed"
-     *				target="_blank"> protocol/distributed </a> </td>
-     *		<td> {@link protocol.distributed} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> Slave System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/slave"
-     *				target="_blank"> protocol/slave </a> </td>
-     *		<td> {@link protocol.slave} </td>
-     *	</tr>
-     * </table>
-     *
-     * <h4> Example - Projects </h4>
-     * <ul>
-     *	<li>
-     *		<a href="https://github.com/samchon/framework/wiki/Examples-Calculator" target="_blank"> Calculator </a>
-     *	</li>
-     *	<li>
-     *		<a href="https://github.com/samchon/framework/wiki/Examples-Chatting" target="_blank"> Chatting </a>
-     *	</li>
-     *	<li>
-     *		<a href="https://github.com/samchon/framework/wiki/Examples-Interaction" target="_blank"> Interaction </a>
-     *	</li>
-     * </ul>
-     *
-     * @see {@link IClientDriver}, {@link IServerConnector}
-     * @handbook <a href="https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#icommunicator"
-     *			 target="_blank"> Basic Components - ICommunicator </a>
+     * @see {@link IClientDriver}, {@link IServerConnector}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#icommunicator)
      * @author Jeongho Nam <http://samchon.org>
      */
     interface ICommunicator extends IProtocol {
@@ -3155,12 +4087,67 @@ declare namespace samchon.protocol {
          * Close connection.
          */
         close(): void;
+        /**
+         * Test connection.
+         *
+         * Test whether this {@link ICommunicator communicator} object is connected with the remote system. If the
+         * connection is alive, then returns ```true```. Otherwise, the connection is not alive or this
+         * {@link ICommunicator communicator has not connected with the remote system yet, then returns ```false```.
+         *
+         * @return true if connected, otherwise false.
+         */
         isConnected(): boolean;
+        /**
+         * Send message.
+         *
+         * Send {@link Invoke} message to remote system.
+         *
+         * @param invoke An {@link Invoke} message to send.
+         */
         sendData(invoke: protocol.Invoke): void;
+        /**
+         * Handle replied message.
+         *
+         * Handles replied {@link Invoke} message recived from remove system. The {@link Invoke} message will be shifted
+         * to the {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} by this method.
+         *
+         * @param invoke An {@link Invoke} message received from remote system.
+         */
         replyData(invoke: protocol.Invoke): void;
     }
 }
 declare namespace samchon.protocol {
+    /**
+     * An abstract, basic class for communicators.
+     *
+     * {@link CommunicatorBase} is an abstract class implemented from the {@link ICommunicator}. Mechanism of converting
+     * raw data to {@link Invoke} messag has realized in this abstract class. Type of this {@link CommunicatorBase} class
+     * is specified to as below following which protocol is used.
+     *
+     * - {@link Communicator}: Samchon Framework's own protocool.
+     * - {@link WebCommunicator}: Web-socket protocol
+     * - {@link SharedWorkerCommunicator}: SharedWorker's message protocol.
+     *
+     * #### [Inherited] {@link ICommunicator}
+     * {@link ICommunicator} is an interface for communicator classes who take full charge of network communication with
+     * remote system, without reference to whether the remote system is a server or a client. Type of the
+     * {@link ICommunicator} is specified to {@link IServerConnector} and {@link IClientDriver} whether the remote system
+     * is a server (that I've to connect) or a client (a client connected to my server).
+     *
+     * Whenever a replied message comes from the remote system, the message will be converted to an {@link Invoke} class
+     * and the {@link Invoke} object will be shifted to the {@link IProtocol listener}'s
+     * {@link IProtocol.replyData IProtocol.replyData()} method.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link IClientDriver}, {@link IServerConnector}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#icommunicator)
+     * @author Jeongho Nam <http://samchon.org>
+     */
     abstract class CommunicatorBase implements ICommunicator {
         /**
          * @hidden
@@ -3170,6 +4157,9 @@ declare namespace samchon.protocol {
          * @inheritdoc
          */
         onClose: Function;
+        /**
+         * @hidden
+         */
         protected connected_: boolean;
         /**
          * @hidden
@@ -3188,7 +4178,7 @@ declare namespace samchon.protocol {
          */
         constructor();
         /**
-         * Construct from <i>listener</i>.
+         * Construct from *listener*.
          *
          * @param listener An {@link IProtocol} object to listen {@link Invoke} messages.
          */
@@ -3201,14 +4191,60 @@ declare namespace samchon.protocol {
          * @inheritdoc
          */
         isConnected(): boolean;
+        /**
+         * @hidden
+         */
         protected is_binary_invoke(): boolean;
+        /**
+         * @inheritdoc
+         */
         abstract sendData(invoke: Invoke): void;
+        /**
+         * @inheritdoc
+         */
         replyData(invoke: Invoke): void;
+        /**
+         * @hidden
+         */
         protected handle_string(str: string): void;
+        /**
+         * @hidden
+         */
         protected handle_binary(binary: Uint8Array): void;
     }
 }
 declare namespace samchon.protocol {
+    /**
+     * A communicator following Samchon Framework's own protocol.
+     *
+     * {@link Communicator} is an abstract class following Samchon Framework's own protocol. This {@link Communicator}
+     * class is specified to {@link ServerConnector} and {@link ClientDriver} whether the remote system is a server (that
+     * my system is connecting to) or a client (a client conneting to to my server).
+     *
+     * Note that, if one of this or remote system is web-browser based, then you don't have to use this
+     * {@link Communicator} class who follows Samchon Framework's own protocol. Web-browser supports only Web-socket
+     * protocol. Thus in that case, you have to use {@link WebCommunicator} instead.
+     *
+     * #### [Inherited] {@link ICommunicator}
+     * {@link ICommunicator} is an interface for communicator classes who take full charge of network communication with
+     * remote system, without reference to whether the remote system is a server or a client. Type of the
+     * {@link ICommunicator} is specified to {@link IServerConnector} and {@link IClientDriver} whether the remote system
+     * is a server (that I've to connect) or a client (a client connected to my server).
+     *
+     * Whenever a replied message comes from the remote system, the message will be converted to an {@link Invoke} class
+     * and the {@link Invoke} object will be shifted to the {@link IProtocol listener}'s
+     * {@link IProtocol.replyData IProtocol.replyData()} method.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link ClientDriver}, {@link ServerConnector}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#icommunicator)
+     * @author Jeongho Nam <http://samchon.org>
+     */
     abstract class Communicator extends CommunicatorBase {
         /**
          * @hidden
@@ -3266,31 +4302,42 @@ declare namespace samchon.protocol {
 }
 declare namespace samchon.protocol {
     /**
-     * <p> Base class for web-communicator, {@link WebClientDriver} and {@link WebServerConnector}. </p>
+     * A communicator following Web-socket protocol.
      *
-     * <p> This class {@link WebCommunicatorBase} subrogates network communication for web-communicator classes,
-     * {@link WebClinetDriver} and {@link WebServerConnector}. The web-communicator and this class
-     * {@link WebCommunicatorBase} share same interface {@link IProtocol} and have a <b>chain of responsibily</b>
-     * relationship. </p>
+     * {@link WebCommunicator} is an abstract class following Web-socket protocol. This {@link WebCommunicator} class is
+     * specified to {@link WebServerConnector} and {@link WebClientDriver} whether the remote system is a server (that my
+     * system is connecting to) or a client (a client conneting to to my server).
      *
-     * <p> When an {@link Invoke} message was delivered from the connected remote system, then this class calls
-     * web-communicator's {@link WebServerConnector.replyData replyData()} method. Also, when called web-communicator's
-     * {@link WebClientDriver.sendData sendData()}, then {@link sendData sendData()} of this class will be caleed. </p>
+     * Note that, one of this or remote system is web-browser based, then there's not any alternative choice. Web browser
+     * supports only Web-socket protocol. In that case, you've use this {@link WebCommunicator} class.
      *
-     * <ul>
-     *	<li> this.replyData() -> communicator.replyData() </li>
-     *	<li> communicator.sendData() -> this.sendData() </li>
-     * </ul>
+     * #### [Inherited] {@link ICommunicator}
+     * {@link ICommunicator} is an interface for communicator classes who take full charge of network communication with
+     * remote system, without reference to whether the remote system is a server or a client. Type of the
+     * {@link ICommunicator} is specified to {@link IServerConnector} and {@link IClientDriver} whether the remote system
+     * is a server (that I've to connect) or a client (a client connected to my server).
      *
+     * Whenever a replied message comes from the remote system, the message will be converted to an {@link Invoke} class
+     * and the {@link Invoke} object will be shifted to the {@link IProtocol listener}'s
+     * {@link IProtocol.replyData IProtocol.replyData()} method.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link WebClientDriver}, {@link WebServerConnector}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#icommunicator)
      * @author Jeongho Nam <http://samchon.org>
      */
     abstract class WebCommunicator extends CommunicatorBase {
         /**
-         * Connection driver, a socket for web-socket.
+         * @hidden
          */
         protected connection_: websocket.connection;
         /**
-         * Close the connection.
+         * @inheritdoc
          */
         close(): void;
         /**
@@ -3298,236 +4345,171 @@ declare namespace samchon.protocol {
          */
         sendData(invoke: Invoke): void;
         /**
-         * <p> Handle raw-data received from the remote system. </p>
-         *
-         * <p> Queries raw-data received from the remote system. When the raw-data represents an formal {@link Invoke}
-         * message, then it will be sent to the {@link replyData}. </p>
-         *
-         * @param message A raw-data received from the remote system.
+         * @hidden
          */
         protected handle_message(message: websocket.IMessage): void;
+        /**
+         * @hidden
+         */
         protected handle_close(): void;
     }
 }
 declare namespace samchon.protocol {
+    /**
+     * A communicator for shared worker.
+     *
+     * {@link SharedWorkerCommunicator} is an abstract class for communication between SharedWorker and Web-browser. This
+     * {@link SharedWorkerCommunicator} is specified to {@link SharedWorkerServerConnector} and
+     * {@link SharedWorkerClientDriver} whether the remote system is a server (that my system is connecting to) or a client
+     * (a client conneting to to my server).
+     *
+     * Note that, SharedWorker is a conception only existed in web-browser. This {@link SharedWorkerCommunicator} is not
+     * supported in NodeJS. Only web-browser environment can utilize this {@link SharedWorkerCommunicator}.
+     *
+     * #### Why SharedWorker be a server?
+     * SharedWorker, it allows only an instance (process) to be created whether the SharedWorker is declared in a browser
+     * or multiple browsers. To integrate them, messages are being sent and received. Doesn't it seem like a relationship
+     * between a server and clients? Thus, Samchon Framework consider the SharedWorker as a server and browsers as
+     * clients.
+     *
+     * The class {@link SharedWorkerCommunicator} is designed make such relationship. From now on, SharedWorker is a
+     * {@link SharedWorkerServer server} and {@link SharedWorkerServerConnector browsers} are clients. Integrate the
+     * server and clients with this {@link SharedWorkerCommunicator}.
+     *
+     * #### [Inherited] {@link ICommunicator}
+     * {@link ICommunicator} is an interface for communicator classes who take full charge of network communication with
+     * remote system, without reference to whether the remote system is a server or a client. Type of the
+     * {@link ICommunicator} is specified to {@link IServerConnector} and {@link IClientDriver} whether the remote system
+     * is a server (that I've to connect) or a client (a client connected to my server).
+     *
+     * Whenever a replied message comes from the remote system, the message will be converted to an {@link Invoke} class
+     * and the {@link Invoke} object will be shifted to the {@link IProtocol listener}'s
+     * {@link IProtocol.replyData IProtocol.replyData()} method.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link SharedWorkerClientDriver}, {@link SharedWorkerServerConnector}, {@link IProtocol}
+     * @reference https://developer.mozilla.org/en-US/docs/Web/API/SharedWorker
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#icommunicator)
+     * @author Jeongho Nam <http://samchon.org>
+     */
     abstract class SharedWorkerCommunicator extends CommunicatorBase {
+        /**
+         * @hidden
+         */
         protected port_: MessagePort;
+        /**
+         * @inheritdoc
+         */
         close(): void;
         /**
          * @inheritdoc
          */
         sendData(invoke: Invoke): void;
+        /**
+         * @hidden
+         */
         protected handle_message(event: MessageEvent): void;
     }
 }
 declare namespace samchon.protocol {
     /**
-     * <p> An interface for communicator with connected client. </p>
+     * An interface for communicator with remote client.
      *
-     * <p> {@link IClientDriver} is a type of {@link ICommunicator}, specified for communication with connected client
-     * in a server. It takes full charge of network communication with the connected client. </p>
+     * {@link IClientDriver} is a type of {@link ICommunicator}, specified for communication with remote client who has
+     * connected in a {@link IServer server}. It takes full charge of network communication with the remote client.
      *
-     * <p> {@link IClientDriver} is created in {@link IServer} and delivered via
+     * The {@link IClientDriver} object is created and delivered from {@link IServer} and
      * {@link IServer.addClient IServer.addClient()}. Those are derived types from this {@link IClientDriver}, being
-     * created by matched {@link IServer} object. </p>
+     * created by the matched {@link IServer} object.
      *
-     * <table>
-     *	<tr>
-     *		<th> Derived Type </th>
-     *		<th> Created By </th>
-     *	</tr>
-     *	<tr>
-     *		<td> {@link ClientDrvier} </td>
-     *		<td> {@link Server} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> {@link WebClientDrvier} </td>
-     *		<td> {@link WebServer} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> {@link SharedWorkerClientDrvier} </td>
-     *		<td> {@link SharedWorkerServer} </td>
-     *	</tr>
-     * </table>
+     * Protocol                | Derived Type                     | Created By
+     * ------------------------|----------------------------------|----------------------------
+     * Samchon Framework's own | {@link ClientDriver}             | {@link Server}
+     * Web-socket protocol     | {@link WebClientDriver}          | {@link WebServer}
+     * SharedWorker            | {@link SharedWorkerClientDriver} | {@link SharedWorkerServer}
      *
-     * <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     * When you've got an {@link IClientDriver} object from the {@link IServer.addClient IServer.addClient()}, then
+     * specify {@link IProtocol listener} with {@link IClient.listen IClient.listen()}. Whenever a replied message comes
+     * from the remote system, the message will be converted to an {@link Invoke} class and the {@link Invoke} object
+     * will be shifted to the {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
+     * Below code is an example specifying and managing the {@link IProtocol listener} objects.
+     *
+     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
      *		  target="_blank">
      *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
      *		 style="max-width: 100%" />
-     * </a> </p>
+     * </a>
      *
-     * <p> When you've got an {@link IClientDriver} object from the {@link IServer.addClient IServer.addClient()}, then
-     * specify {@link CommunicatorBase.listener listener} with {@link IClient.listen IClient.listen()}. Below codes are
-     * an example specifying and managing the {@link CommunicatorBase.listener listener} objects. </p>
-     *
-     * <code>
-
-    // IMPORTS
-    import std = require("typescript-stl");
-    import samchon = require("samchon-framework");
-
-    // SHORTCUTS
-    import library = samchon.library;
-    import protocol = samchon.protocol;
-
-    class CalculatorServer extends protocol.Server
-    {
-        private clients: std.HashSet<CalculatorClient>;
-
-        // WHEN A CLIENT HAS CONNECTED
-        public addClient(driver: IClientDriver): void
-        {
-            let client: CalculatorClient = new CalculatorClient(this, driver);
-            this.clients.insert(client);
-        }
-    }
-
-    class CalculatorClient extends protocol.IProtocol
-    {
-        // PARENT SERVER INSTANCE
-        private server: CalculatorServer;
-
-        // COMMUNICATOR, SENDS AND RECEIVES NETWORK MESSAGE WITH CONNECTED CLIENT
-        private driver: protocol.IClientDriver;
-
-        /////
-        // CONSTRUCTORS
-        /////
-        public constructor(server: CalculatorServer, driver: protocol.IClientDriver)
-        {
-            this.server = server;
-            this.driver = driver;
-
-            // START LISTENING AND RESPOND CLOSING EVENT
-            this.driver.listen(this); // INVOKE MESSAGE WILL COME TO HERE
-            this.driver.onClose = this.destructor.bind(this); // DISCONNECTED HANDLER
-        }
-        public destructor(): void
-        {
-            // WHEN DISCONNECTED, THEN ERASE THIS OBJECT FROM CalculatorServer.clients.
-            this.server["clients"].erase(this);
-        }
-
-        /////
-        // INVOKE MESSAGE CHAIN
-        /////
-        public sendData(invoke: protocol.Invoke): void
-        {
-            // CALL ICommunicator.sendData(), WHO PHYSICALLY SEND NETWORK MESSAGE
-            this.driver.sendData(invoke);
-        }
-        public replyData(invoke: protocol.Invoke): void
-        {
-            // FIND MATCHED MEMBER FUNCTION NAMED EQUAL TO THE invoke.getListener()
-            invoke.apply(this);
-        }
-    }
-     * </code>
-     *
-     *
-     * <h2> Basic Components </h2>
-     * <h4> What Basic Components are </h4>
-     * <p> <b>Basic Components</b> are the smallest unit of network communication in this <i>Samchon Framework</i>. With
-     * <b>Basic Components</b>, you can construct any type of network system, even how the network system is enormously
-     * scaled and complicated, by just combinating the <b>Basic Components</b>. </p>
-     *
-     * <p> All the system templates in this framework are also being implemented by utilization of the
-     * <b>Basic Compoonents</b>. </p>
-     *
-     * <ul>
-     *	<li> {@link service Service} </il>
-     *	<li> {@link external External System} </il>
-     *	<li> {@link parallel Parallel System} </il>
-     *	<li> {@link distributed Distributed System} </il>
-     * </ul>
-     *
-     * <p> Note that, whatever the network system what you've to construct is, just concentrate on role of each system
-     * and attach matched <b>Basic Components</b> to the role, within framework of the <b>Object-Oriented Design</b>.
-     * Then construction of the network system will be much easier. </p>
-     *
-     * <ul>
-     *	<li> A system is a server, then use {@link IServer} or {@link IServerBase}. </li>
-     *	<li> A server wants to handle a client has connected, then use {@link IClientDriver}. </li>
-     *	<li> A system is a client connecting to an external server, then use {@link IServerConnector}. </li>
-     *	<li> </li>
-     * </ul>
-     *
-     * <h4> Example - System Templates </h4>
-     * <p> Learning and understanding <i>Basic Components</i> of Samchon Framework, reading source codes and design of
-     * <b>System Templates</b>' modules will be very helpful. </p>
-     *
-     * <table>
-     *	<tr>
-     *		<th> Name </th>
-     *		<th> Source </th>
-     *		<th> API Documents </th>
-     *	</tr>
-     *	<tr>
-     *		<td> Cloud Service </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/service"
-     *				target="_blank"> protocol/service </a> </td>
-     *		<td> {@link protocol.service} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> External System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/external"
-     *				target="_blank"> protocol/external </a> </td>
-     *		<td> {@link protocol.external} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> Parallel System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/parallel"
-     *				target="_blank"> protocol/parallel </a> </td>
-     *		<td> {@link protocol.parallel} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> Distributed System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/distributed"
-     *				target="_blank"> protocol/distributed </a> </td>
-     *		<td> {@link protocol.distributed} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> Slave System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/slave"
-     *				target="_blank"> protocol/slave </a> </td>
-     *		<td> {@link protocol.slave} </td>
-     *	</tr>
-     * </table>
-     *
-     * <h4> Example - Projects </h4>
-     * <ul>
-     *	<li>
-     *		<a href="https://github.com/samchon/framework/wiki/Examples-Calculator" target="_blank"> Calculator </a>
-     *	</li>
-     *	<li>
-     *		<a href="https://github.com/samchon/framework/wiki/Examples-Chatting" target="_blank"> Chatting </a>
-     *	</li>
-     *	<li>
-     *		<a href="https://github.com/samchon/framework/wiki/Examples-Interaction" target="_blank"> Interaction </a>
-     *	</li>
-     * </ul>
-     *
-     * @see {@link IServer}
-     * @handbook <a href="https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iclientdriver"
-     *			 target="_blank"> Basic Components - IClientDriver </a>
+     * @see {@link IServer}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iclientdriver)
      * @author Jeongho Nam <http://samchon.org>
      */
     interface IClientDriver extends ICommunicator {
         /**
-         * <p> Listen message from the newly connected client. </p>
+         * Listen message from the newly connected client.
          *
-         * <p> Starts listening message from the newly connected client. Replied message from the connected client will
-         * be converted to {@link Invoke} classes and shifted to the <i>listener</i>'s
-         * {@link IProtocol.replyData replyData()} method. </p>
+         * Starts listening message from the newly connected client. Replied message from the connected client will be
+         * converted to {@link Invoke} classes and shifted to the *listener*'s {@link IProtocol.replyData replyData()}
+         * method.
          *
          * @param listener A listener object to listen replied message from newly connected client in
-         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} message.
+         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} object.
          */
         listen(listener: IProtocol): void;
     }
 }
 declare namespace samchon.protocol {
+    /**
+     * Communicator with remote client.
+     *
+     * {@link ClientDriver} is a class taking full charge of network communication with remote client who follows Samchon
+     * Framework's own protocol. This {@link ClientDriver} object is always created by {@link Server} class. When you got
+     * this {@link ClientDriver} object from the {@link Server.addClient Server.addClient()}, then specify
+     * {@link IProtocol listener} with the {@link ClientDriver.listen ClientDriver.listen()} method.
+     *
+     * #### [Inherited] {@link IClientDriver}
+     * {@link IClientDriver} is a type of {@link ICommunicator}, specified for communication with remote client who has
+     * connected in a {@link IServer server}. It takes full charge of network communication with the remote client.
+     *
+     * The {@link IClientDriver} object is created and delivered from {@link IServer} and
+     * {@link IServer.addClient IServer.addClient()}. Those are derived types from this {@link IClientDriver}, being
+     * created by the matched {@link IServer} object.
+     *
+     * Protocol                | Derived Type                     | Created By
+     * ------------------------|----------------------------------|----------------------------
+     * Samchon Framework's own | {@link ClientDriver}             | {@link Server}
+     * Web-socket protocol     | {@link WebClientDriver}          | {@link WebServer}
+     * SharedWorker            | {@link SharedWorkerClientDriver} | {@link SharedWorkerServer}
+     *
+     * When you've got an {@link IClientDriver} object from the {@link IServer.addClient IServer.addClient()}, then
+     * specify {@link IProtocol listener} with {@link IClient.listen IClient.listen()}. Whenever a replied message comes
+     * from the remote system, the message will be converted to an {@link Invoke} class and the {@link Invoke} object
+     * will be shifted to the {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
+     * Below code is an example specifying and managing the {@link IProtocol listener} objects.
+     *
+     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link Server}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iclientdriver)
+     * @author Jeongho Nam <http://samchon.org>
+     */
     class ClientDriver extends Communicator implements IClientDriver {
+        /**
+         * Construct from a socket.
+         */
         constructor(socket: socket.socket);
         /**
          * @inheritdoc
@@ -3536,15 +4518,65 @@ declare namespace samchon.protocol {
     }
 }
 declare namespace samchon.protocol {
+    /**
+     * Communicator with remote web-client.
+     *
+     * {@link WebClientDriver} is a class taking full charge of network communication with remote client who follows
+     * Web-socket protocol. This {@link WebClientDriver} object is always created by {@link WebServer} class. When you
+     * got this {@link WebClientDriver} object from the {@link WebServer.addClient WebServer.addClient()}, then specify
+     * {@link IProtocol listener} with the {@link WebClientDriver.listen WebClientDriver.listen()} method.
+     *
+     * Unlike other protocol, Web-socket protocol's clients notify two parameters on their connection;
+     * {@link getSessionID session-id} and {@link getPath path}. The {@link getSessionID session-id} can be used to
+     * identify *user* of each client, and the {@link getPath path} can be used which type of *service* that client wants.
+     * In {@link service} module, you can see the best utilization case of them.
+     * - {@link service.User}: utlization of the {@link getSessionID session-id}.
+     * - {@link service.Service}: utilization of the {@link getPath path}.
+     *
+     * #### [Inherited] {@link IClientDriver}
+     * {@link IClientDriver} is a type of {@link ICommunicator}, specified for communication with remote client who has
+     * connected in a {@link IServer server}. It takes full charge of network communication with the remote client.
+     *
+     * The {@link IClientDriver} object is created and delivered from {@link IServer} and
+     * {@link IServer.addClient IServer.addClient()}. Those are derived types from this {@link IClientDriver}, being
+     * created by the matched {@link IServer} object.
+     *
+     * Protocol                | Derived Type                     | Created By
+     * ------------------------|----------------------------------|----------------------------
+     * Samchon Framework's own | {@link ClientDriver}             | {@link Server}
+     * Web-socket protocol     | {@link WebClientDriver}          | {@link WebServer}
+     * SharedWorker            | {@link SharedWorkerClientDriver} | {@link SharedWorkerServer}
+     *
+     * When you've got an {@link IClientDriver} object from the {@link IServer.addClient IServer.addClient()}, then
+     * specify {@link IProtocol listener} with {@link IClient.listen IClient.listen()}. Whenever a replied message comes
+     * from the remote system, the message will be converted to an {@link Invoke} class and the {@link Invoke} object
+     * will be shifted to the {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
+     * Below code is an example specifying and managing the {@link IProtocol listener} objects.
+     *
+     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link WebServer}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iclientdriver)
+     * @author Jeongho Nam <http://samchon.org>
+     */
     class WebClientDriver extends WebCommunicator implements IClientDriver {
         /**
-         * Requested path.
+         * @hidden
          */
         private path_;
         /**
-         * Session ID, an identifier of the remote client.
+         * @hidden
          */
         private session_id_;
+        /**
+         * @hidden
+         */
         private listening_;
         /**
          * Initialization Constructor.
@@ -3569,8 +4601,62 @@ declare namespace samchon.protocol {
     }
 }
 declare namespace samchon.protocol {
+    /**
+     * Communicator with remote web-browser.
+     *
+     * {@link SharedWorkerClientDriver} is a class taking full charge of network communication with web browsers. This
+     * {@link SharedWorkerClientDriver} object is always created by {@link SharedWorkerServer} class. When you got this
+     * {@link SharedWorkerClientDriver} object from {@link SharedWorkerServer.addClient SharedWorkerServer.addClient()},
+     * then specify {@link IProtocol listener} with the
+     * {@link SharedWorkerClientDriver.listen SharedWorkerClientDriver.listen()} method.
+     *
+     * #### Why SharedWorker be a server?
+     * SharedWorker, it allows only an instance (process) to be created whether the SharedWorker is declared in a browser
+     * or multiple browsers. To integrate them, messages are being sent and received. Doesn't it seem like a relationship
+     * between a server and clients? Thus, Samchon Framework consider the SharedWorker as a server and browsers as
+     * clients.
+     *
+     * The class {@link SharedWorkerCommunicator} is designed make such relationship. From now on, SharedWorker is a
+     * {@link SharedWorkerServer server} and {@link SharedWorkerServerConnector browsers} are clients. Integrate the
+     * server and clients with this {@link SharedWorkerCommunicator}.
+     *
+     * #### [Inherited] {@link IClientDriver}
+     * {@link IClientDriver} is a type of {@link ICommunicator}, specified for communication with remote client who has
+     * connected in a {@link IServer server}. It takes full charge of network communication with the remote client.
+     *
+     * The {@link IClientDriver} object is created and delivered from {@link IServer} and
+     * {@link IServer.addClient IServer.addClient()}. Those are derived types from this {@link IClientDriver}, being
+     * created by the matched {@link IServer} object.
+     *
+     * Protocol                | Derived Type                     | Created By
+     * ------------------------|----------------------------------|----------------------------
+     * Samchon Framework's own | {@link ClientDriver}             | {@link Server}
+     * Web-socket protocol     | {@link WebClientDriver}          | {@link WebServer}
+     * SharedWorker            | {@link SharedWorkerClientDriver} | {@link SharedWorkerServer}
+     *
+     * When you've got an {@link IClientDriver} object from the {@link IServer.addClient IServer.addClient()}, then
+     * specify {@link IProtocol listener} with {@link IClient.listen IClient.listen()}. Whenever a replied message comes
+     * from the remote system, the message will be converted to an {@link Invoke} class and the {@link Invoke} object
+     * will be shifted to the {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
+     * Below code is an example specifying and managing the {@link IProtocol listener} objects.
+     *
+     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link SharedWorkerServer}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iclientdriver)
+     * @author Jeongho Nam <http://samchon.org>
+     */
     class SharedWorkerClientDriver extends SharedWorkerCommunicator implements IClientDriver {
-        private listening;
+        private listening_;
+        /**
+         * Construct from a MessagePort object.
+         */
         constructor(port: MessagePort);
         /**
          * @inheritdoc
@@ -3618,51 +4704,53 @@ declare namespace samchon.protocol {
     /**
      * A container of entity, and it's a type of entity, too.
      *
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
+     *
      * @author Jeongho Nam <http://samchon.org>
      */
     interface IEntityGroup<T extends IEntity> extends IEntity, std.base.IContainer<T> {
         /**
-         * <p> Construct data of the Entity from an XML object. </p>
+         * Construct data of the Entity from an XML object.
          *
-         * <p> Constructs the EntityArray's own member variables only from the input XML object. </p>
+         * Constructs the EntityArray's own member variables only from the input XML object.
          *
-         * <p> Do not consider about constructing children Entity objects' data in EntityArray::construct().
+         * Do not consider about constructing children Entity objects' data in EntityArray::construct().
          * Those children Entity objects' data will constructed by their own construct() method. Even insertion
-         * of XML objects representing children are done by abstract method of EntityArray::toXML(). </p>
+         * of XML objects representing children are done by abstract method of EntityArray::toXML().
          *
-         * <p> Constructs only data of EntityArray's own. </p>
+         * Constructs only data of EntityArray's own.
          */
         construct(xml: library.XML): void;
         /**
-         * <p> Factory method of a child Entity. </p>
+         * Factory method of a child Entity.
          *
-         * <p> EntityArray::createChild() is a factory method creating a new child Entity which is belonged
+         * EntityArray::createChild() is a factory method creating a new child Entity which is belonged
          * to the EntityArray. This method is called by EntityArray::construct(). The children construction
-         * methods Entity::construct() will be called by abstract method of the EntityArray::construct(). </p>
+         * methods Entity::construct() will be called by abstract method of the EntityArray::construct().
          *
          * @return A new child Entity belongs to EntityArray.
          */
         createChild(xml: library.XML): T;
         /**
-         * <p> Get iterator to element. </p>
+         * Get iterator to element.
          *
-         * <p> Searches the container for an element with a identifier equivalent to <i>key</i> and returns an
-         * iterator to it if found, otherwise it returns an iterator to {@link end end()}. </p>
+         * Searches the container for an element with a identifier equivalent to *key* and returns an
+         * iterator to it if found, otherwise it returns an iterator to {@link end end()}.
          *
-         * <p> Two keys are considered equivalent if the container's comparison object returns false reflexively
-         * (i.e., no matter the order in which the elements are passed as arguments). </p>
+         * Two keys are considered equivalent if the container's comparison object returns false reflexively
+         * (i.e., no matter the order in which the elements are passed as arguments).
          *
-         * <p> Another member functions, {@link has has()} and {@link count count()}, can be used to just check
-         * whether a particular <i>key</i> exists. </p>
+         * Another member functions, {@link has has()} and {@link count count()}, can be used to just check
+         * whether a particular *key* exists.
          *
          * @param key Key to be searched for
-         * @return An iterator to the element, if an element with specified <i>key</i> is found, or
+         * @return An iterator to the element, if an element with specified *key* is found, or
          *		   {@link end end()} otherwise.
          */
         /**
-         * <p> Whether have the item or not. </p>
+         * Whether have the item or not.
          *
-         * <p> Indicates whether a map has an item having the specified identifier. </p>
+         * Indicates whether a map has an item having the specified identifier.
          *
          * @param key Key value of the element whose mapped value is accessed.
          *
@@ -3670,19 +4758,19 @@ declare namespace samchon.protocol {
          */
         has(key: any): boolean;
         /**
-         * <p> Count elements with a specific key. </p>
+         * Count elements with a specific key.
          *
-         * <p> Searches the container for elements whose key is <i>key</i> and returns the number of elements found. </p>
+         * Searches the container for elements whose key is *key* and returns the number of elements found.
          *
          * @param key Key value to be searched for.
          *
-         * @return The number of elements in the container with a <i>key</i>.
+         * @return The number of elements in the container with a *key*.
          */
         count(key: any): number;
         /**
-         * <p> Get an element </p>
+         * Get an element
          *
-         * <p> Returns a reference to the mapped value of the element identified with <i>key</i>. </p>
+         * Returns a reference to the mapped value of the element identified with *key*.
          *
          * @param key Key value of the element whose mapped value is accessed.
          *
@@ -3692,20 +4780,20 @@ declare namespace samchon.protocol {
          */
         get(key: any): T;
         /**
-         * <p> A tag name of children objects. </p>
+         * A tag name of children objects.
          */
         CHILD_TAG(): string;
         /**
-         * <p> Get an XML object represents the EntityArray. </p>
+         * Get an XML object represents the EntityArray.
          *
-         * <p> Archives the EntityArray's own member variables only to the returned XML object. </p>
+         * Archives the EntityArray's own member variables only to the returned XML object.
          *
-         * <p> Do not consider about archiving children Entity objects' data in EntityArray::toXML().
+         * Do not consider about archiving children Entity objects' data in EntityArray::toXML().
          * Those children Entity objects will converted to XML object by their own toXML() method. The
          * insertion of XML objects representing children are done by abstract method of
-         * EntityArray::toXML(). </p>
+         * EntityArray::toXML().
          *
-         * <p> Archives only data of EntityArray's own. </p>
+         * Archives only data of EntityArray's own.
          */
         toXML(): library.XML;
     }
@@ -3857,417 +4945,32 @@ declare namespace samchon.protocol {
 }
 declare namespace samchon.protocol {
     /**
-     * @inheritdoc
-     */
-    interface IEntityCollection<T extends IEntity> extends IEntityGroup<T>, collection.ICollection<T> {
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * @inheritdoc
-     */
-    abstract class EntityArrayCollection<T extends IEntity> extends collection.ArrayCollection<T> implements IEntityCollection<T> {
-        /**
-         * @inheritdoc
-         */
-        construct(xml: library.XML): void;
-        /**
-         * @inheritdoc
-         */
-        abstract createChild(xml: library.XML): T;
-        /**
-         * @inheritdoc
-         */
-        key(): any;
-        /**
-         * @inheritdoc
-         */
-        has(key: any): boolean;
-        /**
-         * @inheritdoc
-         */
-        count(key: any): number;
-        /**
-         * @inheritdoc
-         */
-        get(key: any): T;
-        /**
-         * @inheritdoc
-         */
-        abstract TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        abstract CHILD_TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * @inheritdoc
-     */
-    abstract class EntityListCollection<T extends IEntity> extends collection.ListCollection<T> implements IEntityCollection<T> {
-        /**
-         * @inheritdoc
-         */
-        construct(xml: library.XML): void;
-        /**
-         * @inheritdoc
-         */
-        abstract createChild(xml: library.XML): T;
-        /**
-         * @inheritdoc
-         */
-        key(): any;
-        /**
-         * @inheritdoc
-         */
-        has(key: any): boolean;
-        /**
-         * @inheritdoc
-         */
-        count(key: any): number;
-        /**
-         * @inheritdoc
-         */
-        get(key: any): T;
-        /**
-         * @inheritdoc
-         */
-        abstract TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        abstract CHILD_TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * @inheritdoc
-     */
-    abstract class EntityDequeCollection<T extends IEntity> extends collection.DequeCollection<T> implements IEntityCollection<T> {
-        /**
-         * @inheritdoc
-         */
-        construct(xml: library.XML): void;
-        /**
-         * @inheritdoc
-         */
-        abstract createChild(xml: library.XML): T;
-        /**
-         * @inheritdoc
-         */
-        key(): any;
-        /**
-         * @inheritdoc
-         */
-        has(key: any): boolean;
-        /**
-         * @inheritdoc
-         */
-        count(key: any): number;
-        /**
-         * @inheritdoc
-         */
-        get(key: any): T;
-        /**
-         * @inheritdoc
-         */
-        abstract TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        abstract CHILD_TAG(): string;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * <p> An interface for {@link Invoke} message chain. </p>
+     * Standard message of network I/O.
      *
-     * <p> {@link IProtocol} is an interface for {@link Invoke} message, which is standard message of network I/O in
-     * <i>Samchon Framework</i>, chain. The {@link IProtocol} interface is used to network drivers and some classes
-     * which are in a relationship of <i>Chain of Responsibility Pattern</i> with those network drivers. </p>
+     * {@link Invoke} is a class used in network I/O in protocol package of Samchon Framework.
      *
-     * <p> Implements {@link IProtocol} if the class sends and handles {@link Invoke} message. Looking around source
-     * codes of <i>Samchon Framework</i>, especially <i>System Templates</i>, you can find out that all the classes and
-     * modules handling {@link Invoke} messages are always implementing this {@link IProtocol} . Yes, {@link IProtocol},
-     * this is the main role you've to follow in this <i>Samchon Framework</i>. </p>
-     *
-     * <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
-     *		 style="max-width: 100%" />
-     * </a> </p>
-     *
-     *
-     * <h2> Utilization Case </h2>
-     * <p> Below pseudo code and class diagram represents {@link service Service Module}, who can build a cloud server.
-     * All the classes in the pseudo code are implementing the {@link IProtocol} because all of them are handling
-     * {@link Invoke} message. </p>
-     *
-     * <ul>
-     *	<li> Server: Represents a server literally </li>
-     *	<li> User: Represents an user being identified by its session id. User contains multiple Client objects. </li>
-     *	<ul>
-     *		<li> In browser, an user can open multiple windows.
-     *		<ul>
-     *			<li> User: A browser (like IE, Chrome and Safari).
-     *			<li> Client: An internet browser window
-     *		</ul>
-     *		</li>
-     *	</ul>
-     *	<li> Client: Represents a browser window and it takes role of network communication with it. </li>
-     *	<li> Service: Represents a service, domain logic. </li>
-     * </ul>
-     *
-     * <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_service.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_service.png"
-     *		 style="max-width: 100%" />
-     * </a> </p>
-     *
-     * <code>
-
-    // IMPORTS
-    import std = require("typescript-stl");
-    import samchon = require("samchon-framework");
-
-    // SHORTCUTS
-    import library = samchon.library;
-    import collection = samchon.collection;
-    import protocol = samchon.protocol;
-
-    namespace service
-    {
-        export class Server extends protocol.WebServer implements IProtocol
-        {
-            // SERVER HAS MULTIPLE USER OBJECTS
-            private session_map: std.HashMap<string, User>;
-
-            //------------------------
-            // MESSAGE CHAIN
-            //------------------------
-            public sendData(invoke: protocol.Invoke): void
-            {
-                // SEND INVOKE MESSAGE TO ALL USER OBJECTS
-                for (let it = this.session_map.begin(); !it.equal_to(this.session_map.end()); it = it.next())
-                    it.second.sendData(invoke);
-            }
-            public replyData(invoke: protocol.Invoke): void
-            {
-                invoke.apply(this); // HANDLE INVOKE MESSAGE BY ITSELF
-            }
-        }
-
-        export class User extends
-            collection.HashMapCollection<number, Client> // USER HAS MULTIPLE CLIENT OBJECTS
-            implements IProtocol
-        {
-            private server: Server; // USER REFRES SERVER
-
-            //------------------------
-            // MESSAGE CHAIN
-            //------------------------
-            public sendData(invoke: protocol.Invoke): void
-            {
-                // SEND INVOKE MESSAGE TO ALL CLIENT OBJECTS
-                for (let it = this.begin(); !it.equal_to(this.end()); it = it.next())
-                    it.second.sendData(invoke);
-            }
-            public replyData(invoke: protocol.Invoke): void
-            {
-                invoke.apply(this); // HANDLE INOVKE MESSAGE BY ITSELF
-                this.server.replyData(invoke); // OR VIA SERVER
-            }
-        }
-
-        export class Client implements IProtocol
-        {
-            private user: User; // CLIENT REFERS USER
-            private service: Service; // CLIENT HAS A SERVICE OBJECT
-
-            private driver: WebClientDriver;
-
-            //------------------------
-            // MESSAGE CHAIN
-            //------------------------
-            public sendData(invoke: protocol.Invoke): void
-            {
-                // SEND INVOKE MESSAGE VIA driver: WebClientDriver
-                this.driver.sendData(invoke);
-            }
-            public replyData(invoke: protocol.Invoke): void
-            {
-                invoke.apply(this); // HANDLE INOVKE MEESAGE BY ITSELF
-                this.user.replyData(invoke); // OR VIA USER
-
-                if (this.service != null) // OR VIA SERVICE
-                    this.service.replyData(invoke);
-            }
-        }
-
-        export class Service implements IProtocol
-        {
-            private client: Client; // SERVICE REFRES CLIENT
-
-            //------------------------
-            // MESSAGE CHAIN
-            //------------------------
-            public sendData(invoke: protocol.Invoke): void
-            {
-                // SEND INVOKE MESSAGE VIA CLIENT
-                return this.client.sendData(invoke);
-            }
-            public replyData(invoke: protocol.Invoke): void
-            {
-                invoke.apply(this); // HANDLE INVOKE MESSAGE BY ITSELF
-            }
-        }
-    }
-     * </code>
-     *
-     *
-     * <h2> Basic Components </h2>
-     * <h4> What Basic Components are </h4>
-     * <p> <b>Basic Components</b> are the smallest unit of network communication in this <i>Samchon Framework</i>. With
-     * <b>Basic Components</b>, you can construct any type of network system, even how the network system is enormously
-     * scaled and complicated, by just combinating the <b>Basic Components</b>. </p>
-     *
-     * <p> All the system templates in this framework are also being implemented by utilization of the
-     * <b>Basic Compoonents</b>. </p>
-     *
-     * <ul>
-     *	<li> {@link service Service} </il>
-     *	<li> {@link external External System} </il>
-     *	<li> {@link parallel Parallel System} </il>
-     *	<li> {@link distributed Distributed System} </il>
-     * </ul>
-     *
-     * <p> Note that, whatever the network system what you've to construct is, just concentrate on role of each system
-     * and attach matched <b>Basic Components</b> to the role, within framework of the <b>Object-Oriented Design</b>.
-     * Then construction of the network system will be much easier. </p>
-     *
-     * <ul>
-     *	<li> A system is a server, then use {@link IServer} or {@link IServerBase}. </li>
-     *	<li> A server wants to handle a client has connected, then use {@link IClientDriver}. </li>
-     *	<li> A system is a client connecting to an external server, then use {@link IServerConnector}. </li>
-     *	<li> </li>
-     * </ul>
-     *
-     * <h4> Example - System Templates </h4>
-     * <p> Learning and understanding <i>Basic Components</i> of Samchon Framework, reading source codes and design of
-     * <b>System Templates</b>' modules will be very helpful. </p>
-     *
-     * <table>
-     *	<tr>
-     *		<th> Name </th>
-     *		<th> Source </th>
-     *		<th> API Documents </th>
-     *	</tr>
-     *	<tr>
-     *		<td> Cloud Service </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/service"
-     *				target="_blank"> protocol/service </a> </td>
-     *		<td> {@link protocol.service} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> External System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/external"
-     *				target="_blank"> protocol/external </a> </td>
-     *		<td> {@link protocol.external} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> Parallel System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/parallel"
-     *				target="_blank"> protocol/parallel </a> </td>
-     *		<td> {@link protocol.parallel} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> Distributed System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/distributed"
-     *				target="_blank"> protocol/distributed </a> </td>
-     *		<td> {@link protocol.distributed} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> Slave System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/slave"
-     *				target="_blank"> protocol/slave </a> </td>
-     *		<td> {@link protocol.slave} </td>
-     *	</tr>
-     * </table>
-     *
-     * <h4> Example - Projects </h4>
-     * <ul>
-     *	<li>
-     *		<a href="https://github.com/samchon/framework/wiki/Examples-Calculator" target="_blank"> Calculator </a>
-     *	</li>
-     *	<li>
-     *		<a href="https://github.com/samchon/framework/wiki/Examples-Chatting" target="_blank"> Chatting </a>
-     *	</li>
-     *	<li>
-     *		<a href="https://github.com/samchon/framework/wiki/Examples-Interaction" target="_blank"> Interaction </a>
-     *	</li>
-     * </ul>
-     *
-     * @see {@link Invoke}
-     * @handbook <a href="https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iprotocol"
-     *			 target="_blank"> Basic Components - IProtocol </a>
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IProtocol {
-        /**
-         * <p> Sending message. </p>
-         * <p> Sends message to related system or shifts the responsibility to chain. </p>
-         *
-         * @param invoke Invoke message to send
-         */
-        replyData(invoke: Invoke): void;
-        /**
-         * <p> Handling replied message. </p>
-         * <p> Handles replied message or shifts the responsibility to chain. </p>
-         *
-         * @param invoke An {@link Invoke} message has received.
-         */
-        sendData(invoke: Invoke): void;
-    }
-}
-declare namespace samchon.protocol {
-    /**
-     * <p> Standard message of network I/O. </p>
-     *
-     * <p> {@link Invoke} is a class used in network I/O in protocol package of Samchon Framework. </p>
-     *
-     * <p> The Invoke message has an XML structure like the result screen of provided example in below.
+     * The Invoke message has an XML structure like the result screen of provided example in below.
      * We can enjoy lots of benefits by the normalized and standardized message structure used in
-     * network I/O. </p>
+     * network I/O.
      *
-     * <p> The greatest advantage is that we can make any type of network system, even how the system
+     * The greatest advantage is that we can make any type of network system, even how the system
      * is enourmously complicated. As network communication message is standardized, we only need to
      * concentrate on logical relationships between network systems. We can handle each network system
      * like a object (class) in OOD. And those relationships can be easily designed by using design
-     * pattern. </p>
+     * pattern.
      *
-     * <p> In Samchon Framework, you can make any type of network system with basic componenets
+     * In Samchon Framework, you can make any type of network system with basic componenets
      * (IProtocol, IServer and ICommunicator) by implemens or inherits them, like designing
-     * classes of S/W architecture. </p>
+     * classes of S/W architecture.
      *
-     * @see IProtocol
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
+     *
+     * @see {@link IProtocol}
      * @author Jeongho Nam <http://samchon.org>
      */
     class Invoke extends EntityArray<InvokeParameter> {
         /**
-         * <p> Listener, represent function's name. </p>
+         * Listener, represent function's name.
          */
         private listener;
         /**
@@ -4297,13 +5000,13 @@ declare namespace samchon.protocol {
          */
         getListener(): string;
         /**
-         * <p> Get arguments for Function.apply(). </p>
+         * Get arguments for Function.apply().
          *
          * @return An array containing values of the contained parameters.
          */
         getArguments(): Array<any>;
         /**
-         * <p> Apply to a matched function. </p>
+         * Apply to a matched function.
          */
         apply(obj: IProtocol): boolean;
         /**
@@ -4320,21 +5023,23 @@ declare namespace samchon.protocol {
     /**
      * A parameter belongs to an Invoke.
      *
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_message_protocol.png)
+     *
      * @author Jeongho Nam <http://samchon.org>
      */
     class InvokeParameter extends Entity {
         /**
-         * <p> Name of the parameter. </p>
+         * Name of the parameter.
          *
          * @details Optional property, can be omitted.
          */
         protected name: string;
         /**
-         * <p> Type of the parameter. </p>
+         * Type of the parameter.
          */
         protected type: string;
         /**
-         * <p> Value of the parameter. </p>
+         * Value of the parameter.
          */
         protected value: string | number | library.XML | Uint8Array;
         /**
@@ -4390,35 +5095,78 @@ declare namespace samchon.protocol {
     }
 }
 declare namespace samchon.protocol {
-    class InvokeHistory extends Entity {
+    /**
+     * History of an {@link Invoke} message.
+     *
+     * The {@link InvokeHistory} is a class archiving history log of an {@link Invoke} message with elapsed time. This
+     * {@link InvokeHistory} class is used to report elapsed time of handling a requested process from **slave** to
+     * **master** system.
+     *
+     * The **master** system utilizes derived {@link InvokeHistory} objects to compute performance indices.
+     * - {@link ParallelSytem.getPerformance}
+     * - {@link DistributedProcess.getResource}
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class InvokeHistory extends protocol.Entity {
         /**
-         *
+         * @hidden
          */
         private uid;
         /**
-         * @see {@link Invoke.listener}
+         * @hidden
          */
         private listener;
         /**
-         *
+         * @hidden
          */
         private start_time_;
         /**
-         *
+         * @hidden
          */
         private end_time_;
         /**
          * Default Constructor.
          */
         constructor();
-        constructor(invoke: Invoke);
+        /**
+         * Construct from an {@link Invoke} message.
+         *
+         * @param invoke An {@link Invoke} message requesting a *parallel or distributed process*.
+         */
+        constructor(invoke: protocol.Invoke);
+        /**
+         * @inheritdoc
+         */
         construct(xml: library.XML): void;
+        /**
+         * Complete the history.
+         *
+         * Completes the history and determines the {@link getEndTime end time}.
+         */
         complete(): void;
         key(): number;
+        /**
+         * Get unique ID.
+         */
         getUID(): number;
+        /**
+         * Get {@link Invoke.getListener listener} of the {@link Invoke} message.
+         */
         getListener(): string;
+        /**
+         * Get start time.
+         */
         getStartTime(): Date;
+        /**
+         * Get end time.
+         */
         getEndTime(): Date;
+        /**
+         * Compute elapsed time.
+         *
+         * @return nanoseconds.
+         */
         computeElapsedTime(): number;
         /**
          * @inheritdoc
@@ -4428,125 +5176,170 @@ declare namespace samchon.protocol {
          * @inheritdoc
          */
         toXML(): library.XML;
-        toInvoke(): Invoke;
+        /**
+         * Convert to an {@link Invoke} message.
+         *
+         * Creates and returns an {@link Invoke} message that is used to reporting to the **master**.
+         */
+        toInvoke(): protocol.Invoke;
     }
 }
 declare namespace samchon.protocol {
     /**
-     * <p> An interface for a physical server. </p>
+     * An interface for {@link Invoke} message chain.
      *
-     * <p> {@link IServer} provides methods for opening a server. Extends one of them who are derived from this
-     * {@link IServer} and open the server with method {@link open IServer.open()}. Override
-     * {@link addClient IServer.addClient()} who accepts a newly connected client with {@link IClientDriver}.
-     * If you're embarrased because your class already extended another one, then use {@link IServerBase}. </p>
+     * {@link IProtocol} is an interface for {@link Invoke} message, which is standard message of network I/O in
+     * *Samchon Framework*, chain. The {@link IProtocol} interface is used to network drivers and some classes which are
+     * in a relationship of *Chain of Responsibility Pattern* with those network drivers.
      *
-     * <ul>
-     *	<li> {@link Server} </li>
-     *	<li> {@link WebServer} </li>
-     *	<li> {@link SharedWorkerServer} </li>
-     * </ul>
+     * Implements {@link IProtocol} if the class sends and handles {@link Invoke} messages. Looking around source codes of
+     * the *Samchon Framework*, especially *Templates*, you can find out that all the classes and modules handling
+     * {@link Invoke} messages are always implementing this {@link IProtocol}.
      *
-     * <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
      *		  target="_blank">
      *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
      *		 style="max-width: 100%" />
-     * </a> </p>
+     * </a>
      *
-     * <h2> Basic Components </h2>
-     * <h4> What Basic Components are </h4>
-     * <p> <b>Basic Components</b> are the smallest unit of network communication in this <i>Samchon Framework</i>. With
-     * <b>Basic Components</b>, you can construct any type of network system, even how the network system is enormously
-     * scaled and complicated, by just combinating the <b>Basic Components</b>. </p>
-     *
-     * <p> All the system templates in this framework are also being implemented by utilization of the
-     * <b>Basic Compoonents</b>. </p>
-     *
-     * <ul>
-     *	<li> {@link service Service} </il>
-     *	<li> {@link external External System} </il>
-     *	<li> {@link parallel Parallel System} </il>
-     *	<li> {@link distributed Distributed System} </il>
-     * </ul>
-     *
-     * <p> Note that, whatever the network system what you've to construct is, just concentrate on role of each system
-     * and attach matched <b>Basic Components</b> to the role, within framework of the <b>Object-Oriented Design</b>.
-     * Then construction of the network system will be much easier. </p>
-     *
-     * <ul>
-     *	<li> A system is a server, then use {@link IServer} or {@link IServerBase}. </li>
-     *	<li> A server wants to handle a client has connected, then use {@link IClientDriver}. </li>
-     *	<li> A system is a client connecting to an external server, then use {@link IServerConnector}. </li>
-     *	<li> </li>
-     * </ul>
-     *
-     * <h4> Example - System Templates </h4>
-     * <p> Learning and understanding <i>Basic Components</i> of Samchon Framework, reading source codes and design of
-     * <b>System Templates</b>' modules will be very helpful. </p>
-     *
-     * <table>
-     *	<tr>
-     *		<th> Name </th>
-     *		<th> Source </th>
-     *		<th> API Documents </th>
-     *	</tr>
-     *	<tr>
-     *		<td> Cloud Service </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/service"
-     *				target="_blank"> protocol/service </a> </td>
-     *		<td> {@link protocol.service} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> External System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/external"
-     *				target="_blank"> protocol/external </a> </td>
-     *		<td> {@link protocol.external} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> Parallel System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/parallel"
-     *				target="_blank"> protocol/parallel </a> </td>
-     *		<td> {@link protocol.parallel} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> Distributed System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/distributed"
-     *				target="_blank"> protocol/distributed </a> </td>
-     *		<td> {@link protocol.distributed} </td>
-     *	</tr>
-     *	<tr>
-     *		<td> Slave System </td>
-     *		<td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/slave"
-     *				target="_blank"> protocol/slave </a> </td>
-     *		<td> {@link protocol.slave} </td>
-     *	</tr>
-     * </table>
-     *
-     * <h4> Example - Projects </h4>
-     * <ul>
-     *	<li>
-     *		<a href="https://github.com/samchon/framework/wiki/Examples-Calculator" target="_blank"> Calculator </a>
-     *	</li>
-     *	<li>
-     *		<a href="https://github.com/samchon/framework/wiki/Examples-Chatting" target="_blank"> Chatting </a>
-     *	</li>
-     *	<li>
-     *		<a href="https://github.com/samchon/framework/wiki/Examples-Interaction" target="_blank"> Interaction </a>
-     *	</li>
-     * </ul>
-     *
-     * @see {@link IClientDriver}
-     * @handbook <a href="https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserver"
-     *			 target="_blank"> Basic Components - IServer </a>
+     * @see {@link Invoke}
+     * @handbook https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iprotocol
      * @author Jeongho Nam <http://samchon.org>
      */
-    interface IServer {
-        open(port: number): void;
-        close(): void;
-        addClient(clientDriver: IClientDriver): void;
+    interface IProtocol {
+        /**
+         * Sending message.
+         *
+         * Sends message to related system or shifts the responsibility to chain.
+         *
+         * @param invoke Invoke message to send
+         */
+        replyData(invoke: Invoke): void;
+        /**
+         * Handling replied message.
+         *
+         * Handles replied message or shifts the responsibility to chain.
+         *
+         * @param invoke An {@link Invoke} message has received.
+         */
+        sendData(invoke: Invoke): void;
     }
 }
 declare namespace samchon.protocol {
+    /**
+     * An interface for a server.
+     *
+     * {@link IServer} is an interfaec for server classes who are providing methods for {@link open opening a server} and
+     * {@link IClientDriver accepting clients}.
+     *
+     * To open a server, extends one of derived class under below considedring which protocol to follow first. At next,
+     * overrides {@link addClient addClient()} method who accepts a newly connected client as an {@link IClientDriver}
+     * object. Then at last, call {@link open open()} method with specified port number.
+     *
+     * Protocol | Derived Type | Related {@link IClientDriver}
+     * ---------|--------------|-------------------------------
+     * Samchon Framework's own | {@link Server} | {@link ClientDriver}
+     * Web-socket protocol | {@link WebServer} | {@link WebClientDriver}
+     * SharedWorker | {@link SharedWorkerServer} | {@link SharedWorkerClientDriver}
+     *
+     * Below codes and classes will be good examples for comprehending how to open a server and handle remote clients.
+     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
+     * - https://github.com/samchon/framework/blob/master/ts/examples/chat-server/server.ts
+     * - {@link service.Server}
+     * - {@link external.ExternalClientArray}
+     * - {@link slave.SlaveServer}
+     *
+     * If you're embarrased because your class already extended another one, then use {@link IServerBase}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link IClientDriver}, {@link IServerBase}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserver)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IServer {
+        /**
+         * Open server.
+         *
+         * @param port Port number to open.
+         */
+        open(port: number): void;
+        /**
+         * Close server.
+         *
+         * Close opened server. All remote clients, have connected with this server, are also closed and their call back
+         * functions, for closed connection, {@link IClientDriver.onClose} are also called.
+         */
+        close(): void;
+        /**
+         * Add a newly connected remote client.
+         *
+         * The {@link addClient addClient()} is an abstract method being called when a remote client is newly connected
+         * with {@link IClientDriver} object who communicates with the remote system. Overrides this method and defines
+         * what to do with the *driver*, a newly connected remote client.
+         *
+         * Below methods and example codes may be good for comprehending how to utilize this {@link addClient} method.
+         *
+         * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
+         * - https://github.com/samchon/framework/blob/master/ts/examples/chat-server/server.ts
+         * - {@link service.Server.addClient}
+         * - {@link external.ExternalClientArray.addClient}
+         * - {@link slave.SlaveServer.addClient}
+         *
+         * @param driver A {@link ICommunicator communicator} with (newly connected) remote client.
+         */
+        addClient(driver: IClientDriver): void;
+    }
+}
+declare namespace samchon.protocol {
+    /**
+     * A server.
+     *
+     * The {@link Server} is an abstract class designed to open a server and accept clients who are following Samchon
+     * Framework's own protocol. Extends this {@link Server} class and overrides {@link addClient addClient()} method to
+     * define what to do with newly connected {@link ClientDriver remote clients}.
+     *
+     * #### [Inherited] {@link IServer}
+     * {@link IServer} is an interfaec for server classes who are providing methods for {@link open opening a server} and
+     * {@link IClientDriver accepting clients}.
+     *
+     * To open a server, extends one of derived class under below considedring which protocol to follow first. At next,
+     * overrides {@link addClient addClient()} method who accepts a newly connected client as an {@link IClientDriver}
+     * object. Then at last, call {@link open open()} method with specified port number.
+     *
+     * Protocol | Derived Type | Related {@link IClientDriver}
+     * ---------|--------------|-------------------------------
+     * Samchon Framework's own | {@link Server} | {@link ClientDriver}
+     * Web-socket protocol | {@link WebServer} | {@link WebClientDriver}
+     * SharedWorker | {@link SharedWorkerServer} | {@link SharedWorkerClientDriver}
+     *
+     * Below codes and classes will be good examples for comprehending how to open a server and handle remote clients.
+     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
+     * - https://github.com/samchon/framework/blob/master/ts/examples/chat-server/server.ts
+     * - {@link service.Server}
+     * - {@link external.ExternalClientArray}
+     * - {@link slave.SlaveServer}
+     *
+     * If you're embarrased because your class already extended another one, then use {@link IServerBase}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link ClientDriver}, {@link ServerBase}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserver)
+     * @author Jeongho Nam <http://samchon.org>
+     */
     abstract class Server implements IServer {
+        /**
+         * @hidden
+         */
         private server;
         /**
          * @inheritdoc
@@ -4560,17 +5353,60 @@ declare namespace samchon.protocol {
          * @inheritdoc
          */
         close(): void;
+        /**
+         * @hidden
+         */
         private handle_connect(socket);
     }
 }
 declare namespace samchon.protocol {
+    /**
+     * A web server.
+     *
+     * The {@link WebServer} is an abstract class designed to open a server and accept clients who are following
+     * web-socket protocol. Extends this {@link WebServer} class and overrides {@link addClient addClient()} method to
+     * define what to do with newly connected {@link WebClientDriver remote clients}.
+     *
+     * #### [Inherited] {@link IServer}
+     * {@link IServer} is an interfaec for server classes who are providing methods for {@link open opening a server} and
+     * {@link IClientDriver accepting clients}.
+     *
+     * To open a server, extends one of derived class under below considedring which protocol to follow first. At next,
+     * overrides {@link addClient addClient()} method who accepts a newly connected client as an {@link IClientDriver}
+     * object. Then at last, call {@link open open()} method with specified port number.
+     *
+     * Protocol | Derived Type | Related {@link IClientDriver}
+     * ---------|--------------|-------------------------------
+     * Samchon Framework's own | {@link Server} | {@link ClientDriver}
+     * Web-socket protocol | {@link WebServer} | {@link WebClientDriver}
+     * SharedWorker | {@link SharedWorkerServer} | {@link SharedWorkerClientDriver}
+     *
+     * Below codes and classes will be good examples for comprehending how to open a server and handle remote clients.
+     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
+     * - https://github.com/samchon/framework/blob/master/ts/examples/chat-server/server.ts
+     * - {@link service.Server}
+     * - {@link external.ExternalClientArray}
+     * - {@link slave.SlaveServer}
+     *
+     * If you're embarrased because your class already extended another one, then use {@link IServerBase}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link WebClientDriver}, {@link WebServerBase}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserver)
+     * @author Jeongho Nam <http://samchon.org>
+     */
     abstract class WebServer implements IServer {
         /**
-         * A server handler.
+         * @hidden
          */
         private http_server_;
         /**
-         * Sequence number for issuing session id.
+         * @hidden
          */
         private sequence_;
         /**
@@ -4594,31 +5430,70 @@ declare namespace samchon.protocol {
          */
         abstract addClient(driver: WebClientDriver): void;
         /**
-         * <p> Handle request from a client system. </p>
-         *
-         * <p> This method {@link handle_request} will be called when a client is connected. It will call an abstract
-         * method method {@link addClient addClient()} who handles an accepted client. If the newly connected client
-         * doesn't have its own session id, then a new session id will be issued. </p>
-         *
-         * @param request Requested header.
+         * @hidden
          */
         private handle_request(request);
         /**
-         * <p> Get session id from a newly connected. </p>
-         *
-         * <p> Queries ordinary session id from cookies of a newly connected client. If the client has not, a new
-         * session id will be issued. </p>
-         *
-         * @param cookies Cookies from the remote client.
+         * @hidden
          */
         private get_session_id(cookies);
         /**
-         * Issue a new session id.
+         * @hidden
          */
         private issue_session_id();
     }
 }
 declare namespace samchon.protocol {
+    /**
+     * A SharedWorker server.
+     *
+     * The {@link SharedWorker} is an abstract class is realized to open a SharedWorker server and accept web-browser
+     * clients. Extends this {@link SharedWorkerServer} class and overrides {@link addClient addClient()} method to
+     * define what to do with newly connected {@link ClientDriver remote clients}.
+     *
+     * #### Why SharedWorker be a server?
+     * SharedWorker, it allows only an instance (process) to be created whether the SharedWorker is declared in a browser
+     * or multiple browsers. To integrate them, messages are being sent and received. Doesn't it seem like a relationship
+     * between a server and clients? Thus, Samchon Framework consider the SharedWorker as a server and browsers as
+     * clients.
+     *
+     * The class {@link SharedWorkerCommunicator} is designed make such relationship. From now on, SharedWorker is a
+     * {@link SharedWorkerServer server} and {@link SharedWorkerServerConnector browsers} are clients. Integrate the
+     * server and clients with this {@link SharedWorkerCommunicator}.
+     *
+     * #### [Inherited] {@link IServer}
+     * {@link IServer} is an interfaec for server classes who are providing methods for {@link open opening a server} and
+     * {@link IClientDriver accepting clients}.
+     *
+     * To open a server, extends one of derived class under below considedring which protocol to follow first. At next,
+     * overrides {@link addClient addClient()} method who accepts a newly connected client as an {@link IClientDriver}
+     * object. Then at last, call {@link open open()} method with specified port number.
+     *
+     * Protocol | Derived Type | Related {@link IClientDriver}
+     * ---------|--------------|-------------------------------
+     * Samchon Framework's own | {@link Server} | {@link ClientDriver}
+     * Web-socket protocol | {@link WebServer} | {@link WebClientDriver}
+     * SharedWorker | {@link SharedWorkerServer} | {@link SharedWorkerClientDriver}
+     *
+     * Below codes and classes will be good examples for comprehending how to open a server and handle remote clients.
+     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-server.ts
+     * - https://github.com/samchon/framework/blob/master/ts/examples/chat-server/server.ts
+     * - {@link service.Server}
+     * - {@link external.ExternalClientArray}
+     * - {@link slave.SlaveServer}
+     *
+     * If you're embarrased because your class already extended another one, then use {@link IServerBase}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link SharedWorkerClientDriver}, {@link SharedWorkerServerBase}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserver)
+     * @author Jeongho Nam <http://samchon.org>
+     */
     abstract class SharedWorkerServer implements IServer {
         /**
          * @inheritdoc
@@ -4632,57 +5507,62 @@ declare namespace samchon.protocol {
          * @inheritdoc
          */
         close(): void;
+        /**
+         * @hidden
+         */
         private handle_connect(event);
     }
 }
 declare namespace samchon.protocol {
     /**
-     * <p> An interface for substitute server classes. </p>
+     * An interface for substitute server classes.
      *
-     * <p> {@link IServerBase} is an interface for substitue server classes who subrogate server's role. </p>
+     * {@link IServerBase} is an interface for substitue server classes who subrogate server's role.
      *
-     * <p> The easiest way to defining a server class is to extending one of them, who are derived from the
-     * {@link IServer}. </p>
+     * The easiest way to defining a server class is to extending one of them below, who implemented the {@link IServer}.
+     * However, it is impossible (that is, if the class is already extending another class), you can instead implement
+     * the {@link IServer} interface, create an {@link IServerBase} member, and write simple hooks to route calls into
+     * the aggregated {@link IServerBase}.
      *
-     * <ul>
-     *	<li> {@link Server} </li>
-     *	<li> {@link WebServer} </li>
-     *	<li> {@link SharedWorkerServer} </li>
-     * </ul>
+     * Protocol | {@link IServer} | {@link IServerBase} | {@link IClientDriver}
+     * ---------|-----------------|---------------------|-----------------------
+     * Samchon Framework's own | {@link Server} | {@link ServerBase} | {@link ClientDriver}
+     * Web-socket protocol | {@link WebServer} | {@link WebServerBase} | {@link WebClientDriver}
+     * SharedWorker | {@link SharedWorkerServer} | {@link SharedWorkerServerBase} | {@link SharedWorkerClientDriver}
      *
-     * <p> However, it is impossible (that is, if the class is already extending another class), you can instead implement
-     * the {@link IServer} interface, create an {@link IServerBase} member, and write simple hooks to route calls into the
-     * aggregated {@link IServerBase}. </p>
+     * After the hooking to aggregated {@link IServerBase} object, overrides {@link addClient addClient()} method who
+     * accepts a newly connected client as an {@link IClientDriver} object. At last, call {@link open open()} method with
+     * specified port number.
      *
-     * <p> {@link ExternalClientArray} can be a good example using this {@link IServerBase}. </p>
-     * <ul>
-     *	<li> https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalClientArray.ts </li>
-     * </ul>
+     * ```typescript
+     * class MyServer extends Something implements IServer
+     * {
+     * 	private server_base_: IServerBase = new WebServerBase(this);
      *
-     * <code>
-    class MyServer extends Something implements IServer
-    {
-        private server_base: IServerBase = new WebServerBase(this);
-
-        public addClient(driver: IClientDriver): void
-        {
-            // WHAT TO DO WHEN A CLIENT HAS CONNECTED
-        }
-
-        public open(port: number): void
-        {
-            this.server_base.open();
-        }
-        public close(): void
-        {
-            this.server_base.close();
-        }
-    }
-     * </code>
+     * 	public addClient(driver: IClientDriver): void
+     * 	{
+     * 		// WHAT TO DO WHEN A CLIENT HAS CONNECTED
+     * 	}
      *
-     * @see {@link IServer}
-     * @handbook <a href="https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverbase"
-     *			 target="_blank"> Basic Components - IServerBase </a>
+     * 	public open(port: number): void
+     * 	{
+     * 		this.server_base_.open();
+     * 	}
+     * 	public close(): void
+     * 	{
+     * 		this.server_base_.close();
+     * 	}
+     * }
+     * ```
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link IServer}, {@link IClientDriver}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverbase)
      * @author Jeongho Nam <http://samchon.org>
      */
     interface IServerBase extends IServer {
@@ -4690,172 +5570,272 @@ declare namespace samchon.protocol {
 }
 declare namespace samchon.protocol {
     /**
-     * <p> A substitute {@link Server}. </p>
+     * A substitute {@link Server}.
      *
-     * <p> {@link ServerBase} is a substitute class who subrogates {@link Server}'s responsibility. </p>
+     * The {@link ServerBase} is a substitute class who subrogates {@link Server}'s responsibility.
      *
-     * <p> The easiest way to defning a server class following normal protocol of Samchon Framework is to extending
-     * {@link Server}. However, it is impossible (that is, if the class is already extending another class), you can
-     * instead implement the {@link IServer} interface, create a {@link ServerBase} member, and write simple hooks
-     * to route calls into the aggregated {@link ServerBase}. </p>
+     * #### [Inherited] {@link IServerBase}
+     * {@link IServerBase} is an interface for substitue server classes who subrogate server's role.
      *
-     * <p> {@link ExternalClientArray} can be a good example using this {@link IServerBase}. </p>
-     * <ul>
-     *	<li> https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalClientArray.ts </li>
-     * </ul>
+     * The easiest way to defining a server class is to extending one of them below, who implemented the {@link IServer}.
+     * However, it is impossible (that is, if the class is already extending another class), you can instead implement
+     * the {@link IServer} interface, create an {@link IServerBase} member, and write simple hooks to route calls into
+     * the aggregated {@link IServerBase}.
      *
-     * <code>
-    class MyServer extends Something implements IServer
-    {
-        private server_base: ServerBase = new ServerBase(this);
-
-        public addClient(driver: ClientDriver): void
-        {
-            // WHAT TO DO WHEN A CLIENT HAS CONNECTED
-        }
-
-        public open(port: number): void
-        {
-            this.server_base.open();
-        }
-        public close(): void
-        {
-            this.server_base.close();
-        }
-    }
-     * </code>
+     * Protocol | {@link IServer} | {@link IServerBase} | {@link IClientDriver}
+     * ---------|-----------------|---------------------|-----------------------
+     * Samchon Framework's own | {@link Server} | {@link ServerBase} | {@link ClientDriver}
+     * Web-socket protocol | {@link WebServer} | {@link WebServerBase} | {@link WebClientDriver}
+     * SharedWorker | {@link SharedWorkerServer} | {@link SharedWorkerServerBase} | {@link SharedWorkerClientDriver}
      *
+     * After the hooking to aggregated {@link IServerBase} object, overrides {@link addClient addClient()} method who
+     * accepts a newly connected client as an {@link IClientDriver} object. At last, call {@link open open()} method with
+     * specified port number.
+     *
+     * ```typescript
+     * class MyServer extends Something implements IServer
+     * {
+     * 	private server_base_: IServerBase = new WebServerBase(this);
+     *
+     * 	public addClient(driver: IClientDriver): void
+     * 	{
+     * 		// WHAT TO DO WHEN A CLIENT HAS CONNECTED
+     * 	}
+     *
+     * 	public open(port: number): void
+     * 	{
+     * 		this.server_base_.open();
+     * 	}
+     * 	public close(): void
+     * 	{
+     * 		this.server_base_.close();
+     * 	}
+     * }
+     * ```
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     *
+     * @see {@link Server}, {@link ClientDriver}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverbase)
      * @author Jeongho Nam <http://samchon.org>
      */
     class ServerBase extends Server implements IServerBase {
-        private target_;
-        constructor(target: IServer);
+        /**
+         * @hidden
+         */
+        private hooker_;
+        /**
+         * Construct from a *hooker*.
+         *
+         * @param hooker A hooker throwing responsibility of server's role.
+         */
+        constructor(hooker: IServer);
+        /**
+         * @inheritdoc
+         */
         addClient(driver: IClientDriver): void;
     }
 }
 declare namespace samchon.protocol {
     /**
-     * <p> A substitute {@link WebServer}. </p>
+     * A substitute {@link WebServer}.
      *
-     * <p> {@link WebServerBase} is a substitute class who subrogates {@link WebServer}'s responsibility. </p>
+     * The {@link WebServerBase} is a substitute class who subrogates {@link WebServer}'s responsibility.
      *
-     * <p> The easiest way to defning a server class following normal protocol of Samchon Framework is to extending
-     * {@link WebServer}. However, it is impossible (that is, if the class is already extending another class), you can
-     * instead implement the {@link IServer} interface, create a {@link WebServerBase} member, and write simple hooks to
-     * route calls into the aggregated {@link WebServerBase}. </p>
+     * {@link IServerBase} is an interface for substitue server classes who subrogate server's role.
      *
-     * <p> {@link ExternalClientArray} can be a good example using this {@link IServerBase}. </p>
-     * <ul>
-     *	<li> https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalClientArray.ts </li>
-     * </ul>
+     * The easiest way to defining a server class is to extending one of them below, who implemented the {@link IServer}.
+     * However, it is impossible (that is, if the class is already extending another class), you can instead implement
+     * the {@link IServer} interface, create an {@link IServerBase} member, and write simple hooks to route calls into
+     * the aggregated {@link IServerBase}.
      *
-     * <code>
-    class MyServer extends Something implements IServer
-    {
-        private server_base: WebServerBase = new WebServerBase(this);
-
-        public addClient(driver: WebClientDriver): void
-        {
-            // WHAT TO DO WHEN A CLIENT HAS CONNECTED
-        }
-
-        public open(port: number): void
-        {
-            this.server_base.open();
-        }
-        public close(): void
-        {
-            this.server_base.close();
-        }
-    }
-     * </code>
+     * Protocol | {@link IServer} | {@link IServerBase} | {@link IClientDriver}
+     * ---------|-----------------|---------------------|-----------------------
+     * Samchon Framework's own | {@link Server} | {@link ServerBase} | {@link ClientDriver}
+     * Web-socket protocol | {@link WebServer} | {@link WebServerBase} | {@link WebClientDriver}
+     * SharedWorker | {@link SharedWorkerServer} | {@link SharedWorkerServerBase} | {@link SharedWorkerClientDriver}
      *
+     * After the hooking to aggregated {@link IServerBase} object, overrides {@link addClient addClient()} method who
+     * accepts a newly connected client as an {@link IClientDriver} object. At last, call {@link open open()} method with
+     * specified port number.
+     *
+     * ```typescript
+     * class MyServer extends Something implements IServer
+     * {
+     * 	private server_base_: IServerBase = new WebServerBase(this);
+     *
+     * 	public addClient(driver: IClientDriver): void
+     * 	{
+     * 		// WHAT TO DO WHEN A CLIENT HAS CONNECTED
+     * 	}
+     *
+     * 	public open(port: number): void
+     * 	{
+     * 		this.server_base_.open();
+     * 	}
+     * 	public close(): void
+     * 	{
+     * 		this.server_base_.close();
+     * 	}
+     * }
+     * ```
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link WebServer}, {@link WebClientDriver}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverbase)
      * @author Jeongho Nam <http://samchon.org>
      */
     class WebServerBase extends WebServer implements IServerBase {
-        private target_;
-        constructor(target: IServer);
+        /**
+         * @hidden
+         */
+        private hooker_;
+        /**
+         * Construct from a *hooker*.
+         *
+         * @param hooker A hooker throwing responsibility of server's role.
+         */
+        constructor(hooker: IServer);
+        /**
+         * @inheritdoc
+         */
         addClient(driver: IClientDriver): void;
     }
 }
 declare namespace samchon.protocol {
     /**
-     * <p> A substitute {@link SharedWorkerServer}. </p>
+     * A substitute {@link SharedWorkerServer}.
      *
-     * <p> {@link SharedWorkerServerBase} is a substitute class who subrogates {@link SharedWorkerServer}'s
-     * responsibility. </p>
+     * The {@link SharedWorkerServerBase} is a substitute class who subrogates {@link SharedWorkerServer}'s
+     * responsibility.
      *
-     * <p> The easiest way to defning a server class following normal protocol of Samchon Framework is to extending
-     * {@link SharedWorkerServer}. However, it is impossible (that is, if the class is already extending another class),
-     * you can instead implement the {@link IServer} interface, create a {@link SharedWorkerServerBase} member, and write
-     * simple hooks to route calls into the aggregated {@link SharedWorkerServerBase}. </p>
+     * {@link IServerBase} is an interface for substitue server classes who subrogate server's role.
      *
-     * <p> {@link ExternalClientArray} can be a good example using this {@link IServerBase}. </p>
-     * <ul>
-     *	<li> https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalClientArray.ts </li>
-     * </ul>
+     * The easiest way to defining a server class is to extending one of them below, who implemented the {@link IServer}.
+     * However, it is impossible (that is, if the class is already extending another class), you can instead implement
+     * the {@link IServer} interface, create an {@link IServerBase} member, and write simple hooks to route calls into
+     * the aggregated {@link IServerBase}.
      *
-     * <code>
-    class MyServer extends Something implements IServer
-    {
-        private server_base: SharedWorkerServerBase = new SharedWorkerServerBase(this);
-
-        public addClient(driver: SharedWorkerClientDriver): void
-        {
-            // WHAT TO DO WHEN A CLIENT HAS CONNECTED
-        }
-
-        public open(port: number): void
-        {
-            this.server_base.open();
-        }
-        public close(): void
-        {
-            this.server_base.close();
-        }
-    }
-     * </code>
+     * Protocol | {@link IServer} | {@link IServerBase} | {@link IClientDriver}
+     * ---------|-----------------|---------------------|-----------------------
+     * Samchon Framework's own | {@link Server} | {@link ServerBase} | {@link ClientDriver}
+     * Web-socket protocol | {@link WebServer} | {@link WebServerBase} | {@link WebClientDriver}
+     * SharedWorker | {@link SharedWorkerServer} | {@link SharedWorkerServerBase} | {@link SharedWorkerClientDriver}
      *
+     * After the hooking to aggregated {@link IServerBase} object, overrides {@link addClient addClient()} method who
+     * accepts a newly connected client as an {@link IClientDriver} object. At last, call {@link open open()} method with
+     * specified port number.
+     *
+     * ```typescript
+     * class MyServer extends Something implements IServer
+     * {
+     * 	private server_base_: IServerBase = new WebServerBase(this);
+     *
+     * 	public addClient(driver: IClientDriver): void
+     * 	{
+     * 		// WHAT TO DO WHEN A CLIENT HAS CONNECTED
+     * 	}
+     *
+     * 	public open(port: number): void
+     * 	{
+     * 		this.server_base_.open();
+     * 	}
+     * 	public close(): void
+     * 	{
+     * 		this.server_base_.close();
+     * 	}
+     * }
+     * ```
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @see {@link SharedWorkerServer}, {@link SharedWorkerClientDriver}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverbase)
      * @author Jeongho Nam <http://samchon.org>
      */
     class SharedWorkerServerBase extends SharedWorkerServer implements IServerBase {
-        private target_;
-        constructor(target: IServer);
+        /**
+         * @hidden
+         */
+        private hooker_;
+        /**
+         * Construct from a *hooker*.
+         *
+         * @param hooker A hooker throwing responsibility of server's role.
+         */
+        constructor(hooker: IServer);
+        /**
+         * @inheritdoc
+         */
         addClient(driver: IClientDriver): void;
     }
 }
 declare namespace samchon.protocol {
     /**
-     * <p> An interface for server connector. </p>
+     * An interface for server connector.
      *
-     * <p> {@link IServerConnector} is an interface for server connector classes who ca connect to an external server
-     * as a client. </p>
+     * {@link IServerConnector} is a type of {@link ICommunicator}, specified for server connector classes who connect to
+     * the remote server as a client. {@link IServerConnector} provides {@link connect connection method} and takes full
+     * charge of network communication with the remote server.
      *
-     * <p> Of course, {@link IServerConnector} is extended from the {@link ICommunicator}, thus, it also takes full
-     * charge of network communication and delivers replied message to {@link WebCommunicator.listener listener}'s
-     * {@link IProtocol.replyData replyData()} method. </p>
+     * Declare specific type of {@link IServerConnector} from {@link IProtocol listener} and call the
+     * {@link connect connect()} method. Then whenever a replied message comes from the remote system, the message will
+     * be converted to an {@link Invoke} object and the {@link Invoke} object will be shifted to the
+     * {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method. Below code is an example
+     * connecting to remote server and interacting with it.
      *
-     * @handbook <a href="https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverconnector"
-     *			 target="_blank"> Basic Components - IServerConnector </a>
+     * - https://github.com/samchon/framework/blob/master/ts/examples/calculator/calculator-application.ts
+     *
+     * Note that, protocol of this client and remote server must be matched. Thus, before determining specific type of
+     * this {@link IServerConnector}, you've to consider which protocol and type the remote server follows.
+     *
+     * Protocol | Derived Type | Connect to
+     * ---------|--------------|---------------
+     * Samchon Framework's own | {@link ServerConnector} | {@link Server}
+     * Web-socket protocol | {@link WebServerConnector} | {@link WebServer}
+     * SharedWorker | {@link SharedWorkerServerConnector} | {@link SharedWorkerServer}
+     *
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png)
+     *
+     * @see {@link IServer}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverconnector)
      * @author Jeongho Nam <http://samchon.org>
      */
     interface IServerConnector extends ICommunicator {
         /**
          * Callback function for connection completed.
+         *
+         * When you call {@link connect connect()} and the connection has completed, then this call back function
+         * {@link onConnect} will be called. Note that, if the listener of this {@link onConnect} is a member method of
+         * some class, then you've use the ```bind```.
          */
         onConnect: Function;
         /**
-         * <p> Connect to a server. </p>
+         * Connect to a server.
          *
-         * <p> Connects to a server with specified <i>host</i> address and <i>port</i> number. After the connection has
+         * Connects to a server with specified *host* address and *port* number. After the connection has
          * succeeded, callback function {@link onConnect} is called. Listening data from the connected server also begins.
          * Replied messages from the connected server will be converted to {@link Invoke} classes and will be shifted to
-         * the {@link WebCommunicator.listener listener}'s {@link IProtocol.replyData replyData()} method. </p>
+         * the {@link WebCommunicator.listener listener}'s {@link IProtocol.replyData replyData()} method.
          *
-         * <p> If the connection fails immediately, either an event is dispatched or an exception is thrown: an error
+         * If the connection fails immediately, either an event is dispatched or an exception is thrown: an error
          * event is dispatched if a host was specified, and an exception is thrown if no host was specified. Otherwise,
          * the status of the connection is reported by an event. If the socket is already connected, the existing
-         * connection is closed first. </p>
+         * connection is closed first.
          *
          * @param ip The name or IP address of the host to connect to.
          *			 If no host is specified, the host that is contacted is the host where the calling file resides.
@@ -4867,45 +5847,132 @@ declare namespace samchon.protocol {
     }
 }
 declare namespace samchon.protocol {
+    /**
+     * Server connnector.
+     *
+     * {@link ServerConnector} is a class connecting to remote server who follows Samchon Framework's own protocol and
+     * taking full charge of network communication with the remote server. Create a {@link ServerConnector} instance from
+     * the {@IProtocol listener} and call the {@link connect connect()} method.
+     *
+     * #### [Inherited] {@link IServerConnector}
+     * {@link IServerConnector} is a type of {@link ICommunicator}, specified for server connector classes who connect to
+     * the remote server as a client. {@link IServerConnector} provides {@link connect connection method} and takes full
+     * charge of network communication with the remote server.
+     *
+     * Declare specific type of {@link IServerConnector} from {@link IProtocol listener} and call the
+     * {@link connect connect()} method. Then whenever a replied message comes from the remote system, the message will
+     * be converted to an {@link Invoke} object and the {@link Invoke} object will be shifted to the
+     * {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
+     *
+     * Note that, protocol of this client and remote server must be matched. Thus, before determining specific type of
+     * this {@link IServerConnector}, you've to consider which protocol and type the remote server follows.
+     *
+     * Protocol | Derived Type | Connect to
+     * ---------|--------------|---------------
+     * Samchon Framework's own | {@link ServerConnector} | {@link Server}
+     * Web-socket protocol | {@link WebServerConnector} | {@link WebServer}
+     * SharedWorker | {@link SharedWorkerServerConnector} | {@link SharedWorkerServer}
+     *
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png)
+     *
+     * @see {@link Server}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverconnector)
+     * @author Jeongho Nam <http://samchon.org>
+     */
     class ServerConnector extends Communicator implements IServerConnector {
         /**
          * @inheritdoc
          */
         onConnect: Function;
+        /**
+         * Construct from *listener*.
+         *
+         * @param listener A listener object to listen replied message from newly connected client in
+         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} object.
+         */
         constructor(listener: IProtocol);
         /**
          * @inheritdoc
          */
         connect(ip: string, port: number): void;
+        /**
+         * @hidden
+         */
         private handle_connect(...arg);
     }
 }
 declare namespace samchon.protocol {
     /**
-     * <p> A server connector for web-socket protocol. </p>
+     * A server connector for web-socket protocol.
      *
+     * {@link WebServerConnector} is a class connecting to remote server who follows Web-socket protocol and taking full
+     * charge of network communication with the remote server. Create an {@link WebServerConnector} instance from the
+     * {@IProtocol listener} and call the {@link connect connect()} method.
+     *
+     * #### [Inherited] {@link IServerConnector}
+     * {@link IServerConnector} is a type of {@link ICommunicator}, specified for server connector classes who connect to
+     * the remote server as a client. {@link IServerConnector} provides {@link connect connection method} and takes full
+     * charge of network communication with the remote server.
+     *
+     * Declare specific type of {@link IServerConnector} from {@link IProtocol listener} and call the
+     * {@link connect connect()} method. Then whenever a replied message comes from the remote system, the message will
+     * be converted to an {@link Invoke} class and the {@link Invoke} object will be shifted to the
+     * {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
+     *
+     * Note that, protocol of this client and remote server must be matched. Thus, before determining specific type of
+     * this {@link IServerConnector}, you've to consider which protocol and type the remote server follows.
+     *
+     * Protocol | Derived Type | Connect to
+     * ---------|--------------|---------------
+     * Samchon Framework's own | {@link ServerConnector} | {@link Server}
+     * Web-socket protocol | {@link WebServerConnector} | {@link WebServer}
+     * SharedWorker | {@link SharedWorkerServerConnector} | {@link SharedWorkerServer}
+     *
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png)
+     *
+     * @see {@link WebServer}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverconnector)
      * @author Jeongho Nam <http://samchon.org>
      */
     class WebServerConnector extends WebCommunicator implements IServerConnector {
         /**
-         * <p> A socket for network I/O. </p>
-         *
-         * <p> Note that, {@link socket} is only used in web-browser environment. </p>
+         * @hidden
          */
         private browser_socket_;
         /**
-         * <p> A driver for server connection. </p>
-         *
-         * <p> Note that, {@link node_client} is only used in NodeJS environment. </p>
+         * @hidden
          */
         private node_client_;
         /**
          * @inheritdoc
          */
         onConnect: Function;
+        /**
+         * Construct from *listener*.
+         *
+         * @param listener A listener object to listen replied message from newly connected client in
+         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} object.
+         */
         constructor(listener: IProtocol);
         /**
-         * @inheritdoc
+         * Connect to a web server.
+         *
+         * Connects to a server with specified *host* address, *port* number and *path*. After the connection has
+         * succeeded, callback function {@link onConnect} is called. Listening data from the connected server also begins.
+         * Replied messages from the connected server will be converted to {@link Invoke} classes and will be shifted to
+         * the {@link WebCommunicator.listener listener}'s {@link IProtocol.replyData replyData()} method.
+         *
+         * If the connection fails immediately, either an event is dispatched or an exception is thrown: an error
+         * event is dispatched if a host was specified, and an exception is thrown if no host was specified. Otherwise,
+         * the status of the connection is reported by an event. If the socket is already connected, the existing
+         * connection is closed first.
+         *
+         * @param ip The name or IP address of the host to connect to.
+         *			 If no host is specified, the host that is contacted is the host where the calling file resides.
+         *			 If you do not specify a host, use an event listener to determine whether the connection was
+         *			 successful.
+         * @param port The port number to connect to.
+         * @param path Path of service which you want.
          */
         connect(ip: string, port: number, path?: string): void;
         /**
@@ -4916,18 +5983,92 @@ declare namespace samchon.protocol {
          * @inheritdoc
          */
         sendData(invoke: Invoke): void;
+        /**
+         * @hidden
+         */
         private handle_browser_connect(event);
+        /**
+         * @hidden
+         */
         private handle_browser_message(event);
+        /**
+         * @hidden
+         */
         private handle_node_connect(connection);
     }
 }
 declare namespace samchon.protocol {
+    /**
+     * A server connector for SharedWorker.
+     *
+     * {@link SharedWorkerServerConnector} is a class connecting to SharedWorker and taking full charge of network
+     * communication with the SharedWorker. Create an {@link SharedWorkerServerConnector} instance from the
+     * {@IProtocol listener} and call the {@link connect connect()} method.
+     *
+     * #### Why SharedWorker be a server?
+     * SharedWorker, it allows only an instance (process) to be created whether the SharedWorker is declared in a browser
+     * or multiple browsers. To integrate them, messages are being sent and received. Doesn't it seem like a relationship
+     * between a server and clients? Thus, Samchon Framework consider the SharedWorker as a server and browsers as
+     * clients.
+     *
+     * The class {@link SharedWorkerCommunicator} is designed make such relationship. From now on, SharedWorker is a
+     * {@link SharedWorkerServer server} and {@link SharedWorkerServerConnector browsers} are clients. Integrate the
+     * server and clients with this {@link SharedWorkerCommunicator}.
+     *
+     * #### [Inherited] {@link IServerConnector}
+     * {@link IServerConnector} is a type of {@link ICommunicator}, specified for server connector classes who connect to
+     * the remote server as a client. {@link IServerConnector} provides {@link connect connection method} and takes full
+     * charge of network communication with the remote server.
+     *
+     * Declare specific type of {@link IServerConnector} from {@link IProtocol listener} and call the
+     * {@link connect connect()} method. Then whenever a replied message comes from the remote system, the message will
+     * be converted to an {@link Invoke} class and the {@link Invoke} object will be shifted to the
+     * {@link IProtocol listener}'s {@link IProtocol.replyData IProtocol.replyData()} method.
+     *
+     * Note that, protocol of this client and remote server must be matched. Thus, before determining specific type of
+     * this {@link IServerConnector}, you've to consider which protocol and type the remote server follows.
+     *
+     * Protocol | Derived Type | Connect to
+     * ---------|--------------|---------------
+     * Samchon Framework's own | {@link ServerConnector} | {@link Server}
+     * Web-socket protocol | {@link WebServerConnector} | {@link WebServer}
+     * SharedWorker | {@link SharedWorkerServerConnector} | {@link SharedWorkerServer}
+     *
+     * ![Class Diagram](http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png)
+     *
+     * @see {@link SharedWorkerServer}, {@link IProtocol}
+     * @handbook [Protocol - Basic Components](https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverconnector)
+     * @author Jeongho Nam <http://samchon.org>
+     */
     class SharedWorkerServerConnector extends SharedWorkerCommunicator implements IServerConnector {
         /**
          * @inheritdoc
          */
         onConnect: Function;
+        /**
+         * Construct from *listener*.
+         *
+         * @param listener A listener object to listen replied message from newly connected client in
+         *				   {@link IProtocol.replyData replyData()} as an {@link Invoke} object.
+         */
         constructor(listener: IProtocol);
+        /**
+         * Connect to a SharedWorker.
+         *
+         * Connects to a server with specified *jstFile* path. If a SharedWorker instance of the *jsFile* is not
+         * constructed yet, then the SharedWorker will be newly constructed. Otherwise the SharedWorker already exists,
+         * then connect to the SharedWorker. After those processes, callback function {@link onConnect} is called.
+         * Listening data from the connected server also begins. Replied messages from the connected server will be
+         * converted to {@link Invoke} classes and will be shifted to the {@link WebCommunicator.listener listener}'s
+         * {@link IProtocol.replyData replyData()} method.
+         *
+         * If the connection fails immediately, either an event is dispatched or an exception is thrown: an error
+         * event is dispatched if a host was specified, and an exception is thrown if no host was specified. Otherwise,
+         * the status of the connection is reported by an event. If the socket is already connected, the existing
+         * connection is closed first.
+         *
+         * @param jsFile Path of JavaScript file to execute who defines SharedWorker.
+         */
         connect(jsFile: string): void;
     }
 }
@@ -4951,57 +6092,69 @@ declare namespace samchon.protocol {
         type client = any;
     }
 }
-declare namespace samchon.protocol.distributed {
-    class DSInvokeHistory extends InvokeHistory {
-        private system_;
-        private role_;
-        /**
-         * Construct from a DistributedSystem.
-         *
-         * @param system
-         */
-        constructor(system: DistributedSystem);
-        /**
-         * Initilizer Constructor.
-         *
-         * @param system
-         * @param role
-         * @param invoke
-         */
-        constructor(system: DistributedSystem, role: DistributedSystemRole, invoke: Invoke);
-        /**
-         * @inheritdoc
-         */
-        construct(xml: library.XML): void;
-        getSystem(): DistributedSystem;
-        getRole(): DistributedSystemRole;
-        /**
-         * @inheritdoc
-         */
-        toXML(): library.XML;
-    }
-}
-declare namespace samchon.protocol.external {
+declare namespace samchon.templates.distributed {
     /**
-     * <p> A role of an external system. </p>
+     * Master of Distributed Processing System, a server accepting slave clients.
      *
-     * <p> The {@link ExternalSystemRole} class represents a role, <i>what to do</i> in an {@link ExternalSystem}.
-     * Extends this class and writes some methods related to the role. </p>
+     * The {@link DistributedClientArray} is an abstract class, derived from the {@link DistributedSystemArray} class,
+     * opening a server accepting {@link DistributedSystem distributed clients}.
      *
-     * <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
+     * Extends this {@link DistributedClientArray}, overrides {@link createServerBase createServerBase()} to determine
+     * which protocol to follow and {@link createExternalClient createExternalClient()} creating child
+     * {@link DistributedSystem} object. After the extending and overridings, open this server using the
+     * {@liok open open()} method.
+     *
+     * #### [Inherited] {@link DistributedSystemArray}
+     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
+     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
+     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
+     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
+     * requested the *distributed processes*.
+     *
+     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
+     * **distributed process** through the {@link DistributedProcess} object. You can access the
+     * {@link DistributedProcess} object(s) with those methods:
+     *
+     * - {@link hasRole}
+     * - {@link getRole}
+     * - {@link insertRole}
+     * - {@link eraseRole}
+     * - {@link getRoleMap}
+     *
+     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
+     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
+     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
+     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
+     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
      *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
      *		 style="max-width: 100%" />
-     * </a> </p>
+     * </a>
      *
-     * <h4> Proxy Pattern </h4>
-     * <p> The {@link ExternalSystemRole} class can be an <i>logical proxy</i>. In framework within user, which
+     * #### Parallel Process
+     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
+     * a **parallel process**, too.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
+     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * #### Proxy Pattern
+     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
      * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is <i>which can be done</i>. </p>
+     * important. Only interested in user's perspective is *which can be done*.
      *
-     * <p> By using the <i>logical proxy</i>, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
      * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}. </p>
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
      *
      * <ul>
      *	<li>
@@ -5013,20 +6166,2038 @@ declare namespace samchon.protocol.external {
      *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
      *		external system.
      *	</li>
-     *	<li> Those strategy is called <i>Proxy Pattern</i>. </li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
      * </ul>
      *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
      * @author Jeongho Nam <http://samchon.org>
      */
-    abstract class ExternalSystemRole extends Entity implements IProtocol {
+    abstract class DistributedClientArray extends DistributedSystemArray implements external.IExternalClientArray {
         /**
-         * An {@link ExternalSystem external system} containing this {@link ExternalSystemRole role}.
+         * @hidden
+         */
+        private server_base_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method creating {@link IServerBase} object.
+         *
+         * This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
+         * {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
+         * may connect to {@link ExternalClientArray this server} must follow the specified protocol.
+         *
+         * Overrides the {@link createServerBase createServerBase()} method to create and return one of them:
+         *
+         * - {@link ServerBase}
+         * - {@link WebServerBase}
+         * - {@link SharedWorkerServerBase}
+         *
+         * @return A new {@link IServerBase} object.
+         */
+        protected abstract createServerBase(): protocol.IServerBase;
+        /**
+         * Add a newly connected remote client.
+         *
+         * When a {@link IClientDriver remote client} connects to this *master server of parallel processing system*,
+         * then this {@link ParallelClientArray} creates a child {@link ParallelSystem parallel client} object through
+         * the {@link createExternalClient createExternalClient()} method and {@link insert inserts} it.
+         *
+         * @param driver A communicator for external client.
+         */
+        addClient(driver: protocol.IClientDriver): void;
+        /**
+         * (Deprecated) Factory method creating child object.
+         *
+         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
+         *
+         * Note that, the {@link ParallelClientArray} is a server accepting {@link ParallelSystem parallel clients}.
+         * There's no way to creating the {@link ParallelSystem parallel clients} in advance before opening the server.
+         *
+         * @param xml An {@link XML} object represents the child {@link ParallelSystem} object.
+         * @return ```null```
+         */
+        createChild(xml: library.XML): DistributedSystem;
+        /**
+         * Factory method creating {@link DistributedSystem} object.
+         *
+         * The method {@link createExternalClient createExternalClient()} is a factory method creating a child
+         * {@link ParallelSystem} object, that is called whenever a parallel client has connected, by
+         * {@link addClient addClient()}.
+         *
+         * Overrides this {@link createExternalClient} method and creates a type of {@link DistributedSystem} object with
+         * the *driver* that communicates with the parallel client. After the creation, returns the object. Then whenever
+         * a parallel client has connected, matched {@link DistributedSystem} object will be constructed and
+         * {@link insert inserted} into this {@link DistributedSystemArray} object.
+         *
+         * @param driver A communicator with the parallel client.
+         * @return A newly created {@link ParallelSystem} object.
+         */
+        protected abstract createExternalClient(driver: protocol.IClientDriver): DistributedSystem;
+        /**
+         * @inheritdoc
+         */
+        open(port: number): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * Mediator of Distributed Processing System, a server accepting slave clients.
+     *
+     * The {@link DistributedClientArrayMediator} is an abstract class, derived from {@link DistributedSystemArrayMediator}
+     * class, opening a server accepting {@link DistributedSystem distributed clients} as a **master**.
+     *
+     * Extends this {@link DistributedClientArrayMediator}, overrides {@link createServerBase createServerBase()} to
+     * determine which protocol to follow and {@link createExternalClient createExternalClient()} creating child
+     * {@link DistributedSystem} object. After the extending and overridings, open this server using the
+     * {@link open open()} method.
+     *
+     * #### [Inherited] {@link DistributedSystemArrayMediator}
+     * The {@link DistributedSystemArrayMediator} class be a master for its slave systems, and be a slave to its master
+     * system at the same time. This {@link DistributedSystemArrayMediator} be a master system, containing and managing
+     * {@link DistributedSystem} objects, which represent distributed slave systems, by extending
+     * {@link DistributedSystemArray} class. Also, be a slave system through {@link getMediator mediator} object, which is
+     * derived from the {@link SlavSystem} class.
+     *
+     * As a slave, you can specify this {@link DistributedSystemArrayMediator} to be <i>a client slave connecting to master
+     * server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
+     * Overrides the {@link createMediator createMediator()} method and return one of them:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * #### [Inherited] {@link DistributedSystemArray}
+     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
+     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
+     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
+     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
+     * requested the *distributed processes*.
+     *
+     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
+     * **distributed process** through the {@link DistributedProcess} object. You can access the
+     * {@link DistributedProcess} object(s) with those methods:
+     *
+     * - {@link hasRole}
+     * - {@link getRole}
+     * - {@link insertRole}
+     * - {@link eraseRole}
+     * - {@link getRoleMap}
+     *
+     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
+     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
+     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
+     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
+     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Parallel Process
+     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
+     * a **parallel process**, too.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
+     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * #### Proxy Pattern
+     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class DistributedClientArrayMediator extends DistributedSystemArrayMediator implements external.IExternalClientArray {
+        /**
+         * A subrogator of {@link IServer server}'s role instead of this {@link ExternalClientArray}.
+         */
+        private server_base_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method creating {@link IServerBase} object.
+         *
+         * This method {@link createServerBase createServerBase()} determines which protocol is used in this
+         * {@link DistributedClientArrayMediator} object as a **master**. If the protocol is determined, then
+         * {@link DistributedSystem distributed clients} who may connect to {@link DistributedClientArrayMediator this
+         * server} must follow the specified protocol.
+         *
+         * Overrides the {@link createServerBase createServerBase()} method to create and return one of them:
+         *
+         * - {@link ServerBase}
+         * - {@link WebServerBase}
+         * - {@link SharedWorkerServerBase}
+         *
+         * @return A new {@link IServerBase} object.
+         */
+        protected abstract createServerBase(): protocol.IServerBase;
+        /**
+         * Add a newly connected remote client.
+         *
+         * When a {@link IClientDriver remote client} connects to this *master server of distributed processing system*,
+         * then this {@link DistributedClientArrayMediator} creates a child {@link Distributed distributed client} object
+         * through the {@link createExternalClient createExternalClient()} method.
+         *
+         * @param driver A communicator for external client.
+         */
+        addClient(driver: protocol.IClientDriver): void;
+        /**
+         * (Deprecated) Factory method creating child object.
+         *
+         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
+         *
+         * Note that, the {@link DistributedClientArrayMediator} is a server accepting {@link DistributedSystem distributed
+         * clients} as a master. There's no way to creating the {@link DistributedSystem distributed clients} in advance
+         * before opening the server.
+         *
+         * @param xml An {@link XML} object represents the child {@link DistributedSystem} object.
+         * @return null
+         */
+        createChild(xml: library.XML): DistributedSystem;
+        /**
+         * Factory method creating {@link DistributedSystem} object.
+         *
+         * The method {@link createExternalClient createExternalClient()} is a factory method creating a child
+         * {@link DistributedSystem} object, that is called whenever a distributed client has connected, by
+         * {@link addClient addClient()}.
+         *
+         * Overrides this {@link createExternalClient} method and creates a type of {@link DistributedSystem} object with
+         * the *driver* that communicates with the distributed client. After the creation, returns the object. Then whenever
+         * a distributed client has connected, matched {@link DistributedSystem} object will be constructed and
+         * {@link insert inserted} into this {@link DistributedClientArrayMediator} object.
+         *
+         * @param driver A communicator with the distributed client.
+         * @return A newly created {@link DistributedSystem} object.
+         */
+        protected abstract createExternalClient(driver: protocol.IClientDriver): DistributedSystem;
+        /**
+         * @inheritdoc
+         */
+        open(port: number): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * A role of Distributed Processing System.
+     *
+     * The {@link DistributedProcess} is an abstract class who represents a **process**, *SOMETHING TO DISTRIBUTE* in a Distributed
+     * Processing System. Overrides the {@link DistributedProcess} and defines the *SOMETHING TO DISTRIBUTE*.
+     *
+     * Relationship between {@link DistributedSystem} and {@link DistributedProcess} objects are **M: N Associative**.
+     * Unlike {@link ExternalSystemRole}, the {@link DistributedProcess} objects are not belonged to a specific
+     * {@link DistributedSystem} object. The {@link DistributedProcess} objects are belonged to the
+     * {@link DistributedSystemArrayMediator} directly.
+     *
+     * When you need the **distributed process**, then call {@link sendData sendData()}. The {@link sendData} will find
+     * the most idle {@link DistributedSystem slave system} considering not only number of processes on progress, but also
+     * {@link DistributedSystem.getPerformance performance index} of each {@link DistributedSystem} object and
+     * {@link getResource resource index} of this {@link DistributedProcess} object. The {@link Invoke} message
+     * requesting the **distributed process** will be sent to the most idle {@link DistributedSystem slave system}.
+     *
+     * Those {@link DistributedSystem.getPerformance performance index} and {@link getResource resource index} are
+     * revaluated whenever the **distributed process** has completed basis on the execution time.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class DistributedProcess extends protocol.Entity implements protocol.IProtocol {
+        /**
+         * @hidden
+         */
+        private system_array_;
+        /**
+         * A name, represents and identifies this {@link DistributedProcess process}.
+         *
+         * This {@link name} is an identifier represents this {@link DistributedProcess process}. This {@link name} is
+         * used in {@link DistributedSystemArray.getProcess} and {@link DistributedSystemArray.getProcess}, as a key elements.
+         * Thus, this {@link name} should be unique in its parent {@link DistributedSystemArray} object.
+         */
+        protected name: string;
+        /**
+         * @hidden
+         */
+        private progress_list_;
+        /**
+         * @hidden
+         */
+        private history_list_;
+        /**
+         * @hidden
+         */
+        private resource;
+        /**
+         * @hidden
+         */
+        private enforced_;
+        /**
+         * Constrct from parent {@link DistributedSystemArray} object.
+         *
+         * @param systemArray The parent {@link DistributedSystemArray} object.
+         */
+        constructor(systemArray: DistributedSystemArray);
+        /**
+         * Identifier of {@link ParallelProcess} is its {@link name}.
+         */
+        key(): string;
+        /**
+         * Get parent {@link DistributedSystemArray} object.
+         *
+         * @return The parent {@link DistributedSystemArray} object.
+         */
+        getSystemArray(): DistributedSystemArray;
+        /**
+         * Get name, who represents and identifies this process.
+         */
+        getName(): string;
+        /**
+         * Get resource index.
+         *
+         * Get *resource index* that indicates how much this {@link DistributedProcess role} is heavy.
+         *
+         * If this {@link DistributedProcess role} does not have any	{@link Invoke} message had handled, then the
+         * *resource index* will be ```1.0```, which means default and average value between all
+         * {@link DistributedProcess} instances (that are belonged to a same {@link DistributedSystemArray} object).
+         *
+         * You can specify the *resource index* by yourself, but notice that, if the *resource index* is higher than
+         * other {@link DistributedProcess} objects, then this {@link DistributedProcess role} will be ordered to
+         * handle less processes than other {@link DistributedProcess} objects. Otherwise, the *resource index* is
+         * lower than others, of course, much processes will be requested.
+         *
+         * - {@link setResource setResource()}
+         * - {@link enforceResource enforceResource()}
+         *
+         * Unless {@link enforceResource enforceResource()} is called, This *resource index* is **revaluated** whenever
+         * {@link sendData sendData()} is called.
+         *
+         * @return Resource index.
+         */
+        getResource(): number;
+        /**
+         * Set resource index.
+         *
+         * Set *resource index* that indicates how much this {@link DistributedProcess role} is heavy. This
+         * *resource index* can be **revaulated**.
+         *
+         * Note that, initial and average *resource index* of {@link DistributedProcess} objects are ```1.0```. If the
+         * *resource index* is higher than other {@link DistributedProcess} objects, then this
+         * {@link DistributedProcess} will be ordered to handle more processes than other {@link DistributedProcess}
+         * objects. Otherwise, the *resource index* is lower than others, of course, less processes will be requested.
+         *
+         * Unlike {@link enforceResource}, configuring *resource index* by this {@link setResource} allows the
+         * **revaluation**. This **revaluation** prevents wrong valuation from user. For example, you *mis-valuated* the
+         * *resource index*. The {@link DistributedProcess role} is much heavier than any other, but you estimated it
+         * to the lightest one. It looks like a terrible case that causes
+         * {@link DistributedSystemArray entire distributed processing system} to be slower, however, don't mind. The
+         * {@link DistributedProcess role} will the direct to the *propriate resource index* eventually with the
+         * **revaluation**.
+         *
+         * - The **revaluation** is caused by the {@link sendData sendData()} method.
+         *
+         * @param val New resource index, but can be revaluated.
+         */
+        setResource(val: number): void;
+        /**
+         * Enforce resource index.
+         *
+         * Enforce *resource index* that indicates how much heavy the {@link DistributedProcess role is}. The
+         * *resource index* will be fixed, never be **revaluated**.
+         *
+         * Note that, initial and average *resource index* of {@link DistributedProcess} objects are ```1.0```. If the
+         * *resource index* is higher than other {@link DistributedProcess} objects, then this
+         * {@link DistributedProcess} will be ordered to handle more processes than other {@link DistributedProcess}
+         * objects. Otherwise, the *resource index* is lower than others, of course, less processes will be requested.
+         *
+         * The difference between {@link setResource} and this {@link enforceResource} is allowing **revaluation** or not.
+         * This {@link enforceResource} does not allow the **revaluation**. The *resource index* is clearly fixed and
+         * never be changed by the **revaluation**. But you've to keep in mind that, you can't avoid the **mis-valuation**
+         * with this {@link enforceResource}.
+         *
+         * For example, there's a {@link DistributedProcess role} much heavier than any other, but you
+         * **mis-estimated** it to the lightest. In that case, there's no way. The
+         * {@link DistributedSystemArray entire distributed processing system} will be slower by the **mis-valuation**.
+         * By the reason, using {@link enforceResource}, it's recommended only when you can clearly certain the
+         * *resource index*. If you can't certain the *resource index* but want to recommend, then use {@link setResource}
+         * instead.
+         *
+         * @param val New resource index to be fixed.
+         */
+        enforceResource(val: number): void;
+        /**
+         * @hidden
+         */
+        private compute_average_elapsed_time();
+        /**
+         * @inheritdoc
+         */
+        abstract replyData(invoke: protocol.Invoke): void;
+        /**
+         * Send an {@link Invoke} message.
+         *
+         * Sends an {@link Invoke} message requesting a **distributed process**. The {@link Invoke} message will be sent
+         * to the most idle {@link DistributedSystem} object, which represents a slave system, and the most idle
+         * {@link DistributedSystem} object will be returned.
+         *
+         * When the **distributed process** has completed, then the {@link DistributedSystemArray} object will revaluate
+         * {@link getResource resource index} and {@link DistributedSystem.getPerformance performance index} of this
+         * {@link DistributedSystem} and the most idle {@link DistributedSystem} objects basis on the execution time.
+         *
+         * @param invoke An {@link Invoke} message requesting distributed process.
+         * @return The most idle {@link DistributedSystem} object who may send the {@link Invoke} message.
+         */
+        sendData(invoke: protocol.Invoke): DistributedSystem;
+        /**
+         * @hidden
+         */
+        private complete_history(history);
+        /**
+         * @inheritdoc
+         */
+        TAG(): string;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * An external system driver.
+     *
+     * The {@link ExternalSystem} class represents an external system, connected and interact with this system.
+     * {@link ExternalSystem} takes full charge of network communication with the remote, external system have connected.
+     * Replied {@link Invoke} messages from the external system is shifted to and processed in, children elements of this
+     * class, {@link ExternalSystemRole} objects.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Bridge & Proxy Pattern
+     * The {@link ExternalSystem} class can be a *bridge* for *logical proxy*. In framework within user,
+     * which {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Bridge Pattern* and *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ExternalSystem extends protocol.EntityDequeCollection<ExternalSystemRole> implements protocol.IProtocol {
+        /**
+         * The name represents external system have connected.
+         */
+        protected name: string;
+        /**
+         * @hidden
+         */
+        private system_array_;
+        /**
+         * @hidden
+         */
+        private communicator_;
+        /**
+         * Construct from parent {@link ExternalSystemArray}.
+         *
+         * @param systemArray The parent {@link ExternalSystemArray} object.
+         */
+        constructor(systemArray: ExternalSystemArray);
+        /**
+         * Constrct from parent {@link ExternalSystemArray} and communicator.
+         *
+         * @param systemArray The parent {@link ExternalSystemArray} object.
+         * @param communicator Communicator with the remote, external system.
+         */
+        constructor(systemArray: ExternalSystemArray, communicator: protocol.IClientDriver);
+        /**
+         * Default Destructor.
+         *
+         * This {@link destructor destructor()} method is called when the {@link ExternalSystem} object is destructed and
+         * the {@link ExternalSystem} object is destructed when connection with the remote system is closed or this
+         * {@link ExternalSystem} object is {@link ExternalSystemArray.erase erased} from its parent
+         * {@link ExternalSystemArray} object.
+         *
+         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
+         * by those *destruction* cases. Also, if your derived {@link ExternalSystem} class has something to do on the
+         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
+         * Overriding this {@link destructor destructor()}, don't forget to calling ```super.destructor();``` on tail.
+         *
+         * ```typescript
+         * class SomeSystem extends templates.external.ExternalSystem
+         * {
+         *     protected destructor(): void
+         *     {
+         *         // DO SOMETHING
+         *         this.do_something();
+         *
+         *         // CALL SUPER.DESTRUCTOR() ON TAIL. DON'T FORGET THIS
+         *         super.destructor();
+         *     }
+         * }
+         * ```
+         */
+        protected destructor(): void;
+        /**
+         * @hidden
+         */
+        private handle_close();
+        /**
+         * Get parent {@link ExternalSystemArray} object.
+         */
+        getSystemArray(): ExternalSystemArray;
+        /**
+         * Identifier of {@link ExternalSystem} is its {@link name}.
+         *
+         * @return name.
+         */
+        key(): string;
+        /**
+         * Get {@link name}.
+         */
+        getName(): string;
+        /**
+         * @hidden
+         */
+        /**
+         * @hidden
+         */
+        protected communicator: protocol.ICommunicator;
+        /**
+         * Close connection.
+         */
+        close(): void;
+        /**
+         * Send {@link Invoke} message to external system.
+         *
+         * @param invoke An {@link Invoke} message to send.
+         */
+        sendData(invoke: protocol.Invoke): void;
+        /**
+         * Handle an {@Invoke} message has received.
+         *
+         * @param invoke An {@link Invoke} message have received.
+         */
+        replyData(invoke: protocol.Invoke): void;
+        /**
+         * Tag name of the {@link ExternalSystem} in {@link XML}.
+         *
+         * @return *system*.
+         */
+        TAG(): string;
+        /**
+         * Tag name of {@link ExternalSystemRole children elements} belonged to the {@link ExternalSystem} in {@link XML}.
+         *
+         * @return *role*.
+         */
+        CHILD_TAG(): string;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * A driver for a parallel slave system.
+     *
+     * The {@link ParallelSystem} is an abstract class represents a **slave** system in *Parallel Processing System*,
+     * connected with this **master** system. This {@link ParallelSystem} takes full charge of network communication with
+     * the remote, parallel **slave** system has connected.
+     *
+     * When a *parallel process* is requested (by {@link ParallelSystemArray.sendSegementData} or
+     * {@link ParallelSystemArray.sendPieceData}), the number of pieces to be allocated to a {@link ParallelSystem} is
+     * turn on its {@link getPerformance performance index}. Higher {@link getPerformance performance index}, then
+     * more pieces are requested. The {@link getPerformance performance index} is revaluated whenever a *parallel process*
+     * has completed, basic on the execution time and number of pieces. You can sugguest or enforce the
+     * {@link getPerformance performance index} with {@link setPerformance} or {@link enforcePerformance}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Bridge & Proxy Pattern
+     * This class {@link ParallelSystem} is derived from the {@link ExternalSystem} class. Thus, you can take advantage
+     * of the *Bridge & Proxy Pattern* in this {@link ParallelSystem} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Bridge & Proxy Pattern*:
+     *
+     * The {@link ExternalSystem} class can be a *bridge* for *logical proxy*. In framework within user,
+     * which {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Bridge Pattern* and *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ParallelSystem extends external.ExternalSystem {
+        /**
+         * @hidden
+         */
+        private progress_list_;
+        /**
+         * @hidden
+         */
+        private history_list_;
+        /**
+         * @hidden
+         */
+        private exclude_;
+        /**
+         * @hidden
+         */
+        private performance;
+        /**
+         * @hidden
+         */
+        private enforced_;
+        /**
+         * Construct from parent {@link ParallelSystemArray}.
+         *
+         * @param systemArray The parent {@link ParallelSystemArray} object.
+         */
+        constructor(systemArray: ParallelSystemArray);
+        /**
+         * Construct from parent {@link ParallelSystemArray} and communicator.
+         *
+         * @param systemArray The parent {@link ParallelSystemArray} object.
+         * @param communicator A communicator communicates with remote, the external system.
+         */
+        constructor(systemArray: ParallelSystemArray, communicator: protocol.IClientDriver);
+        /**
+         * Default Destructor.
+         *
+         * This {@link destructor destructor()} method is called when the {@link ParallelSystem} object is destructed and
+         * the {@link ParallelSystem} object is destructed when connection with the remote system is closed or this
+         * {@link ParallelSystem} object is {@link ParallelSystemArray.erase erased} from its parent
+         * {@link ParallelSystemArray} object.
+         *
+         * You may think if there're some *parallel processes* have requested but not completed yet, then it would be a
+         * critical problem because the *parallel processes* will not complete forever. Do not worry. The critical problem
+         * does not happen. After the destruction, the remained *parallel processes* will be shifted to and proceeded in
+         * other {@link ParallelSystem} objects.
+         *
+         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
+         * by those *destruction* cases. Also, if your derived {@link ParallelSystem} class has something to do on the
+         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
+         * Overriding this {@link destructor destructor()}, don't forget to calling ```super.destructor();``` on tail.
+         *
+         * ```typescript
+         * class SomeSystem extends protocol.external.ExternalSystem
+         * {
+         *     protected destructor(): void
+         *     {
+         *         // DO SOMETHING
+         *         this.do_something();
+         *
+         *         // CALL SUPER.DESTRUCTOR() ON TAIL. DON'T FORGET THIS
+         *         super.destructor();
+         *     }
+         * }
+         * ```
+         */
+        protected destructor(): void;
+        /**
+         * Get manager of this object.
+         *
+         * @return The parent {@link ParallelSystemArray} object.
+         */
+        getSystemArray(): ParallelSystemArray;
+        /**
+         * Get performance index.
+         *
+         * Get *performance index* that indicates how much fast the remote system is.
+         *
+         * If this {@link ParallelSystem parallel system} does not have any {@link Invoke} message had handled, then the
+         * *performance index* will be ```1.0```, which means default and average value between all {@link ParallelSystem}
+         * instances (that are belonged to a same {@link ParallelSystemArray} object).
+         *
+         * You can specify this *performance index* by yourself but notice that, if the *performance index* is higher
+         * than other {@link ParallelSystem} objects, then this {@link ParallelSystem parallel system} will be ordered to
+         * handle more processes than other {@link ParallelSystem} objects. Otherwise, the *performance index* is lower
+         * than others, of course, less processes will be delivered.
+         *
+         * - {@link setPerformance setPerformance()}
+         * - {@link enforcePerformance enforcePerformance()}
+         *
+         * Unless {@link enforcePerformance enforcePerformance()} is called, This *performance index* is **revaluated**
+         * whenever user calls one of them below.
+         *
+         * - {@link ParallelSystemArray.sendSegmentData ParallelSystemArray.sendSegmentData()}
+         * - {@link ParallelSystemArray.sendPieceData ParallelSystemArray.sendPieceData()}
+         * - {@link DistributedProcess.sendData DistributedProcess.sendData()}.
+         *
+         * @return Performance index.
+         */
+        getPerformance(): number;
+        /**
+         * Set performance index.
+         *
+         * Set *performance index* that indicates how much fast the remote system is. This *performance index* can be
+         * **revaulated**.
+         *
+         * Note that, initial and average *performance index* of {@link ParallelSystem} objects are ```1.0```. If the
+         * *performance index* is higher than other {@link ParallelSystem} objects, then this {@link ParallelSystem} will
+         * be ordered to handle more processes than other {@link ParallelSystem} objects. Otherwise, the
+         * *performance index* is lower than others, of course, less processes will be delivered.
+         *
+         * Unlike {@link enforcePerformance}, configuring *performance index* by this {@link setPerformance} allows
+         * **revaluation**. This **revaluation** prevents wrong valuation from user. For example, you *mis-valuated* the
+         * *performance index*. The remote system is much faster than any other, but you estimated it to the slowest one.
+         * It looks like a terrible case that causes {@link ParallelSystemArray entire parallel systems} to be slower,
+         * however, don't mind. The system will direct to the *propriate performance index* eventually with the
+         * **revaluation** by following methods.
+         *
+         * - {@link ParallelSystemArray.sendSegmentData ParallelSystemArray.sendSegmentData()}
+         * - {@link ParallelSystemArray.sendPieceData ParallelSystemArray.sendPieceData()}
+         * - {@link DistributedProcess.sendData DistributedProcess.sendData()}.
+         *
+         * @param val New performance index, but can be revaluated.
+         */
+        setPerformance(val: number): void;
+        /**
+         * Enforce performance index.
+         *
+         * Enforce *performance index* that indicates how much fast the remote system is. The *performance index* will be
+         * fixed, never be **revaluated**.
+         *
+         * Note that, initial and average *performance index* of {@link ParallelSystem} objects are ```1.0```. If the
+         * *performance index* is higher than other {@link ParallelSystem} objects, then this {@link ParallelSystem} will
+         * be ordered to handle more processes than other {@link ParallelSystem} objects. Otherwise, the
+         * *performance index* is lower than others, of course, less processes will be delivered.
+         *
+         * The difference between {@link setPerformance} and this {@link enforcePerformance} is allowing **revaluation**
+         * or not. This {@link enforcePerformance} does not allow the **revaluation**. The *performance index* is clearly
+         * fixed and never be changed by the **revaluation**. But you've to keep in mind that, you can't avoid the
+         * **mis-valuation** with this {@link enforcePerformance}.
+         *
+         * For example, there's a remote system much faster than any other, but you **mis-estimated** it to the slowest.
+         * In that case, there's no way. The {@link ParallelSystemArray entire parallel systems} will be slower by the
+         * **mis-valuation**. By the reason, using {@link enforcePerformance}, it's recommended only when you can clearly
+         * certain the *performance index*. If you can't certain the *performance index* but want to recommend, then use
+         * {@link setPerformance} instead.
+         *
+         * @param val New performance index to be fixed.
+         */
+        enforcePerformance(val: number): void;
+        /**
+         * @hidden
+         */
+        private send_piece_data(invoke, first, last);
+        /**
+         * @hidden
+         */
+        private _replyData(invoke);
+        /**
+         * @hidden
+         */
+        protected _Report_history(xml: library.XML): void;
+        /**
+         * @hidden
+         */
+        protected _Send_back_history(invoke: protocol.Invoke, history: protocol.InvokeHistory): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * A driver for a distributed slave system.
+     *
+     * The {@link DistributedSystem} is an abstract class represents a **slave** system in *Distributed Processing System*,
+     * connected with this **master** system. This {@link DistributedSystem} takes full charge of network communication
+     * with the remote, distributed **slave** system has connected.
+     *
+     * This {@link DistributedSystem} has a {@link getPerformance performance index} that indicates how much the **slave**
+     * system is fast. The {@link getPerformance performance index} is referenced and revaluated whenever those methods
+     * are called:
+     *
+     * - Requesting a *parallel process*
+     *   - {@link DistributedSystemArray.sendSegmentData}
+     *   - {@link DistributedSystemArray.sendPieceData}
+     * - Requesting a *distributed process*: {@link DistributedProcess.sendData}
+     *
+     * Note that, this {@link DistributedSystem} class derived from the {@link ExternalSystem} class. Thus, this
+     * {@link DistributedSystem} can also have children {@link ExternalSystemRole} objects exclusively. However, the
+     * children {@link ExternalSystemRole roles} objects are different with the {@link DistributedProcess}. The
+     * domestic {@link ExternalSystemRole roles} are belonged to only a specific {@link DistributedSystem} object.
+     * Otherwise, the {@link DistributedProcess} objects are belonged to a {@link DistributedSystemArray} object.
+     * Furthermore, the relationship between this {@link DistributedSystem} and {@link DistributedProcess} classes are
+     * **M: N Associative**.
+     *
+     * Articles     | {@link DistributedProcess}     | {@link ExternalSystemRole}
+     * -------------|--------------------------------|----------------------------
+     * Belonged to  | {@link DistributedSystemArray} | {@link DistributedSystem}
+     * Relationship | M: N Associative               | 1: N Composite
+     * Ownership    | References                     | Exclusive possession
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class DistributedSystem extends parallel.ParallelSystem {
+        /**
+         * Construct from parent {@link DistributedSystemArray}.
+         *
+         * @param systemArray The parent {@link DistributedSystemArray} object.
+         */
+        constructor(systemArray: DistributedSystemArray);
+        /**
+         * Constrct from parent {@link DistributedSystemArray} and communicator.
+         *
+         * @param systemArray The parent {@link DistributedSystemArray} object.
+         * @param communicator A communicator communicates with remote, the external system.
+         */
+        constructor(systemArray: DistributedSystemArray, communicator: protocol.IClientDriver);
+        /**
+         * Factory method creating a {@link ExternalSystemRole child} object.
+         *
+         * In {@link distributed} module, the process class {@link DistributedProcess} is not belonged to a specific
+         * {@link DistributedSystem} object. It only belongs to a {@link DistributedSystemArray} object and has a
+         * **M: N Associative Relationship** between this {@link DistributedSystem} class.
+         *
+         * By that reason, it's the normal case that the {@link DistributedSystem} object does not have any children
+         * {@link ExternalSystemRole} object. Thus, default {@link createChild} returns ```null```.
+         *
+         * However, if you want a {@link DistributedSystem} to have its own domestic {@link ExternalSystemRole} objects
+         * without reference to the {@link DistributedProcess} objects, it is possible. Creates and returns the
+         * domestic {@link ExternalSystemRole} object.
+         *
+         * @param xml {@link XML} represents the {@link ExternalSystemRole child} object.
+         * @return A newly created {@link ExternalSystemRole} object or ```null```.
+         */
+        createChild(xml: library.XML): external.ExternalSystemRole;
+        /**
+         * Get parent {@link DistributedSystemArray} object.
+         *
+         * @return The parent {@link DistributedSystemArray} object.
+         */
+        getSystemArray(): DistributedSystemArray;
+        /**
+         * @hidden
+         */
+        private compute_average_elapsed_time();
+        /**
+         * @inheritdoc
+         */
+        replyData(invoke: protocol.Invoke): void;
+        /**
+         * @hidden
+         */
+        protected _Report_history(xml: library.XML): void;
+        /**
+         * @hidden
+         */
+        protected _Send_back_history(invoke: protocol.Invoke, history: protocol.InvokeHistory): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * An interface for a distributed slave server driver.
+     *
+     * The easiest way to defining a driver for distributed **slave** server is extending {@link DistributedServer} class.
+     * However, if you've to interact with a prallel **slave** system who can be both server and client, them make a class
+     * (let's name it **BaseSystem**) extending the {@link DistributedServer} class. At next, make a new class (now, I name
+     * it **BaseServer**) extending the **BaseSystem** and implements this interface {@link IParallelServer}. Define the
+     * **BaseServer** following those codes on below:
+     *
+     * <ul>
+     *	<li> {@link ExternalServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link ParallelServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/parallel/ParallelServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link DistributedServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/distributed/DistributedServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     * </ul>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IDistributedServer extends DistributedSystem {
+        /**
+         * Connect to external server.
+         */
+        connect(): void;
+    }
+    /**
+     * A driver for distributed slave server.
+     *
+     * The {@link DistributedServer} is an abstract class, derived from the {@link DistributedSystem} class, connecting to
+     * remote, distributed **slave** server. Extends this {@link DistributedServer} class and overrides the
+     * {@link createServerConnector createServerConnector()} method following which protocol the **slave** server uses.
+     *
+     * #### [Inheritdoc] {@link DistributedSystem}
+     * The {@link DistributedSystem} is an abstract class represents a **slave** system in *Distributed Processing System*,
+     * connected with this **master** system. This {@link DistributedSystem} takes full charge of network communication
+     * with the remote, distributed **slave** system has connected.
+     *
+     * This {@link DistributedSystem} has a {@link getPerformance performance index} that indicates how much the **slave**
+     * system is fast. The {@link getPerformance performance index} is referenced and revaluated whenever those methods
+     * are called:
+     *
+     * - Requesting a *parallel process*
+     *   - {@link DistributedSystemArray.sendSegmentData}
+     *   - {@link DistributedSystemArray.sendPieceData}
+     * - Requesting a *distributed process*: {@link DistributedProcess.sendData}
+     *
+     * Note that, this {@link DistributedSystem} class derived from the {@link ExternalSystem} class. Thus, this
+     * {@link DistributedSystem} can also have children {@link ExternalSystemRole} objects exclusively. However, the
+     * children {@link ExternalSystemRole roles} objects are different with the {@link DistributedProcess}. The
+     * domestic {@link ExternalSystemRole roles} are belonged to only a specific {@link DistributedSystem} object.
+     * Otherwise, the {@link DistributedProcess} objects are belonged to a {@link DistributedSystemArray} object.
+     * Furthermore, the relationship between this {@link DistributedSystem} and {@link DistributedProcess} classes are
+     * **M: N Associative**.
+     *
+     * Articles     | {@link DistributedProcess}     | {@link ExternalSystemRole}
+     * -------------|--------------------------------|----------------------------
+     * Belonged to  | {@link DistributedSystemArray} | {@link DistributedSystem}
+     * Relationship | M: N Associative               | 1: N Composite
+     * Ownership    | References                     | Exclusive possession
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class DistributedServer extends DistributedSystem implements external.IExternalServer {
+        /**
+         * IP address of target external system to connect.
+         */
+        protected ip: string;
+        /**
+         * Port number of target external system to connect.
+         */
+        protected port: number;
+        /**
+         * Construct from parent {@link DistributedSystemArray}.
+         *
+         * @param systemArray The parent {@link DistributedSystemArray} object.
+         */
+        constructor(systemArray: DistributedSystemArray);
+        /**
+         * Factory method creating {@link IServerConnector} object.
+         *
+         * The {@link createServerConnector createServerConnector()} is an abstract method creating
+         * {@link IServerConnector} object. Overrides and returns one of them, considering which protocol the slave server
+         * follows:
+         *
+         * - {@link ServerConnector}
+         * - {@link WebServerConnector}
+         * - {@link SharedWorkerServerConnector}
+         *
+         * @return A newly created {@link IServerConnector} object.
+         */
+        protected abstract createServerConnector(): protocol.IServerConnector;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * Master of Distributed Processing System, a client connecting to slave servers.
+     *
+     * The {@link DistributedServerArray} is an abstract class, derived from the {@link DistributedSystemArray} class,
+     * connecting to {@link IDistributedServer distributed servers}.
+     *
+     * Extends this {@link DistributedServerArray} and overrides {@link createChild createChild()} method creating child
+     * {@link IDistributedServer} object. After the extending and overriding, construct children {@link IDistributedServer}
+     * objects and call the {@link connect connect()} method.
+     *
+     * #### [Inherited] {@link DistributedSystemArray}
+     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
+     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
+     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
+     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
+     * requested the *distributed processes*.
+     *
+     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
+     * **distributed process** through the {@link DistributedProcess} object. You can access the
+     * {@link DistributedProcess} object(s) with those methods:
+     *
+     * - {@link hasRole}
+     * - {@link getRole}
+     * - {@link insertRole}
+     * - {@link eraseRole}
+     * - {@link getRoleMap}
+     *
+     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
+     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
+     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
+     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
+     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Parallel Process
+     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
+     * a **parallel process**, too.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
+     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * #### Proxy Pattern
+     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class DistributedServerArray extends DistributedSystemArray implements external.IExternalServerArray {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * Mediator of Distributed Processing System, a client connecting to slave servers.
+     *
+     * The {@link DistributedServerArrayMediator} is an abstract class, derived from {@link DistributedSystemArrayMediator}
+     * class, connecting to {@link IDistributedServer distributed servers}.
+     *
+     * Extends this {@link DistributedServerArrayMediator} and overrides {@link createChild createChild()} method creating
+     * child {@link IDistributedServer} object. After the extending and overriding, construct children
+     * {@link IDistributedServer} objects and call the {@link connect connect()} method.
+     *
+     * #### [Inherited] {@link DistributedSystemArrayMediator}
+     * The {@link DistributedSystemArrayMediator} class be a master for its slave systems, and be a slave to its master
+     * system at the same time. This {@link DistributedSystemArrayMediator} be a master system, containing and managing
+     * {@link DistributedSystem} objects, which represent distributed slave systems, by extending
+     * {@link DistributedSystemArray} class. Also, be a slave system through {@link getMediator mediator} object, which is
+     * derived from the {@link SlavSystem} class.
+     *
+     * As a slave, you can specify this {@link DistributedSystemArrayMediator} to be <i>a client slave connecting to master
+     * server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
+     * Overrides the {@link createMediator createMediator()} method and return one of them:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * #### [Inherited] {@link DistributedSystemArray}
+     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
+     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
+     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
+     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
+     * requested the *distributed processes*.
+     *
+     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
+     * **distributed process** through the {@link DistributedProcess} object. You can access the
+     * {@link DistributedProcess} object(s) with those methods:
+     *
+     * - {@link hasRole}
+     * - {@link getRole}
+     * - {@link insertRole}
+     * - {@link eraseRole}
+     * - {@link getRoleMap}
+     *
+     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
+     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
+     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
+     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
+     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Parallel Process
+     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
+     * a **parallel process**, too.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
+     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * #### Proxy Pattern
+     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class DistributedServerArrayMediator extends DistributedSystemArrayMediator implements external.IExternalServerArray {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * Master of Distributed Processing System, be a server and client at the same time.
+     *
+     * The {@link DistributedServerClientArray} is an abstract class, derived from the {@link DistributedSystemArray}
+     * class, opening a server accepting {@link Distributed distributed clients} and being a client connecting to
+     * {@link IDistributedServer distributed servers} at the same time.
+     *
+     * Extends this {@link DistributedServerClientArray} and overrides below methods. After the overridings, open server
+     * with {@link open open()} method and connect to {@link IDistributedServer distributed servers} through the
+     * {@link connect connect()} method.
+     *
+     * - {@link createServerBase createServerBase()}
+     * - {@link createExternalClient createExternalClient()}
+     * - {@link createExternalServer createExternalServer()}
+     *
+     * #### [Inherited] {@link DistributedSystemArray}
+     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
+     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
+     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
+     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
+     * requested the *distributed processes*.
+     *
+     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
+     * **distributed process** through the {@link DistributedProcess} object. You can access the
+     * {@link DistributedProcess} object(s) with those methods:
+     *
+     * - {@link hasRole}
+     * - {@link getRole}
+     * - {@link insertRole}
+     * - {@link eraseRole}
+     * - {@link getRoleMap}
+     *
+     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
+     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
+     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
+     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
+     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Parallel Process
+     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
+     * a **parallel process**, too.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
+     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * #### Proxy Pattern
+     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class DistributedServerClientArray extends DistributedClientArray implements external.IExternalServerClientArray {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method of a child Entity.
+         *
+         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A new child Entity via {@link createExternalServer createExternalServer()}.
+         */
+        createChild(xml: library.XML): DistributedSystem;
+        /**
+         * Factory method creating an {@link IDistributedServer} object.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A newly created {@link IDistributedServer} object.
+         */
+        protected abstract createExternalServer(xml: library.XML): IDistributedServer;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * Mediator of Distributed Processing System, be a server and client at the same time as a **master**.
+     *
+     * The {@link DistributedServerClientArrayMediator} is an abstract class, derived from the
+     * {@link DistributedSystemArrayMediator} class, opening a server accepting {@link DistributedSystem distributed
+     * clients} and being a client connecting to {@link IDistributedServer distributed servers} at the same time.
+     *
+     * Extends this {@link DistributedServerClientArrayMediator} and overrides below methods. After the overridings, open
+     * server with {@link open open()} method and connect to {@link IDistributedServer distributed servers} through the
+     * {@link connect connect()} method.
+     *
+     * - {@link createServerBase createServerBase()}
+     * - {@link createExternalClient createExternalClient()}
+     * - {@link createExternalServer createExternalServer()}
+     *
+     * #### [Inherited] {@link DistributedSystemArrayMediator}
+     * The {@link DistributedSystemArrayMediator} class be a master for its slave systems, and be a slave to its master
+     * system at the same time. This {@link DistributedSystemArrayMediator} be a master system, containing and managing
+     * {@link DistributedSystem} objects, which represent distributed slave systems, by extending
+     * {@link DistributedSystemArray} class. Also, be a slave system through {@link getMediator mediator} object, which is
+     * derived from the {@link SlavSystem} class.
+     *
+     * As a slave, you can specify this {@link DistributedSystemArrayMediator} to be <i>a client slave connecting to master
+     * server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
+     * Overrides the {@link createMediator createMediator()} method and return one of them:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * #### [Inherited] {@link DistributedSystemArray}
+     * The {@link DistributedSystemArray} is an abstract class containing and managing remote distributed **slave** system
+     * drivers, {@link DistributedSystem} objects. Within framework of network, {@link DistributedSystemArray} represents
+     * your system, a **Master** of *Distributed Processing System* that requesting *distributed process* to **slave**
+     * systems and the children {@link DistributedSystem} objects represent the remote **slave** systems, who is being
+     * requested the *distributed processes*.
+     *
+     * The {@link DistributedSystemArray} contains {@link DistributedProcess} objects directly. You can request a
+     * **distributed process** through the {@link DistributedProcess} object. You can access the
+     * {@link DistributedProcess} object(s) with those methods:
+     *
+     * - {@link hasRole}
+     * - {@link getRole}
+     * - {@link insertRole}
+     * - {@link eraseRole}
+     * - {@link getRoleMap}
+     *
+     * When you need the **distributed process**, call the {@link DistributedProcess.sendData} method. Then the
+     * {@link DistributedProcess} will find the most idle {@link DistributedSystem} object who represents a distributed
+     * **slave **system. The {@link Invoke} message will be sent to the most idle {@link DistributedSystem} object. When
+     * the **distributed process** has completed, then {@link DistributedSystem.getPerformance performance index} and
+     * {@link DistributedProcess.getResource resource index} of related objects will be revaluated.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Parallel Process
+     * This {@link DistributedSystemArray} class is derived from the {@link ParallelSystemArray} class, so you can request
+     * a **parallel process**, too.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices will
+     * be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * #### Proxy Pattern
+     * This class {@link DistributedSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link DistributedSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class DistributedServerClientArrayMediator extends DistributedClientArrayMediator implements external.IExternalServerClientArray {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method of a child Entity.
+         *
+         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A new child Entity via {@link createExternalServer createExternalServer()}.
+         */
+        createChild(xml: library.XML): DistributedSystem;
+        /**
+         * Factory method creating an {@link IDistributedServer} object.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A newly created {@link IDistributedServer} object.
+         */
+        protected abstract createExternalServer(xml: library.XML): IDistributedServer;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.distributed {
+    /**
+     * History of an {@link Invoke} message.
+     *
+     * The {@link PRInvokeHistory} is a class archiving history log of an {@link Invoke} message which requests the
+     * *distributed process*, created whenever {@link DistributedProcess.sendData} is called.
+     *
+     * When the *distributed process* has completed, then {@link complete complete()} is called and the *elapsed time* is
+     * determined. The elapsed time is utilized for computation of {@link DistributedSystem.getPerformance performance index}
+     * and {@link DistributedProcess.getResource resource index} of related objects.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_distributed_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class DSInvokeHistory extends protocol.InvokeHistory {
+        /**
+         * @hidden
+         */
+        private system_;
+        /**
+         * @hidden
+         */
+        private process_;
+        /**
+         * Construct from a DistributedSystem.
+         *
+         * @param system The {@link DistributedSystem} object who sent the {@link Invoke} message.
+         */
+        constructor(system: DistributedSystem);
+        /**
+         * Initilizer Constructor.
+         *
+         * @param system The {@link DistributedSystem} object who sent the {@link Invoke} message.
+         * @param process The {@link DistributedProcess} object who sent the {@link Invoke} message.
+         * @param invoke An {@link Invoke} message requesting the *distributed process*.
+         */
+        constructor(system: DistributedSystem, process: DistributedProcess, invoke: protocol.Invoke);
+        /**
+         * @inheritdoc
+         */
+        construct(xml: library.XML): void;
+        /**
+         * Get the related {@link DistributedSystem} object.
+         */
+        getSystem(): DistributedSystem;
+        /**
+         * Get the related {@link DistributedProcess} object.
+         */
+        getProcess(): DistributedProcess;
+        /**
+         * @inheritdoc
+         */
+        toXML(): library.XML;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * An interface for an {@link ExternalSystemArray} accepts {@link ExternalSystem external clients} as a
+     * {@link IServer server}.
+     *
+     * The easiest way to defining an {@link ExternalSystemArray} who opens server and accepts
+     * {@link ExternalSystem external clients} is to extending one of below, who are derived from this interface
+     * {@link IExternalClientArray}. However, if you can't specify an {@link ExternalSystemArray} to be whether server or
+     * client, then make a class (let's name it as **BaseSystemArray**) extending {@link ExternalSystemArray} and make
+     * a new class (now, I name it **BaseClientArray**) extending **BaseSystemArray** and implementing this
+     * interface {@link IExternalClientArray}. Define the **BaseClientArray** following those codes on below:
+     *
+     * <ul>
+     *	<li> {@link ExternalClientArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalClientArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link ParallelClientArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/ParallelClientArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link DistributedClientArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/DistributedClientArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IExternalClientArray extends ExternalSystemArray, protocol.IServer {
+    }
+    /**
+     * An array and manager of {@link ExternalSystem external clients} as a server.
+     *
+     * The {@link ExternalClientArray} is an abstract class, derived from the {@link ExternalSystemArray} class, opening
+     * a server accepting {@link ExternalSystem external clients}.
+     *
+     * Extends this {@link ExternalClientArray}, overrides {@link createServerBase createServerBase()} to determine which
+     * protocol to follow and {@link createExternalClient createExternalClient()} creating child {@link ExternalSystem}
+     * object. After the extending and overridings, open this server using the {@link open open()} method.
+     *
+     * #### [Inherited] {@link ExternalSystemArray}
+     * The {@link ExternalSystemArray} is an abstract class containing and managing external system drivers,
+     * {@link ExternalSystem} objects. Within framewokr of network, {@link ExternalSystemArray} represents your system
+     * and children {@link ExternalSystem} objects represent remote, external systems connected with your system.
+     * With this {@link ExternalSystemArray}, you can manage multiple external systems as a group.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Proxy Pattern
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ExternalClientArray extends ExternalSystemArray implements IExternalClientArray {
+        /**
+         * @hidden
+         */
+        private server_base_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method creating {@link IServerBase} object.
+         *
+         * This method {@link createServerBase createServerBase()} determines which templates is used in this server,
+         * {@link ExternalClientArray}. If the templates is determined, then {@link ExternalSystem external clients} who
+         * may connect to {@link ExternalClientArray this server} must follow the specified templates.
+         *
+         * Creates and returns one of them:
+         * <ul>
+         *	<li> {@link ServerBase} </li>
+         *	<li> {@link WebServerBase} </li>
+         *	<li> {@link SharedWorkerServerBase} </li>
+         * </ul>
+         *
+         * @return A new {@link IServerBase} object.
+         */
+        protected abstract createServerBase(): protocol.IServerBase;
+        /**
+         * Add a newly connected remote client.
+         *
+         * When a {@link IClientDriver remote client} connects to this *server* {@link ExternalClientArray} object,
+         * then this {@link ExternalClientArray} creates a child {@link ExternalSystem external client} object through
+         * the {@link createExternalClient createExternalClient()} method and {@link insert inserts} it.
+         *
+         * @param driver A communicator for external client.
+         */
+        addClient(driver: protocol.IClientDriver): void;
+        /**
+         * (Deprecated) Factory method creating child object.
+         *
+         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
+         *
+         * Note that, the {@link ExternalClientArray} is a server accepting {@link ExternalSystem external clients}.
+         * There's no way to creating the {@link ExternalSystem external clients} in advance before opening the server.
+         *
+         * @param xml An {@link XML} object represents the child {@link ExternalSystem} object.
+         * @return null
+         */
+        createChild(xml: library.XML): ExternalSystem;
+        /**
+         * Factory method creating a child {@link ExternalSystem} object.
+         *
+         * @param driver A communicator with connected client.
+         * @return A newly created {@link ExternalSystem} object.
+         */
+        protected abstract createExternalClient(driver: protocol.IClientDriver): ExternalSystem;
+        /**
+         * @inheritdoc
+         */
+        open(port: number): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * An interface for an external server driver.
+     *
+     * The easiest way to defining an external server driver is to extending one of below, who are derived from this
+     * interface {@link IExternalServer}. However, if you've to interact with an external system who can be both server
+     * and client, then make a class (let's name it as **BaseSystem**) extending {@link ExternalSystem} and make a
+     * new class (now, I name it **BaseServer**) extending **BaseSystem** and implementing this interface
+     * {@link IExternalServer}. Define the **BaseServer** following those codes on below:
+     *
+     * <ul>
+     *	<li> {@link ExternalServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link ParallelServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/parallel/ParallelServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link DistributedServer}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/distributed/DistributedServer.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IExternalServer extends ExternalSystem {
+        /**
+         * Connect to external server.
+         */
+        connect(): void;
+    }
+    /**
+     * An external server driver.
+     *
+     * The {@link ExternalServer} is an abstract class, derived from the {@link ExternalSystem} class, connecting to
+     * remote, external server. Extends this {@link ExternalServer} class and overrides the
+     * {@link createServerConnector createServerConnector()} method following which protocol the external server uses.
+     *
+     * #### [Inherited] {@link ExternalSystem}
+     * The {@link ExternalSystem} class represents an external system, connected and interact with this system.
+     * {@link ExternalSystem} takes full charge of network communication with the remote, external system have connected.
+     * Replied {@link Invoke} messages from the external system is shifted to and processed in, children elements of this
+     * class, {@link ExternalSystemRole} objects.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Bridge & Proxy Pattern
+     * The {@link ExternalSystem} class can be a *bridge* for *logical proxy*. In framework within user,
+     * which {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Bridge Pattern* and *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ExternalServer extends ExternalSystem implements IExternalServer {
+        /**
+         * IP address of target external system to connect.
+         */
+        protected ip: string;
+        /**
+         * Port number of target external system to connect.
+         */
+        protected port: number;
+        /**
+         * Construct from parent {@link ExternalSystemArray}.
+         *
+         * @param systemArray The parent {@link ExternalSystemArray} object.
+         */
+        constructor(systemArray: ExternalSystemArray);
+        /**
+         * Factory method creating {@link IServerConnector} object.
+         *
+         * The {@link createServerConnector createServerConnector()} is an abstract method creating
+         * {@link IServerConnector} object. Overrides and returns one of them, considering which templates the external
+         * system follows:
+         *
+         * - {@link ServerConnector}
+         * - {@link WebServerConnector}
+         * - {@link SharedWorkerServerConnector}
+         *
+         * @return A newly created {@link IServerConnector} object.
+         */
+        protected abstract createServerConnector(): protocol.IServerConnector;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * An interface for an {@link ExternalSystemArray} connects to {@link IExternalServer external servers} as a
+     * **client**.
+     *
+     * The easiest way to defining an {@link ExternalSystemArray} who connects to
+     * {@link IExternalServer external servers} is to extending one of below, who are derived from this interface
+     * {@link IExternalServerArray}. However, if you can't specify an {@link ExternalSystemArray} to be whether server or
+     * client, then make a class (let's name it as **BaseSystemArray**) extending {@link ExternalSystemArray} and make
+     * a new class (now, I name it **BaseServerArray**) extending **BaseSystemArray** and implementing this
+     * interface {@link IExternalServerArray}. Define the **BaseServerArray** following those codes on below:
+     *
+     * <ul>
+     *	<li> {@link ExternalServerArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServerArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link ParallelServerArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/ParallelServerArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link DistributedServerArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/DistributedServerArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IExternalServerArray extends ExternalSystemArray {
+        /**
+         * Connect to {@link IExternalServer external servers}.
+         *
+         * This method calls children elements' method {@link IExternalServer.connect} gradually.
+         */
+        connect(): void;
+    }
+    /**
+     * An array and manager of {@link IExternalServer external servers}.
+     *
+     * The {@link ExternalServerArray} is an abstract class, derived from the {@link ExternalSystemArray} class,
+     * connecting to {@link IExternalServer external servers}.
+     *
+     * Extends this {@link ExternalServerArray} and overrides {@link createChild createChild()} method creating child
+     * {@link IExternalServer} object. After the extending and overriding, construct children {@link IExternalServer}
+     * objects and call the {@link connect connect()} method.
+     *
+     * #### [Inherited] {@link ExternalSystemArray}
+     * The {@link ExternalSystemArray} is an abstract class containing and managing external system drivers,
+     * {@link ExternalSystem} objects. Within framewokr of network, {@link ExternalSystemArray} represents your system
+     * and children {@link ExternalSystem} objects represent remote, external systems connected with your system.
+     * With this {@link ExternalSystemArray}, you can manage multiple external systems as a group.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Proxy Pattern
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ExternalServerArray extends ExternalSystemArray {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * An interface for an {@link ExternalSystemArray} accepts {@link ExternalSystem external clients} as a
+     * {@link IServer server} and connects to {@link IExternalServer} as **client**, at the same time.
+     *
+     * The easiest way to defining an {@link IExternalServerClientArray} who opens server, accepts
+     * {@link ExternalSystem external clients} and connects to {@link IExternalServer external servers} is to extending
+     * one of below, who are derived from this interface {@link IExternalServerClientArray}. However, if you can't
+     * specify an {@link ExternalSystemArray} to be whether server or client or even can both them, then make a class
+     * (let's name it as **BaseSystemArray**) extending {@link ExternalSystemArray} and make a new class (now, I name
+     * it **BaseServerClientArray**) extending **BaseSystemArray** and implementing this interface
+     * {@link IExternalServerClientArray}. Define the **BaseServerClientArray** following those codes on below:
+     *
+     * <ul>
+     *	<li> {@link ExternalServerClientArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServerClientArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link ParallelServerClientArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/ParallelServerClientArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     *	<li> {@link DistributedServerClientArray}:
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/master/DistributedServerClientArray.ts"
+     *		   target="_blank"> View source code on GitHub </a>
+     *	</li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IExternalServerClientArray extends IExternalServerArray, IExternalClientArray {
+    }
+    /**
+     * An array and manager of {@link IExternalServer external servers} and {@link ExternalSystem external clients}.
+     *
+     * The {@link ExternalServerClientArray} is an abstract class, derived from the {@link ExternalSystemArray} class,
+     * opening a server accepting {@link ExternalSystem external clients} and being a client connecting to
+     * {@link IExternalServer external servers} at the same time.
+     *
+     * Extends this {@link ExternalServerClientArray} and overrides below methods. After the overridings, open server
+     * with {@link open open()} method and connect to {@link IExternalServer external servers} through the
+     * {@link connect connect()} method.
+     *
+     * - {@link createServerBase createServerBase()}
+     * - {@link createExternalClient createExternalClient()}
+     * - {@link createExternalServer createExternalServer()}
+     *
+     * #### [Inherited] {@link ExternalSystemArray}
+     * The {@link ExternalSystemArray} is an abstract class containing and managing external system drivers,
+     * {@link ExternalSystem} objects. Within framewokr of network, {@link ExternalSystemArray} represents your system
+     * and children {@link ExternalSystem} objects represent remote, external systems connected with your system.
+     * With this {@link ExternalSystemArray}, you can manage multiple external systems as a group.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Proxy Pattern
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ExternalServerClientArray extends ExternalClientArray implements IExternalServerClientArray {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method of a child Entity.
+         *
+         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A new child Entity via {@link createExternalServer createExternalServer()}.
+         */
+        createChild(xml: library.XML): ExternalSystem;
+        /**
+         * Factory method creating an {@link IExternalServer} object.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A newly created {@link IExternalServer} object.
+         */
+        protected abstract createExternalServer(xml: library.XML): IExternalServer;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.external {
+    /**
+     * A role of an external system.
+     *
+     * The {@link ExternalSystemRole} class represents a role, *WHAT TO DO*. Extends the {@link ExternalSystemRole} class
+     * and overrides {@link replyData replyData()} to define the *WHAT TO DO*. And assign this {@link ExternalSystemRole}
+     * object to related {@link ExternalSystem} object.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_external_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Proxy Pattern
+     * The {@link ExternalSystemRole} class can be an *logical proxy*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem} object, via {@link ExternalSystemArray.getRole ExternalSystemArray.getRole()}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - External System](https://github.com/samchon/framework/wiki/TypeScript-Templates-External_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ExternalSystemRole extends protocol.Entity implements protocol.IProtocol {
+        /**
+         * @hidden
          */
         private system;
         /**
-         * <p> A name, represents and identifies this {@link ExternalSystemRole role}. </p>
+         * A name, represents and identifies this {@link ExternalSystemRole role}.
          *
-         * <p> This {@link name} is an identifier represents this {@link ExternalSystemRole role}. This {@link name} is
+         * This {@link name} is an identifier represents this {@link ExternalSystemRole role}. This {@link name} is
          * used in {@link ExternalSystemArray.getRole} and {@link ExternalSystem.get}, as a key elements. Thus, this
          * {@link name} should be unique in an {@link ExternalSystemArray}.
          */
@@ -5042,7 +8213,16 @@ declare namespace samchon.protocol.external {
          */
         key(): string;
         /**
-         * Get external system, this role is belonged to.
+         * Get grandparent {@link ExternalSystemArray}.
+         *
+         * Get the grandparent {@link ExternalSystemArray} object through this parent {@link ExternalSystem},
+         * {@link ExternalSystem.getSystemArray ExternalSystem.getSystemArray()}.
+         *
+         * @return The grandparent {@link ExternalSystemArray} object.
+         */
+        getSystemArray(): ExternalSystemArray;
+        /**
+         * Get parent {@link ExternalSystemRole} object.
          */
         getSystem(): ExternalSystem;
         /**
@@ -5050,76 +8230,544 @@ declare namespace samchon.protocol.external {
          */
         getName(): string;
         /**
-         * Send an {@link Invoke} message to the external system via {@link system}.
+         * Send an {@link Invoke} message.
+         *
+         * Sends an {@link Invoke} message to remote system through the parent {@link ExternalSystem} object.
          *
          * @param invoke An {@link Invoke} message to send to the external system.
          */
-        sendData(invoke: Invoke): void;
+        sendData(invoke: protocol.Invoke): void;
         /**
-         * <p> Handle replied {@link Invoke message} from the {@link system external system} belonged to. </p>
+         * Handle replied {@link Invoke} message.
          *
-         * <p> This {@link replyData replyData()} will call a member method named following {@link Invoke.listener}.
-         * in the <i>invoke</i>. </p>
+         * {@link ExternalSystemRole.replyData ExternalSystemRole.replyData()} is an abstract method handling a replied
+         * {@link Invoke message} gotten from remote system via parent {@link ExternalSystem} object. Overrides this
+         * method and defines the *WHAT TO DO* with the {@link Invoke message}.
          *
-         * @param invoke An {@link Invoke} message received from the {@link system external system}.
+         * @param invoke An {@link Invoke} message received from the {@link ExternalSystem external system}.
          */
-        replyData(invoke: Invoke): void;
+        abstract replyData(invoke: protocol.Invoke): void;
         /**
          * Tag name of the {@link ExternalSytemRole} in {@link XML}.
          *
-         * @return <i>role</i>.
+         * @return *role*.
          */
         TAG(): string;
     }
 }
-declare namespace samchon.protocol.distributed {
-    abstract class DistributedSystemRole extends external.ExternalSystemRole {
-        private system_array_;
-        private progress_list_;
-        private history_list_;
-        protected performance: number;
-        constructor(systemArray: DistributedSystemArray);
-        getSystemArray(): DistributedSystemArray;
-        getPerformance(): number;
+declare namespace samchon.templates.slave {
+    abstract class SlaveSystem implements protocol.IProtocol {
+        /**
+         * @hidden
+         */
+        protected communicator_: protocol.ICommunicator;
+        /**
+         * Default Constructor.
+         */
+        constructor();
         sendData(invoke: protocol.Invoke): void;
-        _Report_history(history: DSInvokeHistory): void;
+        /**
+         * @hidden
+         */
+        protected _replyData(invoke: protocol.Invoke): void;
+        replyData(invoke: protocol.Invoke): void;
     }
 }
-/**
- * [[include: https://raw.githubusercontent.com/samchon/framework/master/handbook/TypeScript-Protocol-External_System.md]]
- */
-declare namespace samchon.protocol.external {
-        /**
-     * <p> An array and manager of {@link ExternalSystem external systems}. </p>
-         *
-     * <p> {@link ExternalSystemArray} is an abstract class contains and manages external system drivers,
-     * {@link ExternalSystem} objects. You can specify this {@link ExternalSystemArray} to be a server accepting
-     * {@link ExternalSystem external clients} or a client connecting to {@link IExternalServer external servers}. Even
-     * both of them is also possible. </p>
+declare namespace samchon.templates.parallel {
+    /**
+     * A mediator, the master driver.
      *
-     * <ul>
-     *	<li> A server accepting external clients: {@link IExternalClientArray} </li>
-     *	<li> A client connecting to external servers: {@link IExternalServerArray} </li>
-     *	<li>
-     *		Accepts external clients & Connects to external servers at the same time:
-     *		{@link IExternalServerClientArray}
-     *	</li>
-     * </ul>
+     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
+     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
      *
-     * <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
+     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
+     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
+     * type and protocol the **master** system follows:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
+     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
+     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
+     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
+     * result to its **master**.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
      *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
      *		 style="max-width: 100%" />
-     * </a> </p>
+     * </a>
      *
-     * <h4> Proxy Pattern </h4>
-     * <p> The {@link ExternalSystemArray} class can use <i>Proxy Pattern</i>. In framework within user, which
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
+     *			 [Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class MediatorSystem extends slave.SlaveSystem {
+        /**
+         * @hidden
+         */
+        private system_array_;
+        /**
+         * @hidden
+         */
+        private progress_list_;
+        /**
+         * Construct from parent {@link ParallelSystemArrayMediator} object.
+         *
+         * @param systemArray The parent {@link ParallelSystemArrayMediator} object.
+         */
+        constructor(systemArray: ParallelSystemArrayMediator);
+        /**
+         * Construct from parent {@link DistributedSystemArrayMediator} object.
+         *
+         * @param systemArray The parent {@link DistributedSystemArrayMediator} object.
+         */
+        constructor(systemArray: distributed.DistributedSystemArrayMediator);
+        /**
+         * Start interaction.
+         *
+         * The {@link start start()} is an abstract method starting interaction with the **master** system. If the
+         * **master** is a server, then connects to the **master**. Otherwise, the **master** is client, then this
+         * {@link MediatorSystem} object wil open a server accepting the **master**.
+         */
+        abstract start(): void;
+        /**
+         * Get parent {@link ParallelSystemArrayMediator} object.
+         */
+        getSystemArray(): ParallelSystemArrayMediator | distributed.DistributedSystemArrayMediator;
+        /**
+         * @hidden
+         */
+        private complete_history(uid);
+        /**
+         * @hidden
+         */
+        protected _replyData(invoke: protocol.Invoke): void;
+        /**
+         * @inheritdoc
+         */
+        replyData(invoke: protocol.Invoke): void;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * A mediator server, driver for the master client.
+     *
+     * The {@link MediatorServer} is a class opening a server accepting the **master** client, following the protocol of
+     * Samchon Framework's own.
+     *
+     * #### [Inherited] {@link MediatorSystem}
+     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
+     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
+     *
+     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
+     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
+     * type and protocol the **master** system follows:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
+     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
+     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
+     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
+     * result to its **master**.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
+     *			 [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class MediatorServer extends MediatorSystem implements slave.ISlaveServer {
+        /**
+         * @hidden
+         */
+        private server_base_;
+        /**
+         * @hidden
+         */
+        private port;
+        /**
+         * Initializer Constructor.
+         *
+         * @param systemArray The parent {@link ParallelSystemArrayMediator} object.
+         * @param port Port number of server to open.
+         */
+        constructor(systemArray: ParallelSystemArrayMediator, port: number);
+        /**
+         * Initializer Constructor.
+         *
+         * @param systemArray The parent {@link DistributedSystemArrayMediator} object.
+         * @param port Port number of server to open.
+         */
+        constructor(systemArray: distributed.DistributedSystemArrayMediator, port: number);
+        /**
+         * Factory method creating {@link IServerBase} object.
+         *
+         * This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
+         * {@link MediatorServer}. Note that, **slave** (this {@link MediatorServer} object) must follow the **master**'s
+         * protocol.
+         *
+         * Overrides and return one of them considering the which protocol to follow:
+         *
+         * - {@link ServerBase}
+         * - {@link WebServerBase}
+         * - {@link SharedWorkerServerBase}
+         */
+        protected createServerBase(): protocol.IServerBase;
+        /**
+         * Add a newly connected remote client.
+         *
+         * {@link MediatorServer} represents a **slave** dedicating to its **master**. In that reason, the
+         * {@link MediatorServer} does not accept multiple **master** clients. It accepts only one. Thus, *listener* of
+         * the *communicator* is {@link MediatorSystem} object, itself.
+         *
+         * @param driver A communicator with remote client.
+         */
+        addClient(driver: protocol.IClientDriver): void;
+        /**
+         * @inheritdoc
+         */
+        start(): void;
+        /**
+         * @inheritdoc
+         */
+        open(port: number): void;
+        /**
+         * @inheritdoc
+         */
+        close(): void;
+    }
+    /**
+     * A mediator server, driver for the master client.
+     *
+     * The {@link MediatorWebServer} is a class opening a server accepting the **master** client, following the
+     * web-socket protocol.
+     *
+     * #### [Inherited] {@link MediatorSystem}
+     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
+     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
+     *
+     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
+     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
+     * type and protocol the **master** system follows:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
+     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
+     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
+     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
+     * result to its **master**.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
+     *			 [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class MediatorWebServer extends MediatorServer {
+        /**
+         * @inheritdoc
+         */
+        protected createServerBase(): protocol.IServerBase;
+    }
+    /**
+     * A mediator server, driver for the master client.
+     *
+     * The {@link MediatorSharedWorkerServer} is a class opening a server accepting the **master** client, following the
+     * SharedWorker's protocol.
+     *
+     * #### [Inherited] {@link MediatorSystem}
+     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
+     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
+     *
+     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
+     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
+     * type and protocol the **master** system follows:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
+     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
+     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
+     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
+     * result to its **master**.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
+     *			 [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class MediatorSharedWorkerServer extends MediatorServer {
+        /**
+         * @inheritdoc
+         */
+        protected createServerBase(): protocol.IServerBase;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * A mediator client, driver for the master server.
+     *
+     * The {@link MediatorServer} is a class being a client connecting to the **master** server, following the protocol
+     * of Samchon Framework's own.
+     *
+     * #### [Inherited] {@link MediatorSystem}
+     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
+     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
+     *
+     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
+     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
+     * type and protocol the **master** system follows:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
+     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
+     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
+     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
+     * result to its **master**.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
+     *			 [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class MediatorClient extends MediatorSystem implements slave.ISlaveClient {
+        /**
+         * @hidden
+         */
+        private ip;
+        /**
+         * @hidden
+         */
+        private port;
+        /**
+         * Initializer Constructor.
+         *
+         * @param systemArray The parent {@link ParallelSystemArrayMediator} object.
+         * @param ip IP address to connect.
+         * @param port Port number to connect.
+         */
+        constructor(systemArray: ParallelSystemArrayMediator, ip: string, port: number);
+        /**
+         * Initializer Constructor.
+         *
+         * @param systemArray The parent {@link DistributedSystemArrayMediator} object.
+         * @param ip IP address to connect.
+         * @param port Port number to connect.
+         */
+        constructor(systemArray: distributed.DistributedSystemArrayMediator, ip: string, port: number);
+        /**
+         * Factory method creating {@link IServerConnector} object.
+         *
+         * The {@link createServerConnector createServerConnector()} is an abstract method creating
+         * {@link IServerConnector} object. Overrides and returns one of them, considering which protocol the **master**
+         * server follows:
+         *
+         * - {@link ServerConnector}
+         * - {@link WebServerConnector}
+         * - {@link SharedWorkerServerConnector}
+         *
+         * @return A newly created {@link IServerConnector} object.
+         */
+        protected createServerConnector(): protocol.IServerConnector;
+        /**
+         * @inheritdoc
+         */
+        start(): void;
+        /**
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+    /**
+     * A mediator client, driver for the master server.
+     *
+     * The {@link MediatorWebClient} is a class being a client connecting to the **master** server, following the
+     * web-socket protocol.
+     *
+     * #### [Inherited] {@link MediatorSystem}
+     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
+     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
+     *
+     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
+     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
+     * type and protocol the **master** system follows:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
+     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
+     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
+     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
+     * result to its **master**.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
+     *			 [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class MediatorWebClient extends MediatorClient {
+        /**
+         * @inheritdoc
+         */
+        protected createServerConnector(): protocol.IServerConnector;
+    }
+    /**
+     * A mediator client, driver for the master server.
+     *
+     * The {@link MediatorSharedWorkerClient} is a class being a client connecting to the **master** server, following
+     * the SharedWorker's protocol.
+     *
+     * #### [Inherited] {@link MediatorSystem}
+     * The {@link MediatorSystem} is an abstract class helping {@link ParallelSystemArrayMediator} can be a **slave**
+     * system. The {@link MediatorSystem} interacts and communicates with the **master** system as a role of **slave**.
+     *
+     * This {@link MediatorSystem} object is created in {@link ParallelSystemArrayMediator.createMediator}. Override the
+     * method and return one of them, which are derived from this {@link MediatorSystem} class, considering which
+     * type and protocol the **master** system follows:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * When the **master** orders a *parallel process* to this **slave**, then the {@link MediatorSystem} delivers the
+     * *parallel process* to its parent {@link ParallelSystemArrayMediator} object. The
+     * {@link ParallelSystemArrayMediator} object distributes the *parallel process* to its slaves system,
+     * {@link ParallelSystem} objects. When the *parallel process* has completed, then {@link MediatorSystem} reports the
+     * result to its **master**.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System),
+     *			 [Templates - Distributed System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Distributed_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class MediatorSharedWorkerClient extends MediatorClient {
+        /**
+         * @inheritdoc
+         */
+        protected createServerConnector(): protocol.IServerConnector;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * Master of Parallel Processing System, a server accepting slave clients.
+     *
+     * The {@link ParallelClientArray} is an abstract class, derived from the {@link ParallelSystemArray} class, opening
+     * a server accepting {@link ParallelSystem parallel clients}.
+     *
+     * Extends this {@link ParallelClientArray}, overrides {@link createServerBase createServerBase()} to determine which
+     * protocol to follow and {@link createExternalClient createExternalClient()} creating child {@link ParallelSystem}
+     * object. After the extending and overridings, open this server using the {@link open open()} method.
+     *
+     * #### [Inherited] {@link ParallelSystemArray}
+     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
+     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
+     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to slave systems and the
+     * children {@link ParallelSystem} objects represent the remote slave systems, who is being requested the
+     * *parallel processes*.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
+     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Proxy Pattern
+     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
      * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is <i>which can be done</i>. </p>
+     * important. Only interested in user's perspective is *which can be done*.
      *
-     * <p> By using the <i>logical proxy</i>, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
      * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}. </p>
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
      *
      * <ul>
      *	<li>
@@ -5131,180 +8779,75 @@ declare namespace samchon.protocol.external {
      *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
      *		external system.
      *	</li>
-     *	<li> Those strategy is called <i>Proxy Pattern</i>. </li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
      * </ul>
      *
-     * @author Jeongho Nam <http://samchon.org>
-         */
-    abstract class ExternalSystemArray extends EntityDequeCollection<ExternalSystem> implements IProtocol {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @hidden
-         */
-        private handle_system_erase(event);
-        /**
-         * Test whether this system array has the role.
-         *
-         * @param name Name, identifier of target {@link ExternalSystemRole role}.
-         *
-         * @return Whether the role has or not.
-         */
-        hasRole(name: string): boolean;
-        /**
-         * Get a role.
-         *
-         * @param name Name, identifier of target {@link ExternalSystemRole role}.
-         *
-         * @return The specified role.
-         */
-        getRole(name: string): ExternalSystemRole;
-        /**
-         * <p> Send an {@link Invoke} message. </p>
-         *
-         * @param invoke An {@link Invoke} message to send.
-         */
-        sendData(invoke: Invoke): void;
-        /**
-         * <p> Handle an {@Invoke} message have received. </p>
-         *
-         * @param invoke An {@link Invoke} message have received.
-         */
-        replyData(invoke: Invoke): void;
-        /**
-         * Tag name of the {@link ExternalSytemArray} in {@link XML}.
-         *
-         * @return <i>systemArray</i>.
-         */
-        TAG(): string;
-        /**
-         * Tag name of {@link ExternalSystem children elements} belonged to the {@link ExternalSytemArray} in {@link XML}.
-         *
-         * @return <i>system</i>.
-         */
-        CHILD_TAG(): string;
-    }
-}
-declare namespace samchon.protocol.parallel {
-    /**
-     * <p> A manager containing {@link ParallelSystem} objects. </p>
-     *
-     *
-     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
      * @author Jeongho Nam <http://samchon.org>
      */
-    abstract class ParallelSystemArray extends external.ExternalSystemArray {
+    abstract class ParallelClientArray extends ParallelSystemArray implements external.IExternalClientArray {
         /**
          * @hidden
          */
-        private history_sequence_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        at(index: number): ParallelSystem;
-        /**
-         * @hidden
-         */
-        _Fetch_history_sequence(): number;
-        /**
-         * @hidden
-         */
-        _Set_history_sequence(val: number): void;
-        /**
-         *
-         * @param invoke An invoke message requesting parallel process.
-         * @param size Number of pieces.
-         */
-        sendSegmentData(invoke: Invoke, size: number): void;
-        /**
-         *
-         *
-         * @param invoke An invoke message requesting parallel process.
-         * @param first Initial piece's index in a section.
-         * @param last Final piece's index in a section. The ranged used is [<i>first</i>, <i>last</i>), which contains
-         *			   all the pieces' indices between <i>first</i> and <i>last</i>, including the piece pointed by index
-         *			   <i>first</i>, but not the piece pointed by the index <i>last</i>.
-         */
-        sendPieceData(invoke: Invoke, first: number, last: number): void;
-        /**
-         *
-         * @param history
-         *
-         * @return Whether the processes with same uid are all fininsed.
-         */
-        _Complete_history(history: InvokeHistory): boolean;
-        /**
-         * @hidden
-         */
-        private normalize_performance();
-    }
-}
-declare namespace samchon.protocol.distributed {
-    abstract class DistributedSystemArray extends parallel.ParallelSystemArray {
-        /**
-         * @hidden
-         */
-        private role_map_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        construct(xml: library.XML): void;
-        abstract createRole(xml: library.XML): DistributedSystemRole;
-        /**
-         * @inheritdoc
-         */
-        at(index: number): DistributedSystem;
-        getRoleMap(): std.HashMap<string, DistributedSystemRole>;
-        /**
-         * @inheritdoc
-         */
-        hasRole(name: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        getRole(name: string): DistributedSystemRole;
-        insertRole(role: DistributedSystemRole): void;
-        eraseRole(name: string): void;
-        toXML(): library.XML;
-    }
-}
-declare namespace samchon.protocol.distributed {
-    abstract class DistributedClientArray extends DistributedSystemArray implements external.IExternalClientArray {
-        /**
-         * A subrogator of {@link IServer server}'s role instead of this {@link ExternalClientArray}.
-         */
         private server_base_;
         /**
          * Default Constructor.
          */
         constructor();
         /**
-         * <p> Factory method creating {@link IServerBase} object. </p>
+         * Factory method creating {@link IServerBase} object.
          *
-         * <p> This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
+         * This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
          * {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
-         * may connect to {@link ExternalClientArray this server} must follow the specified protocol. </p>
+         * may connect to {@link ExternalClientArray this server} must follow the specified protocol.
          *
-         * <p> Creates and returns one of them: </p>
-         * <ul>
-         *	<li> {@link ServerBase} </li>
-         *	<li> {@link WebServerBase} </li>
-         *	<li> {@link SharedWorkerServerBase} </li>
-         * </ul>
+         * Overrides the {@link createServerBase createServerBase()} method to create and return one of them:
+         *
+         * - {@link ServerBase}
+         * - {@link WebServerBase}
+         * - {@link SharedWorkerServerBase}
          *
          * @return A new {@link IServerBase} object.
          */
-        protected abstract createServerBase(): IServerBase;
-        addClient(driver: IClientDriver): void;
-        createChild(xml: library.XML): DistributedSystem;
-        protected abstract createExternalClient(driver: IClientDriver): DistributedSystem;
+        protected abstract createServerBase(): protocol.IServerBase;
+        /**
+         * Add a newly connected remote client.
+         *
+         * When a {@link IClientDriver remote client} connects to this *master server of parallel processing system*,
+         * then this {@link ParallelClientArray} creates a child {@link ParallelSystem parallel client} object through
+         * the {@link createExternalClient createExternalClient()} method and {@link insert inserts} it.
+         *
+         * @param driver A communicator for external client.
+         */
+        addClient(driver: protocol.IClientDriver): void;
+        /**
+         * (Deprecated) Factory method creating child object.
+         *
+         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
+         *
+         * Note that, the {@link ParallelClientArray} is a server accepting {@link ParallelSystem parallel clients}.
+         * There's no way to creating the {@link ParallelSystem parallel clients} in advance before opening the server.
+         *
+         * @param xml An {@link XML} object represents the child {@link ParallelSystem} object.
+         * @return ```null```
+         */
+        createChild(xml: library.XML): ParallelSystem;
+        /**
+         * Factory method creating {@link ParallelSystem} object.
+         *
+         * The method {@link createExternalClient createExternalClient()} is a factory method creating a child
+         * {@link ParallelSystem} object, that is called whenever a parallel client has connected, by
+         * {@link addClient addClient()}.
+         *
+         * Overrides this {@link createExternalClient} method and creates a type of {@link ParallelSystem} object with
+         * the *driver* that communicates with the parallel client. After the creation, returns the {@link ParallelSystem}
+         * object. Then whenever a parallel client has connected, matched {@link ParallelSystem} object will be
+         * constructed and {@link insert inserted} into this {@link ParallelClientArray} object.
+         *
+         * @param driver A communicator with the parallel client.
+         * @return A newly created {@link ParallelSystem} object.
+         */
+        protected abstract createExternalClient(driver: protocol.IClientDriver): ParallelSystem;
         /**
          * @inheritdoc
          */
@@ -5315,389 +8858,208 @@ declare namespace samchon.protocol.distributed {
         close(): void;
     }
 }
-declare namespace samchon.protocol.distributed {
-    abstract class DistributedSystemArrayMediator extends DistributedSystemArray {
+declare namespace samchon.templates.parallel {
+    /**
+     * Mediator of Parallel Processing System.
+     *
+     * The {@link ParallelSystemArrayMediator} class be a **master** for its slave systems, and be a **slave** to its
+     * master system at the same time. This {@link ParallelSystemArrayMediator} be a **master **system, containing and
+     * managing {@link ParallelSystem} objects, which represent parallel slave systems, by extending
+     * {@link ParallelSystemArray} class. Also, be a **slave** system through {@link getMediator mediator} object, which is
+     * derived from the {@link SlavSystem} class.
+     *
+     * As a **master**, you can specify this {@link ParallelSystemArrayMediator} class to be <i>a master server accepting
+     * slave clients<i> or <i>a master client to connecting slave servers</i>. Even both of them is possible. Extends one
+     * of them below and overrides abstract factory method(s) creating the child {@link ParallelSystem} object.
+     *
+     * - {@link ParallelClientArrayMediator}: A server accepting {@link ParallelSystem parallel clients}.
+     * - {@link ParallelServerArrayMediator}: A client connecting to {@link ParallelServer parallel servers}.
+     * - {@link ParallelServerClientArrayMediator}: Both of them. Accepts {@link ParallelSystem parallel clients} and
+     *   connects to {@link ParallelServer parallel servers} at the same time.
+     *
+     * As a **slave**, you can specify this {@link ParallelSystemArrayMediator} to be <i>a client slave connecting to
+     * master server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
+     * Overrides the {@link createMediator createMediator()} method and return one of them:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * #### [Inherited] {@link ParallelSystemArray}
+     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
+     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
+     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to slave systems and the
+     * children {@link ParallelSystem} objects represent the remote slave systems, who is being requested the
+     * *parallel processes*.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
+     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Proxy Pattern
+     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ParallelSystemArrayMediator extends ParallelSystemArray {
+        /**
+         * @hidden
+         */
         private mediator_;
         /**
          * Default Constructor.
          */
         constructor();
-        protected abstract createMediator(): parallel.MediatorSystem;
+        /**
+         * Factory method creating a {@link MediatorSystem} object.
+         *
+         * The {@link createMediator createMediator()} is an abstract method creating the {@link MediatorSystem} object.
+         *
+         * You know what? this {@link ParallelSystemArrayMediator} class be a **master** for its slave systems, and be a
+         * **slave** to its master system at the same time. The {@link MediatorSystem} object makes it possible; be a
+         * **slave** system. This {@link createMediator} determines specific type of the {@link MediatorSystem}.
+         *
+         * Overrides the {@link createMediator createMediator()} method to create and return one of them following which
+         * protocol and which type of remote connection (server or client) will be used:
+         *
+         * - A client slave connecting to master server:
+         *   - {@link MediatorClient}
+         *   - {@link MediatorWebClient}
+         *   - {@link MediatorSharedWorkerClient}
+         * - A server slave accepting master client:
+         *   - {@link MediatorServer}
+         *   - {@link MediatorWebServer}
+         *   - {@link MediatorSharedWorkerServer}
+         *
+         * @return A newly created {@link MediatorSystem} object.
+         */
+        protected abstract createMediator(): MediatorSystem;
+        /**
+         * Start mediator.
+         *
+         * If the {@link getMediator mediator} is a type of server, then opens the server accepting master client.
+         * Otherwise, the {@link getMediator mediator} is a type of client, then connects the master server.
+         */
         protected startMediator(): void;
-        getMediator(): parallel.MediatorSystem;
-        _Complete_history(history: parallel.PRInvokeHistory): boolean;
+        /**
+         * Get {@link MediatorSystem} object.
+         *
+         * When you need to send an {@link Invoke} message to the master system of this
+         * {@link ParallelSystemArrayMediator}, then send to the {@link MediatorSystem} through this {@link getMediator}.
+         *
+         * ```typescript
+         * this.getMediator().sendData(...);
+         * ```
+         *
+         * @return The {@link MediatorSystem} object.
+         */
+        getMediator(): MediatorSystem;
+        /**
+         * @hidden
+         */
+        protected _Complete_history(history: PRInvokeHistory): boolean;
     }
 }
-declare namespace samchon.protocol.distributed {
-    abstract class DistributedClientArrayMediator extends DistributedSystemArrayMediator implements external.IExternalClientArray {
+declare namespace samchon.templates.parallel {
     /**
-         * A subrogator of {@link IServer server}'s role instead of this {@link ExternalClientArray}.
-         */
-        private server_base_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * <p> Factory method creating {@link IServerBase} object. </p>
+     * Mediator of Parallel Processing System, a server accepting slave clients.
      *
-         * <p> This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
-         * {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
-         * may connect to {@link ExternalClientArray this server} must follow the specified protocol. </p>
+     * The {@link ParallelClientArrayMediator} is an abstract class, derived from the {@link ParallelSystemArrayMediator}
+     * class, opening a server accepting {@link ParallelSystem parallel clients} as a **master**.
      *
-         * <p> Creates and returns one of them: </p>
-     * <ul>
-         *	<li> {@link ServerBase} </li>
-         *	<li> {@link WebServerBase} </li>
-         *	<li> {@link SharedWorkerServerBase} </li>
-     * </ul>
+     * Extends this {@link ParallelClientArrayMediator}, overrides {@link createServerBase createServerBase()} to
+     * determine which protocol to follow and {@link createExternalClient createExternalClient()} creating child
+     * {@link ParallelSystem} object. After the extending and overridings, open this server using the
+     * {@link open open()} method.
      *
-         * @return A new {@link IServerBase} object.
-         */
-        protected abstract createServerBase(): IServerBase;
-        addClient(driver: IClientDriver): void;
-        createChild(xml: library.XML): DistributedSystem;
-        protected abstract createExternalClient(driver: IClientDriver): DistributedSystem;
-        /**
-         * @inheritdoc
-         */
-        open(port: number): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-    }
-}
-declare namespace samchon.protocol.external {
-    /**
-     * <p> An external system driver. </p>
+     * #### [Inherited] {@link ParallelSystemArrayMediator}
+     * The {@link ParallelSystemArrayMediator} class be a **master** for its slave systems, and be a **slave** to its
+     * master system at the same time. This {@link ParallelSystemArrayMediator} be a **master **system, containing and
+     * managing {@link ParallelSystem} objects, which represent parallel slave systems, by extending
+     * {@link ParallelSystemArray} class. Also, be a **slave** system through {@link getMediator mediator} object, which is
+     * derived from the {@link SlavSystem} class.
      *
-     * <p> The {@link ExternalSystem} class represents an external system, connected and interact with this system.
-     * {@link ExternalSystem} takes full charge of network communication with external system have connected.
-     * Replied {@link Invoke messages} from the external system is shifted to and processed in, children elements of this
-     * class, {@link ExternalSystemRole} objects. </p>
+     * As a **slave**, you can specify this {@link ParallelSystemArrayMediator} to be <i>a client slave connecting to
+     * master server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
+     * Overrides the {@link createMediator createMediator()} method and return one of them:
      *
-     * <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * #### [Inherited] {@link ParallelSystemArray}
+     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
+     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
+     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to slave systems and the
+     * children {@link ParallelSystem} objects represent the remote slave systems, who is being requested the
+     * *parallel processes*.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
+     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
      *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
      *		 style="max-width: 100%" />
-     * </a> </p>
+     * </a>
      *
-     * <h4> Bridge & Proxy Pattern </h4>
-     * <p> The {@link ExternalSystem} class can be a <i>bridge</i> for <i>logical proxy</i>. In framework within user,
-     * which {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is <i>which can be done</i>. </p>
+     * #### Proxy Pattern
+     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
      *
-     * <p> By using the <i>logical proxy</i>, user dont't need to know which {@link ExternalSystemRole role} is belonged
-     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}. </p>
-     *
-     * <ul>
-     *	<li>
-     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
-     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
-     *	</li>
-     *	<li>
-     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
-     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
-     *		external system.
-     *	</li>
-     *	<li> Those strategy is called <i>Bridge Pattern</i> and <i>Proxy Pattern</i>. </li>
-     * </ul>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ExternalSystem extends EntityDequeCollection<ExternalSystemRole> implements IProtocol {
-        /**
-         * The name represents external system have connected.
-         */
-        protected name: string;
-        /**
-         * @hidden
-         */
-        private system_array_;
-        /**
-         * @hidden
-         */
-        private communicator_;
-        constructor(systemArray: ExternalSystemArray);
-        constructor(systemArray: ExternalSystemArray, communicator: IClientDriver);
-        /**
-         * Default Destructor.
-         */
-        destructor(): void;
-        /**
-         * @hidden
-         */
-        private handle_close();
-        getSystemArray(): ExternalSystemArray;
-        /**
-         * Identifier of {@link ExternalSystem} is its {@link name}.
-         */
-        key(): string;
-        /**
-         * Get {@link name}.
-         */
-        getName(): string;
-        protected communicator: protocol.ICommunicator;
-        close(): void;
-        /**
-         * Send {@link Invoke} message to external system.
-         *
-         * @param invoke An {@link Invoke} message to send.
-         */
-        sendData(invoke: Invoke): void;
-        /**
-         * Handle an {@Invoke} message has received.
-         *
-         * @param invoke An {@link Invoke} message have received.
-         */
-        replyData(invoke: Invoke): void;
-        /**
-         * Tag name of the {@link ExternalSytem} in {@link XML}.
-         *
-         * @return <i>system</i>.
-         */
-        TAG(): string;
-        /**
-         * Tag name of {@link ExternalSystemRole children elements} belonged to the {@link ExternalSytem} in {@link XML}.
-         *
-         * @return <i>role</i>.
-         */
-        CHILD_TAG(): string;
-    }
-}
-declare namespace samchon.protocol.parallel {
-    /**
-     * <p> An external parallel system driver. </p>
-     *
-     *
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ParallelSystem extends external.ExternalSystem {
-        /**
-         * @hidden
-         */
-        private progress_list_;
-        /**
-         * @hidden
-         */
-        private history_list_;
-        /**
-         * <p> Performance index. </p>
-         *
-         * <p> A performance index that indicates how much fast the connected parallel system is. </p>
-         *
-         * <p> If this {@link ParallelSystem parallel system} hasn't any {@link Invoke} message had handled, then the
-         * {@link performance performance index} will be 1, which means default and average value between all
-         * {@link ParallelSystem} instances (belonged to a same {@link ParallelSystemArray} object). </p>
-         *
-         * <p> You can specify this {@link performance} by yourself, but notice that, if the
-         * {@link performance performance index} is higher then other {@link ParallelSystem} objects, then this
-         * {@link ParallelSystem parallel system} will ordered to handle more processes than other
-         * {@link ParallelSystem} objects. Otherwise, the {@link performance performance index) is lower than others,
-         * of course, less processes will be delivered. </p>
-         *
-         * <p> This {@link performance index} is always re-calculated whenever {@link ParallelSystemArray} calls one of
-         * them below. </p>
-         *
-         * <ul>
-         *	<li> {@link ParallelSystemArray.sendSegmentData ParallelSystemArray.sendSegmentData()} </li>
-         *	<li> {@link ParallelSystemArray.sendPieceData ParallelSystemArray.sendPieceData()} </li>
-         * </ul>
-         *
-         * <p> If this class is a type of {@link DistributedSystem} derived class from the {@link ParallelSystem},
-         * then {@link DistributedSystemRole.sendData DistributedSystemRole.sendData()} also cause the re-calculation.
-         * </p>
-         */
-        protected performance: number;
-        constructor(systemArray: ParallelSystemArray);
-        constructor(systemArray: ParallelSystemArray, communicator: IClientDriver);
-        destructor(): void;
-        /**
-         * Get manager of this object, {@link systemArray}.
-         *
-         * @return A manager containing this {@link ParallelSystem} object.
-         */
-        getSystemArray(): ParallelSystemArray;
-        /**
-         * Get {@link performant performance index}.
-         *
-         * A performance index that indicates how much fast the connected parallel system is.
-         */
-        getPerformance(): number;
-        _Get_progress_list(): std.HashMap<number, std.Pair<Invoke, InvokeHistory>>;
-        _Get_history_list(): std.HashMap<number, InvokeHistory>;
-        _Set_performance(val: number): void;
-        /**
-         * @hidden
-         */
-        _Send_piece_data(invoke: Invoke, first: number, last: number): void;
-        /**
-         * @hidden
-         */
-        private _replyData(invoke);
-        /**
-         *
-         *
-         * @param xml
-         *
-         * @see {@link ParallelSystemArray.notify_complete}
-         */
-        protected _Report_history(xml: library.XML): void;
-    }
-}
-declare namespace samchon.protocol.distributed {
-    abstract class DistributedSystem extends parallel.ParallelSystem {
-        destructor(): void;
-        createChild(xml: library.XML): external.ExternalSystemRole;
-    /**
-         * Get manager of this object.
-     *
-         * @return A manager containing this {@link DistributedSystem} objects.
-     */
-        getSystemArray(): DistributedSystemArray;
-        /**
-         * @inheritdoc
-         */
-        has(key: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        get(key: string): DistributedSystemRole;
-        replyData(invoke: protocol.Invoke): void;
-        protected _Report_history(xml: library.XML): void;
-    }
-}
-declare namespace samchon.protocol.distributed {
-    interface IDistributedServer extends DistributedSystem, external.IExternalServer {
-        /**
-         * @inheritdoc
-         */
-        getSystemArray(): DistributedSystemArray;
-        /**
-         * @inheritdoc
-         */
-        has(key: string): boolean;
-        /**
-         * @inheritdoc
-         */
-        get(key: string): DistributedSystemRole;
-    }
-    abstract class DistributedServer extends DistributedSystem implements external.IExternalServer {
-        protected ip: string;
-        protected port: number;
-        constructor(systemArray: DistributedSystemArray);
-        protected abstract createServerConnector(): IServerConnector;
-        connect(): void;
-        getIP(): string;
-        getPort(): number;
-    }
-}
-declare namespace samchon.protocol.distributed {
-    abstract class DistributedServerArray extends DistributedSystemArray implements external.IExternalServerArray {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.protocol.distributed {
-    abstract class DistributedServerArrayMediator extends DistributedSystemArrayMediator implements external.IExternalServerArray {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.protocol.distributed {
-    abstract class DistributedServerClientArray extends DistributedClientArray implements external.IExternalServerClientArray {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        createChild(xml: library.XML): DistributedSystem;
-        protected abstract createExternalServer(xml: library.XML): IDistributedServer;
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.protocol.distributed {
-    abstract class DistributedServerClientArrayMediator extends DistributedClientArrayMediator implements external.IExternalServerClientArray {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        createChild(xml: library.XML): DistributedSystem;
-        protected abstract createExternalServer(xml: library.XML): IDistributedServer;
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.protocol.external {
-    /**
-     * <p> An interface for an {@link ExternalSystemArray} accepts {@link ExternalSystem external clients} as a
-     * {@link IServer server}. </p>
-     *
-     * <p> The easiest way to defining an {@link ExternalSystemArray} who opens server and accepts
-     * {@link ExternalSystem external clients} is to extending one of below, who are derived from this interface
-     * {@link IExternalClientArray}. However, if you can't specify an {@link ExternalSystemArray} to be whether server or
-     * client, then make a class (let's name it as <b>BaseSystemArray</b>) extending {@link ExternalSystemArray} and make
-     * a new class (now, I name it <b>BaseClientArray</b>) extending <b>BaseSystemArray</b> and implementing this
-     * interface {@link IExternalClientArray}. Define the <b>BaseClientArray</b> following those codes on below:
-     *
-     * <ul>
-     *	<li> {@link ExternalClientArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalClientArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link ParallelClientArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/ParallelClientArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link DistributedClientArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/DistributedClientArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     * </ul>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IExternalClientArray extends ExternalSystemArray, IServer {
-    }
-    /**
-     * <p> An {@link ExternalSystemArray} acceepts {@link ExternalSystem external clients} as a {@link IServer server}. </p>
-     *
-     * <p> {@link ExternalServerArray} is an abstract class contains, manages and accepts external server drivers,
-     * {@link IExternalServer} objects, as a {@link IServer server}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
-     *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
-     *		 style="max-width: 100%" />
-     * </a> </p>
-     *
-     * <h4> Proxy Pattern </h4>
-     * <p> The {@link ExternalSystemArray} class can use <i>Proxy Pattern</i>. In framework within user, which
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
      * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is <i>which can be done</i>. </p>
+     * important. Only interested in user's perspective is *which can be done*.
      *
-     * <p> By using the <i>logical proxy</i>, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
      * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}. </p>
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
      *
      * <ul>
      *	<li>
@@ -5709,14 +9071,15 @@ declare namespace samchon.protocol.external {
      *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
      *		external system.
      *	</li>
-     *	<li> Those strategy is called <i>Proxy Pattern</i>. </li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
      * </ul>
      *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
      * @author Jeongho Nam <http://samchon.org>
      */
-    abstract class ExternalClientArray extends ExternalSystemArray implements IExternalClientArray {
+    abstract class ParallelClientArrayMediator extends ParallelSystemArrayMediator implements external.IExternalClientArray {
         /**
-         * A subrogator of {@link IServer server}'s role instead of this {@link ExternalClientArray}.
+         * @hidden
          */
         private server_base_;
         /**
@@ -5724,36 +9087,61 @@ declare namespace samchon.protocol.external {
          */
         constructor();
         /**
-         * <p> Factory method creating {@link IServerBase} object. </p>
+         * Factory method creating {@link IServerBase} object.
          *
-         * <p> This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
-         * {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
-         * may connect to {@link ExternalClientArray this server} must follow the specified protocol. </p>
+         * This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
+         * {@link ParallelClientArrayMediator}. If the protocol is determined, then
+         * {@link ParallelSystem parallel clients} who may connect to {@link ParallelClientArrayMediator this server}
+         * must follow the specified protocol.
          *
-         * <p> Creates and returns one of them: </p>
-         * <ul>
-         *	<li> {@link ServerBase} </li>
-         *	<li> {@link WebServerBase} </li>
-         *	<li> {@link SharedWorkerServerBase} </li>
-         * </ul>
+         * Overrides the {@link createServerBase createServerBase()} method to create and return one of them:
+         *
+         * - {@link ServerBase}
+         * - {@link WebServerBase}
+         * - {@link SharedWorkerServerBase}
          *
          * @return A new {@link IServerBase} object.
          */
-        protected abstract createServerBase(): IServerBase;
-        addClient(driver: IClientDriver): void;
+        protected abstract createServerBase(): protocol.IServerBase;
         /**
-         * This method is deprecated. Don't use and override this.
+         * Add a newly connected remote client.
          *
-         * @return null.
+         * When a {@link IClientDriver remote client} connects to this *master server of parallel processing system*,
+         * then this {@link ParallelClientArrayMediator} creates a child {@link ParallelSystem parallel client} object
+         * through the {@link createExternalClient createExternalClient()} method and {@link insert inserts} it.
+         *
+         * @param driver A communicator for parallel client.
          */
-        createChild(xml: library.XML): ExternalSystem;
+        addClient(driver: protocol.IClientDriver): void;
         /**
-         * Factory method creating {@link ExternalSystem} object.
+         * (Deprecated) Factory method creating child object.
          *
-         * @param driver A communicator with connected client.
-         * @return A newly created {@link ExternalSystem} object.
+         * The method {@link createChild createChild()} is deprecated. Don't use and override this.
+         *
+         * Note that, the {@link ParallelClientArrayMediator} is a server accepting {@link ParallelSystem parallel
+         * clients} as a master. There's no way to creating the {@link ParallelSystem parallel clients} in advance before
+         * opening the server.
+         *
+         * @param xml An {@link XML} object represents the child {@link ParallelSystem} object.
+         * @return null
          */
-        protected abstract createExternalClient(driver: IClientDriver): ExternalSystem;
+        createChild(xml: library.XML): ParallelSystem;
+        /**
+         * Factory method creating {@link ParallelSystem} object.
+         *
+         * The method {@link createExternalClient createExternalClient()} is a factory method creating a child
+         * {@link ParallelSystem} object, that is called whenever a parallel client has connected, by
+         * {@link addClient addClient()}.
+         *
+         * Overrides this {@link createExternalClient} method and creates a type of {@link ParallelSystem} object with
+         * the *driver* that communicates with the parallel client. After the creation, returns the {@link ParallelSystem}
+         * object. Then whenever a parallel client has connected, matched {@link ParallelSystem} object will be
+         * constructed and {@link insert inserted} into this {@link ParallelClientArrayMediator} object.
+         *
+         * @param driver A communicator with the parallel client.
+         * @return A newly created {@link ParallelSystem} object.
+         */
+        protected abstract createExternalClient(driver: protocol.IClientDriver): ParallelSystem;
         /**
          * @inheritdoc
          */
@@ -5764,58 +9152,78 @@ declare namespace samchon.protocol.external {
         close(): void;
     }
 }
-declare namespace samchon.protocol.external {
+declare namespace samchon.templates.parallel {
     /**
-     * <p> An interface for an external server driver. </p>
+     * An interface for a parallel slave server driver.
      *
-     * <p> The easiest way to defining an external server driver is to extending one of below, who are derived from this
-     * interface {@link IExternalServer}. However, if you've to interact with an external system who can be both server
-     * and client, then make a class (let's name it as <b>BaseSystem</b>) extending {@link ExternalSystem} and make a
-     * new class (now, I name it <b>BaseServer</b>) extending <b>BaseSystem</b> and implementing this interface
-     * {@link IExternalServer}. Define the <b>BaseServer</b> following those codes on below:
+     * The easiest way to defining a driver for parallel **slave** server is extending {@link ParallelServer} class.
+     * However, if you've to interact with a prallel **slave** system who can be both server and client, them make a class
+     * (let's name it **BaseSystem**) extending the {@link ParallelSystem} class. At next, make a new class (now, I name it
+     * **BaseServer**) extending the **BaseSystem** and implements this interface {@link IParallelServer}. Define the
+     * **BaseServer** following those codes on below:
      *
      * <ul>
      *	<li> {@link ExternalServer}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalServer.ts"
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/external/ExternalServer.ts"
      *		   target="_blank"> View source code on GitHub </a>
      *	</li>
      *	<li> {@link ParallelServer}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/DistributedServer.ts"
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/parallel/ParallelServer.ts"
      *		   target="_blank"> View source code on GitHub </a>
      *	</li>
      *	<li> {@link DistributedServer}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/ParallelServer.ts"
+     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/templates/distributed/DistributedServer.ts"
      *		   target="_blank"> View source code on GitHub </a>
      *	</li>
      * </ul>
      *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
      * @author Jeongho Nam <http://samchon.org>
      */
-    interface IExternalServer extends ExternalSystem {
+    interface IParallelServer extends ParallelSystem {
+        /**
+         * Connect to slave server.
+         */
         connect(): void;
     }
     /**
-     * <p> An external server driver. </p>
+     * A driver for parallel slave server.
      *
-     * <p> The {@link ExternalServer} class represents an external server, connected and interact with this system.
-     * {@link ExternalServer} takes full charge of network communication with external server have connected.
-     * Replied {@link Invoke messages} from the external system is shifted to and processed in, children elements of this
-     * class, {@link ExternalSystemRole} objects. </p>
+     * The {@link ParallelServer} is an abstract class, derived from the {@link ParallelSystem} class, connecting to
+     * remote, parallel **slave** server. Extends this {@link ParallelServer} class and overrides the
+     * {@link createServerConnector createServerConnector()} method following which protocol the **slave** server uses.
      *
-     * <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
+     * #### [Inherited] {@link ParallelSystem}
+     * The {@link ParallelSystem} is an abstract class represents a **slave** system in *Parallel Processing System*,
+     * connected with this **master** system. This {@link ParallelSystem} takes full charge of network communication with
+     * the remote, parallel **slave** system has connected.
+     *
+     * When a *parallel process* is requested (by {@link ParallelSystemArray.sendSegementData} or
+     * {@link ParallelSystemArray.sendPieceData}), the number of pieces to be allocated to a {@link ParallelSystem} is
+     * turn on its {@link getPerformance performance index}. Higher {@link getPerformance performance index}, then
+     * more pieces are requested. The {@link getPerformance performance index} is revaluated whenever a *parallel process*
+     * has completed, basic on the execution time and number of pieces. You can sugguest or enforce the
+     * {@link getPerformance performance index} with {@link setPerformance} or {@link enforcePerformance}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
      *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
      *		 style="max-width: 100%" />
-     * </a> </p>
+     * </a>
      *
-     * <h4> Bridge & Proxy Pattern </h4>
-     * <p> The {@link ExternalSystem} class can be a <i>bridge</i> for <i>logical proxy</i>. In framework within user,
+     * #### Bridge & Proxy Pattern
+     * This class {@link ParallelSystem} is derived from the {@link ExternalSystem} class. Thus, you can take advantage
+     * of the *Bridge & Proxy Pattern* in this {@link ParallelSystem} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Bridge & Proxy Pattern*:
+     *
+     * The {@link ExternalSystem} class can be a *bridge* for *logical proxy*. In framework within user,
      * which {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is <i>which can be done</i>. </p>
+     * important. Only interested in user's perspective is *which can be done*.
      *
-     * <p> By using the <i>logical proxy</i>, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
      * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}. </p>
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
      *
      * <ul>
      *	<li>
@@ -5827,12 +9235,13 @@ declare namespace samchon.protocol.external {
      *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
      *		external system.
      *	</li>
-     *	<li> Those strategy is called <i>Bridge Pattern</i> and <i>Proxy Pattern</i>. </li>
+     *	<li> Those strategy is called *Bridge Pattern* and *Proxy Pattern*. </li>
      * </ul>
      *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
      * @author Jeongho Nam <http://samchon.org>
      */
-    abstract class ExternalServer extends ExternalSystem implements IExternalServer {
+    abstract class ParallelServer extends ParallelSystem implements IParallelServer {
         /**
          * IP address of target external system to connect.
          */
@@ -5842,84 +9251,73 @@ declare namespace samchon.protocol.external {
          */
         protected port: number;
         /**
-         * Default Constructor.
+         * Construct from parent {@link ParallelSystemArray}.
+         *
+         * @param systemArray The parent {@link ParallelSystemArray} object.
          */
-        constructor(systemArray: ExternalSystemArray);
+        constructor(systemArray: ParallelSystemArray);
         /**
-         * Factory method creating server connector.
+         * Factory method creating {@link IServerConnector} object.
+         *
+         * The {@link createServerConnector createServerConnector()} is an abstract method creating
+         * {@link IServerConnector} object. Overrides and returns one of them, considering which protocol the slave server
+         * follows:
+         *
+         * - {@link ServerConnector}
+         * - {@link WebServerConnector}
+         * - {@link SharedWorkerServerConnector}
+         *
+         * @return A newly created {@link IServerConnector} object.
          */
-        protected abstract createServerConnector(): IServerConnector;
+        protected abstract createServerConnector(): protocol.IServerConnector;
         /**
          * @inheritdoc
          */
         connect(): void;
-        /**
-         * @inheritdoc
-         */
-        getIP(): string;
-        /**
-         * @inheritdoc
-         */
-        getPort(): number;
     }
 }
-declare namespace samchon.protocol.external {
+declare namespace samchon.templates.parallel {
     /**
-     * <p> An interface for an {@link ExternalSystemArray} connects to {@link IExternalServer external servers} as a
-     * <b>client</b>. </p>
+     * Master of Parallel Processing System, a client connecting to slave servers.
      *
-     * <p> The easiest way to defining an {@link ExternalSystemArray} who connects to
-     * {@link IExternalServer external servers} is to extending one of below, who are derived from this interface
-     * {@link IExternalServerArray}. However, if you can't specify an {@link ExternalSystemArray} to be whether server or
-     * client, then make a class (let's name it as <b>BaseSystemArray</b>) extending {@link ExternalSystemArray} and make
-     * a new class (now, I name it <b>BaseServerArray</b>) extending <b>BaseSystemArray</b> and implementing this
-     * interface {@link IExternalServerArray}. Define the <b>BaseServerArray</b> following those codes on below:
+     * The {@link ParallelServerArray} is an abstract class, derived from the {@link ParallelSystemArray} class,
+     * connecting to {@link IParallelServer parallel servers}.
      *
-     * <ul>
-     *	<li> {@link ExternalServerArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalServerArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link ParallelServerArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/ParallelServerArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link DistributedServerArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/DistributedServerArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     * </ul>
+     * Extends this {@link ParallelServerArray} and overrides {@link createChild createChild()} method creating child
+     * {@link IParallelServer} object. After the extending and overriding, construct children {@link IParallelServer}
+     * objects and call the {@link connect connect()} method.
      *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IExternalServerArray extends ExternalSystemArray {
-        /**
-         * <p> Connect to {@link IExternalServer external servers}. </p>
-         *
-         * <p> This method calls children elements' method {@link IExternalServer.connect} gradually. </p>
-         */
-        connect(): void;
-    }
-    /**
-     * <p> An {@link ExternalSystemArray} connecting to {@link IExternalServer external servers} as a <b>client</b>. </p>
+     * #### [Inherited] {@link ParallelSystemArray}
+     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
+     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
+     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to slave systems and the
+     * children {@link ParallelSystem} objects represent the remote slave systems, who is being requested the
+     * *parallel processes*.
      *
-     * <p> {@link ExternalServerArray} is an abstract class contains, manages and connects to external server drivers,
-     * {@link IExternalServer} objects, as a <b>client</b>. </p>
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
+     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
      *
-     * <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
      *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
      *		 style="max-width: 100%" />
-     * </a> </p>
+     * </a>
      *
-     * <h4> Proxy Pattern </h4>
-     * <p> The {@link ExternalSystemArray} class can use <i>Proxy Pattern</i>. In framework within user, which
+     * #### Proxy Pattern
+     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
      * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is <i>which can be done</i>. </p>
+     * important. Only interested in user's perspective is *which can be done*.
      *
-     * <p> By using the <i>logical proxy</i>, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
      * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}. </p>
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
      *
      * <ul>
      *	<li>
@@ -5931,12 +9329,13 @@ declare namespace samchon.protocol.external {
      *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
      *		external system.
      *	</li>
-     *	<li> Those strategy is called <i>Proxy Pattern</i>. </li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
      * </ul>
      *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
      * @author Jeongho Nam <http://samchon.org>
      */
-    abstract class ExternalServerArray extends ExternalSystemArray {
+    abstract class ParallelServerArray extends ParallelSystemArray implements external.IExternalServerArray {
         /**
          * Default Constructor.
          */
@@ -5947,60 +9346,77 @@ declare namespace samchon.protocol.external {
         connect(): void;
     }
 }
-declare namespace samchon.protocol.external {
+declare namespace samchon.templates.parallel {
     /**
-     * <p> An interface for an {@link ExternalSystemArray} accepts {@link ExternalSystem external clients} as a
-     * {@link IServer server} and connects to {@link IExternalServer} as <b>client</b>, at the same time. </p>
+     * Mediator of Parallel Processing System, a client connecting to slave servers.
      *
-     * <p> The easiest way to defining an {@link IExternalServerClientArray} who opens server, accepts
-     * {@link ExternalSystem external clients} and connects to {@link IExternalServer external servers} is to extending
-     * one of below, who are derived from this interface {@link IExternalServerClientArray}. However, if you can't
-     * specify an {@link ExternalSystemArray} to be whether server or client or even can both them, then make a class
-     * (let's name it as <b>BaseSystemArray</b>) extending {@link ExternalSystemArray} and make a new class (now, I name
-     * it <b>BaseServerClientArray</b>) extending <b>BaseSystemArray</b> and implementing this interface
-     * {@link IExternalServerClientArray}. Define the <b>BaseServerClientArray</b> following those codes on below:
+     * The {@link ParallelServerArrayMediator} is an abstract class, derived from the {@link ParallelSystemArrayMediator}
+     * class, connecting to {@link IParallelServer parallel servers}.
      *
-     * <ul>
-     *	<li> {@link ExternalServerClientArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalServerClientArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link ParallelServerClientArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/ParallelServerClientArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     *	<li> {@link DistributedServerClientArray}:
-     *		<a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/DistributedServerClientArray.ts"
-     *		   target="_blank"> View source code on GitHub </a>
-     *	</li>
-     * </ul>
+     * Extends this {@link ParallelServerArrayMediator} and overrides {@link createChild createChild()} method creating
+     * child {@link IParallelServer} object. After the extending and overriding, construct children
+     * {@link IParallelServer} objects and call the {@link connect connect()} method.
      *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IExternalServerClientArray extends IExternalServerArray, IExternalClientArray {
-    }
-    /**
-     * <p> An {@link ExternalSystemArray} connecting to {@link IExternalServer external servers} as a <b>client</b> and
-     * accepts {@link ExternalSystem external clients} as a {@link IServer server}. </p>
+     * #### [Inherited] {@link ParallelSystemArrayMediator}
+     * The {@link ParallelSystemArrayMediator} class be a **master** for its slave systems, and be a **slave** to its
+     * master system at the same time. This {@link ParallelSystemArrayMediator} be a **master **system, containing and
+     * managing {@link ParallelSystem} objects, which represent parallel slave systems, by extending
+     * {@link ParallelSystemArray} class. Also, be a **slave** system through {@link getMediator mediator} object, which is
+     * derived from the {@link SlavSystem} class.
      *
-     * <p> {@link ExternalServerArray} is an abstract class contains, manages and connects to external server drivers,
-     * {@link IExternalServer} objects and accepts external client drivers {@link ExternalSyste} obejcts as a
-     * <b>client</b> and a {@link IServer server} at the same time. </p>
+     * As a **master**, you can specify this {@link ParallelSystemArrayMediator} class to be <i>a master server accepting
+     * slave clients<i> or <i>a master client to connecting slave servers</i>. Even both of them is possible. Extends one
+     * of them below and overrides abstract factory method(s) creating the child {@link ParallelSystem} object.
      *
-     * <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
+     * - {@link ParallelClientArrayMediator}: A server accepting {@link ParallelSystem parallel clients}.
+     * - {@link ParallelServerArrayMediator}: A client connecting to {@link ParallelServer parallel servers}.
+     * - {@link ParallelServerClientArrayMediator}: Both of them. Accepts {@link ParallelSystem parallel clients} and
+     *                                              connects to {@link ParallelServer parallel servers} at the same time.
+     *
+     * As a **slave**, you can specify this {@link ParallelSystemArrayMediator} to be <i>a client slave connecting to
+     * master server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
+     * Overrides the {@link createMediator createMediator()} method and return one of them:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * #### [Inherited] {@link ParallelSystemArray}
+     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
+     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
+     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to slave systems and the
+     * children {@link ParallelSystem} objects represent the remote slave systems, who is being requested the
+     * *parallel processes*.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
+     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
      *		  target="_blank">
-     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
      *		 style="max-width: 100%" />
-     * </a> </p>
+     * </a>
      *
-     * <h4> Proxy Pattern </h4>
-     * <p> The {@link ExternalSystemArray} class can use <i>Proxy Pattern</i>. In framework within user, which
+     * #### Proxy Pattern
+     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
      * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
-     * important. Only interested in user's perspective is <i>which can be done</i>. </p>
+     * important. Only interested in user's perspective is *which can be done*.
      *
-     * <p> By using the <i>logical proxy</i>, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
      * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
-     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}. </p>
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
      *
      * <ul>
      *	<li>
@@ -6012,121 +9428,262 @@ declare namespace samchon.protocol.external {
      *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
      *		external system.
      *	</li>
-     *	<li> Those strategy is called <i>Proxy Pattern</i>. </li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
      * </ul>
      *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
      * @author Jeongho Nam <http://samchon.org>
      */
-    abstract class ExternalServerClientArray extends ExternalClientArray implements IExternalServerClientArray {
+    abstract class ParallelServerArrayMediator extends ParallelSystemArrayMediator implements external.IExternalServerArray {
         /**
          * Default Constructor.
          */
         constructor();
         /**
-         * <p> Factory method of a child Entity. </p>
+         * @inheritdoc
+         */
+        connect(): void;
+    }
+}
+declare namespace samchon.templates.parallel {
+    /**
+     * Master of Parallel Processing System, be a server and client at the same time.
+     *
+     * The {@link ParallelServerClientArray} is an abstract class, derived from the {@link ParallelSystemArray} class,
+     * opening a server accepting {@link ParallelSystem parallel clients} and being a client connecting to
+     * {@link IParallelServer parallel servers} at the same time.
+     *
+     * Extends this {@link ParallelServerClientArray} and overrides below methods. After the overridings, open server
+     * with {@link open open()} method and connect to {@link IParallelServer parallel servers} through the
+     * {@link connect connect()} method.
+     *
+     * - {@link createServerBase createServerBase()}
+     * - {@link createExternalClient createExternalClient()}
+     * - {@link createExternalServer createExternalServer()}
+     *
+     * #### [Inherited] {@link ParallelSystemArray}
+     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
+     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
+     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to slave systems and the
+     * children {@link ParallelSystem} objects represent the remote slave systems, who is being requested the
+     * *parallel processes*.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
+     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Proxy Pattern
+     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ParallelServerClientArray extends ParallelClientArray implements external.IExternalServerClientArray {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Factory method of a child Entity.
          *
-         * <p> This method is migrated to {@link createExternalServer createExternalServer()}. Override the
-         * {@link createExternalServer createExternalServer()}. </p>
+         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
          *
          * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
-         *
          * @return A new child Entity via {@link createExternalServer createExternalServer()}.
          */
-        createChild(xml: library.XML): ExternalSystem;
+        createChild(xml: library.XML): IParallelServer;
         /**
-         * Factory method creating an {@link IExternalServer} object.
+         * Factory method creating an {@link IParallelServer} object.
          *
          * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
-         *
-         * @return A newly created {@link IExternalServer} object.
+         * @return A newly created {@link IParallelServer} object.
          */
-        protected abstract createExternalServer(xml: library.XML): IExternalServer;
+        protected abstract createExternalServer(xml: library.XML): IParallelServer;
         /**
          * @inheritdoc
          */
         connect(): void;
     }
 }
-declare namespace samchon.protocol.slave {
-    abstract class SlaveSystem implements protocol.IProtocol {
-        protected communicator_: ICommunicator;
+declare namespace samchon.templates.parallel {
+    /**
+     * Mediator of Parallel Processing System, be a server and client at the same time as a **master**.
+     *
+     * The {@link ParallelServerClientArrayMediator} is an abstract class, derived from the
+     * {@link ParallelSystemArrayMediator} class, opening a server accepting {@link ParallelSystem parallel clients} and
+     * being a client connecting to {@link IParallelServer parallel servers} at the same time.
+     *
+     * Extends this {@link ParallelServerClientArrayMediator} and overrides below methods. After the overridings, open
+     * server with {@link open open()} method and connect to {@link IParallelServer parallel servers} through the
+     * {@link connect connect()} method.
+     *
+     * - {@link createServerBase createServerBase()}
+     * - {@link createExternalClient createExternalClient()}
+     * - {@link createExternalServer createExternalServer()}
+     *
+     * #### [Inherited] {@link ParallelSystemArrayMediator}
+     * The {@link ParallelSystemArrayMediator} class be a **master** for its slave systems, and be a **slave** to its
+     * master system at the same time. This {@link ParallelSystemArrayMediator} be a **master **system, containing and
+     * managing {@link ParallelSystem} objects, which represent parallel slave systems, by extending
+     * {@link ParallelSystemArray} class. Also, be a **slave** system through {@link getMediator mediator} object, which is
+     * derived from the {@link SlavSystem} class.
+     *
+     * As a **master**, you can specify this {@link ParallelSystemArrayMediator} class to be <i>a master server accepting
+     * slave clients<i> or <i>a master client to connecting slave servers</i>. Even both of them is possible. Extends one
+     * of them below and overrides abstract factory method(s) creating the child {@link ParallelSystem} object.
+     *
+     * - {@link ParallelClientArrayMediator}: A server accepting {@link ParallelSystem parallel clients}.
+     * - {@link ParallelServerArrayMediator}: A client connecting to {@link ParallelServer parallel servers}.
+     * - {@link ParallelServerClientArrayMediator}: Both of them. Accepts {@link ParallelSystem parallel clients} and
+     *                                              connects to {@link ParallelServer parallel servers} at the same time.
+     *
+     * As a **slave**, you can specify this {@link ParallelSystemArrayMediator} to be <i>a client slave connecting to
+     * master server</i> or <i>a server slave accepting master client</i> by overriding the {@link createMediator} method.
+     * Overrides the {@link createMediator createMediator()} method and return one of them:
+     *
+     * - A client slave connecting to master server:
+     *   - {@link MediatorClient}
+     *   - {@link MediatorWebClient}
+     *   - {@link MediatorSharedWorkerClient}
+     * - A server slave accepting master client:
+     *   - {@link MediatorServer}
+     *   - {@link MediatorWebServer}
+     *   - {@link MediatorSharedWorkerServer}
+     *
+     * #### [Inherited] {@link ParallelSystemArray}
+     * The {@link ParallelSystemArray} is an abstract class containing and managing remote parallel **slave** system
+     * drivers, {@link ParallelSystem} objects. Within framework of network, {@link ParallelSystemArray} represents your
+     * system, a **Master** of *Parallel Processing System* that requesting *parallel process* to slave systems and the
+     * children {@link ParallelSystem} objects represent the remote slave systems, who is being requested the
+     * *parallel processes*.
+     *
+     * When you need the **parallel process**, then call one of them: {@link sendSegmentData} or {@link sendPieceData}.
+     * When the **parallel process** has completed, {@link ParallelSystemArray} estimates each {@link ParallelSystem}'s
+     * {@link ParallelSystem.getPerformance performance index} basis on their execution time. Those performance indices
+     * will be reflected to the next **parallel process**, how much pieces to allocate to each {@link ParallelSystem}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * #### Proxy Pattern
+     * This class {@link ParallelSystemArray} is derived from the {@link ExternalSystemArray} class. Thus, you can take
+     * advantage of the *Proxy Pattern* in the {@link ParallelSystemArray} class. If a process to request is not the
+     * *parallel process* (to be distrubted to all slaves), but the **exclusive process** handled in a system, then it
+     * may better to utilizing the *Proxy Pattern*:
+     *
+     * The {@link ExternalSystemArray} class can use *Proxy Pattern*. In framework within user, which
+     * {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
+     * important. Only interested in user's perspective is *which can be done*.
+     *
+     * By using the *logical proxy*, user dont't need to know which {@link ExternalSystemRole role} is belonged
+     * to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
+     * Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}.
+     *
+     * <ul>
+     *	<li>
+     *		{@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
+     *		from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
+     *	</li>
+     *	<li>
+     *		When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
+     *		{@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
+     *		external system.
+     *	</li>
+     *	<li> Those strategy is called *Proxy Pattern*. </li>
+     * </ul>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ParallelServerClientArrayMediator extends ParallelClientArrayMediator implements external.IExternalServerClientArray {
         /**
          * Default Constructor.
          */
         constructor();
-        sendData(invoke: Invoke): void;
-        protected _replyData(invoke: Invoke): void;
-        replyData(invoke: Invoke): void;
-    }
-}
-declare namespace samchon.protocol.parallel {
-    abstract class MediatorSystem extends slave.SlaveSystem {
-        private mediator_;
-        private progress_list_;
-        constructor(systemArray: ParallelSystemArrayMediator | distributed.DistributedSystemArrayMediator);
-        abstract start(): void;
-        getMediator(): ParallelSystemArrayMediator | distributed.DistributedSystemArrayMediator;
-        _Complete_history(uid: number): void;
-        protected _replyData(invoke: Invoke): void;
-        replyData(invoke: protocol.Invoke): void;
-    }
-}
-declare namespace samchon.protocol.parallel {
-    class MediatorServer extends MediatorSystem implements slave.ISlaveServer {
-        private server_base_;
-        private port;
-        constructor(systemArray: ParallelSystemArrayMediator, port: number);
-        protected createServerBase(): IServerBase;
-        addClient(driver: IClientDriver): void;
-        start(): void;
-        open(port: number): void;
-        close(): void;
-    }
-    class MediatorWebServer extends MediatorServer {
+        /**
+         * Factory method of a child Entity.
+         *
+         * This method is migrated to {@link createExternalServer}. Override the {@link createExternalServer} method.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A new child Entity via {@link createExternalServer createExternalServer()}.
+         */
+        createChild(xml: library.XML): ParallelSystem;
+        /**
+         * Factory method creating an {@link IParallelServer} object.
+         *
+         * @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
+         * @return A newly created {@link IParallelServer} object.
+         */
+        protected abstract createExternalServer(xml: library.XML): IParallelServer;
         /**
          * @inheritdoc
          */
-        protected createServerBase(): IServerBase;
-    }
-    class MediatorSharedWorkerServer extends MediatorServer {
-        /**
-         * @inheritdoc
-         */
-        protected createServerBase(): IServerBase;
-    }
-}
-declare namespace samchon.protocol.parallel {
-    class MediatorClient extends MediatorSystem implements slave.ISlaveClient {
-        protected ip: string;
-        protected port: number;
-        constructor(systemArray: ParallelSystemArrayMediator, ip: string, port: number);
-        protected createServerConnector(): IServerConnector;
-        getIP(): string;
-        getPort(): number;
-        start(): void;
         connect(): void;
     }
-    class MediatorWebClient extends MediatorClient {
-        /**
-         * @inheritdoc
-         */
-        protected createServerConnector(): IServerConnector;
-    }
-    class MediatorSharedWorkerClient extends MediatorClient {
-        /**
-         * @inheritdoc
-         */
-        protected createServerConnector(): IServerConnector;
-    }
 }
-declare namespace samchon.protocol.parallel {
-    class PRInvokeHistory extends InvokeHistory {
+declare namespace samchon.templates.parallel {
+    /**
+     * History of an {@link Invoke} message.
+     *
+     * The {@link PRInvokeHistory} is a class archiving history log of an {@link Invoke} message which requests the
+     * *parallel process*, created whenever {@link ParallelSystemArray.sendSegmentData} or
+     * {@link ParallelSystemArray.sendSegmentData} is called.
+     *
+     * When the *parallel process* has completed, then {@link complete complete()} is called and the *elapsed time* is
+     * determined. The elapsed time is utilized for computation of {@link ParallelSystem.getPerformance performance index}
+     * of each {@link ParallelSystem parallel slave system}.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		  target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_parallel_system.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Parallel System](https://github.com/samchon/framework/wiki/TypeScript-Templates-Parallel_System)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class PRInvokeHistory extends protocol.InvokeHistory {
         /**
-         * Index number of initial piece.
+         * @hidden
          */
         private first;
         /**
-         * Index number of final piece.
+         * @hidden
          */
         private last;
         /**
@@ -6134,195 +9691,245 @@ declare namespace samchon.protocol.parallel {
          */
         constructor();
         /**
-         * Construct from an Invoke message.
+         * Construct from an {@link Invoke} message.
          *
-         * @param invoke
+         * @param invoke An {@link Invoke} message requesting a *parallel process*.
+         */
+        constructor(invoke: protocol.Invoke);
+        /**
+         * Get initial piece's index.
+         *
+         * Returns initial piece's index in the section of requested *parallel process*.
+         *
+         * @return The initial index.
          */
-        constructor(invoke: Invoke);
         getFirst(): number;
+        /**
+         * Get final piece's index.
+         *
+         * Returns initial piece's index in the section of requested *parallel process*. The range used is
+         * [*first*, *last*), which contains all the pieces' indices between *first* and *last*, including the piece
+         * pointed by index *first*, but not the piece pointed by the index *last*.
+         *
+         * @return The final index.
+         */
         getLast(): number;
-        _Set_first(val: number): void;
-        _Set_last(val: number): void;
         /**
          * Compute number of allocated pieces.
          */
         computeSize(): number;
     }
 }
-declare namespace samchon.protocol.parallel {
-    abstract class ParallelClientArray extends ParallelSystemArray implements external.IExternalClientArray {
-        /**
-         * A subrogator of {@link IServer server}'s role instead of this {@link ExternalClientArray}.
-         */
-        private server_base_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * <p> Factory method creating {@link IServerBase} object. </p>
-         *
-         * <p> This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
-         * {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
-         * may connect to {@link ExternalClientArray this server} must follow the specified protocol. </p>
-         *
-         * <p> Creates and returns one of them: </p>
-         * <ul>
-         *	<li> {@link ServerBase} </li>
-         *	<li> {@link WebServerBase} </li>
-         *	<li> {@link SharedWorkerServerBase} </li>
-         * </ul>
-         *
-         * @return A new {@link IServerBase} object.
-         */
-        protected abstract createServerBase(): IServerBase;
-        addClient(driver: IClientDriver): void;
-        createChild(xml: library.XML): ParallelSystem;
-        protected abstract createExternalClient(driver: IClientDriver): ParallelSystem;
-        /**
-         * @inheritdoc
-         */
-        open(port: number): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-    }
-}
-declare namespace samchon.protocol.parallel {
-    abstract class ParallelSystemArrayMediator extends ParallelSystemArray {
-        private mediator_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        protected abstract createMediator(): MediatorSystem;
-        protected start_mediator(): void;
-        getMediator(): MediatorSystem;
-        _Complete_history(history: PRInvokeHistory): boolean;
-    }
-}
-declare namespace samchon.protocol.parallel {
-    abstract class ParallelClientArrayMediator extends ParallelSystemArrayMediator implements external.IExternalClientArray {
-        /**
-         * A subrogator of {@link IServer server}'s role instead of this {@link ExternalClientArray}.
-         */
-        private server_base_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * <p> Factory method creating {@link IServerBase} object. </p>
-         *
-         * <p> This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
-         * {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
-         * may connect to {@link ExternalClientArray this server} must follow the specified protocol. </p>
-         *
-         * <p> Creates and returns one of them: </p>
-         * <ul>
-         *	<li> {@link ServerBase} </li>
-         *	<li> {@link WebServerBase} </li>
-         *	<li> {@link SharedWorkerServerBase} </li>
-         * </ul>
-         *
-         * @return A new {@link IServerBase} object.
-         */
-        protected abstract createServerBase(): IServerBase;
-        addClient(driver: IClientDriver): void;
-        createChild(xml: library.XML): ParallelSystem;
-        protected abstract createExternalClient(driver: IClientDriver): ParallelSystem;
-        /**
-         * @inheritdoc
-         */
-        open(port: number): void;
-        /**
-         * @inheritdoc
-         */
-        close(): void;
-    }
-}
-declare namespace samchon.protocol.parallel {
-    interface IParallelServer extends external.IExternalServer, ParallelSystem {
-        /**
-         * @inheritdoc
-         */
-        getSystemArray(): ParallelSystemArray;
-    }
-    abstract class ParallelServer extends ParallelSystem implements external.IExternalServer {
-        protected ip: string;
-        protected port: number;
-        constructor(systemArray: ParallelSystemArray);
-        protected abstract createServerConnector(): IServerConnector;
-        connect(): void;
-        getIP(): string;
-        getPort(): number;
-    }
-}
-declare namespace samchon.protocol.parallel {
-    abstract class ParallelServerArray extends ParallelSystemArray implements external.IExternalServerArray {
-        constructor();
-        connect(): void;
-    }
-}
-declare namespace samchon.protocol.parallel {
-    abstract class ParallelServerArrayMediator extends ParallelSystemArrayMediator implements external.IExternalServerArray {
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.protocol.parallel {
-    abstract class ParallelServerClientArray extends ParallelClientArray implements external.IExternalServerClientArray {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        createChild(xml: library.XML): ParallelSystem;
-        protected abstract createExternalServer(xml: library.XML): IParallelServer;
-        connect(): void;
-    }
-}
-declare namespace samchon.protocol.parallel {
-    abstract class ParallelServerClientArrayMediator extends ParallelClientArrayMediator implements external.IExternalServerClientArray {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        createChild(xml: library.XML): ParallelSystem;
-        protected abstract createExternalServer(xml: library.XML): IParallelServer;
-        /**
-         * @inheritdoc
-         */
-        connect(): void;
-    }
-}
-declare namespace samchon.protocol.service {
+declare namespace samchon.templates.service {
+    /**
+     * A driver of remote client.
+     *
+     * The {@link Client} is an abstract class representing and interacting with a remote client. It deals the network
+     * communication with the remote client and shifts {@link Invoke} message to related {@link User} and {@link Service}
+     * objects.
+     *
+     * Extends this {@link Client} class and override the {@link createService} method, a factory method creating a child
+     * {@link Service} object. Note that, {@link Client} represents a remote client, not *an user*, a specific *web page*
+     * or *service*. Do not define logics about user or account information. It must be declared in the parent
+     * {@link User} class. Also, don't define processes of a specific a web page or service. Defines them in the child
+     * {@link Service} class.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png" target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
+     * @author Jeongho Nam <http://samchon.org>
+     */
     abstract class Client implements protocol.IProtocol {
+        /**
+         * @hidden
+         */
         private user_;
-        private service_;
-        private communicator_;
+        /**
+         * @hidden
+         */
         private no_;
         /**
-         * Construct from an User and WebClientDriver.
+         * @hidden
+         */
+        private communicator_;
+        /**
+         * @hidden
+         */
+        private service_;
+        /**
+         * Construct from parent {@link User} and communicator.
+         *
+         * @param user Parent {@link User} object.
+         * @param driver Communicator with remote client.
+         */
+        constructor(user: User, driver: protocol.WebClientDriver);
+        /**
+         * Default Destructor.
+         *
+         * This {@link destructor destructor()} method is called when the {@link Client} object is destructed and this
+         * {@link Client} object is destructed when connection with the remote client is closed or this {@link Client}
+         * object is {@link User.erase erased} from its parent {@link User} object.
+         *
+         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
+         * by those *destruction* cases. Also, if your derived {@link Client} class has something to do on the
+         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
+         * Overriding this {@link destructor destructor()}, don't forget to calling ```super.destructor();``` on tail.
+         *
+         * ```typescript
+         * class MyUser extends protocol.service.Client
+         * {
+         *     protected destructor(): void
+         *     {
+         *         // DO SOMETHING
+         *         this.do_something();
+         *
+         *         // CALL SUPER.DESTRUCTOR() ON TAIL. DON'T FORGET THIS
+         *         super.destructor();
+         *     }
+         * }
+         * ```
+         */
+        protected destructor(): void;
+        /**
+         * Factory method creating {@link Service} object.
+         *
+         * @param path Requested path.
+         * @return A newly created {@link Service} object or ```null```.
          */
-        constructor(user: User, driver: WebClientDriver);
         protected abstract createService(path: string): Service;
+        /**
+         * Close connection.
+         */
         close(): void;
+        /**
+         * Get parent {@link User} object.
+         *
+         * Get the parent {@link User} object, who is groupping {@link Client} objects with same session id.
+         *
+         * @return The parent {@link User} object.
+         */
         getUser(): User;
+        /**
+         * Get child {@link Service} object.
+         *
+         * @return The child {@link Service} object.
+         */
         getService(): Service;
+        /**
+         * Get sequence number.
+         *
+         * Get sequence number of this {@link Client} object in the parent {@link User} object. This sequence number also
+         * be a *key* in the parent {@link User} object, who extended the ```std.HashMap<number, Client>```.
+         *
+         * @return Sequence number.
+         */
         getNo(): number;
-        _Set_no(val: number): void;
-        sendData(invoke: protocol.Invoke): void;
-        replyData(invoke: protocol.Invoke): void;
+        /**
+         * Change related {@link Service} object.
+         *
+         * @param path Requested, identifier path.
+         */
         protected changeService(path: string): void;
+        /**
+         * Change {@link Service} to another.
+         *
+         * @param service {@link service} object to newly assigned.
+         */
+        protected changeService(service: Service): void;
+        /**
+         * Send an {@link Invoke} message.
+         *
+         * Sends an {@link Invoke} message to remote client.
+         *
+         * @param invoke An {@link Invoke} messgae to send to remote client.
+         */
+        sendData(invoke: protocol.Invoke): void;
+        /**
+         * Handle a replied {@link Invoke} message.
+         *
+         * The default {@link Client.replyData Client.replyData()} shifts chain to its parent {@link User} and belonged
+         * {@link Service} objects, by calling the the {@link User.replyData User.replyData()} and
+         * {@link Service.replyData Service.replyData()} methods.
+         *
+         * Note that, {@link Client} represents a remote client, not *an user*, a specific *web page* or *service*. Do not
+         * define logics about user or account information. It must be declared in the parent {@link User} class. Also,
+         * don't define processes of a specific a web page or service. Defines them in the child {@link Service} class.
+         *
+         * ```typescript
+         * class protocol.service.Client
+         * {
+         *     public replyData(invoke: protocol.Invoke): void
+         *     {
+         *         // SHIFT TO PARENT USER
+         *         // THE PARENT USER ALSO MAY SHIFT TO ITS PARENT SERVER
+         *         this.getUser().replyData(invoke);
+         *
+         *         // SHIFT TO BELOGED SERVICE
+         *         if (this.getService() != null)
+         *             this.getService().replyData(invoke);
+         *     }
+         * }
+         *
+         * class MyClient extends protocol.service.Client
+         * {
+         *     public replyData(invoke: protocol.Invoke): void
+         *     {
+         *         if (invoke.getListener() == "do_something_in_client_level")
+         *             this.do_something_in_client_level();
+         *         else
+         *             super.replyData(invoke);
+         *     }
+         * }
+         * ```
+         *
+         * @param invoke An {@link Invoke invoke} message to be handled in {@link Client} level.
+         */
+        replyData(invoke: protocol.Invoke): void;
     }
 }
-declare namespace samchon.protocol.service {
-    abstract class Server extends protocol.WebServer implements IProtocol {
+/**
+ * A system template for Cloud Service.
+ *
+ * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
+ * @author Jeongho Nam <http://samchon.org>
+ */
+declare namespace samchon.templates.service {
+    /**
+     * A cloud server.
+     *
+     * The {@link Server} is an abstract server class, who can build a real-time cloud server, that is following the
+     * web-socket protocol. Extends this {@link Server} and related classes and overrides abstract methods under below.
+     * After the overridings, open this {@link Server cloud server} using the {@link open open()} method.
+     *
+     * - Objects in composite relationship and their factory methods
+     *   - {@link User}: {@link Server.createUser Server.createUser()}
+     *   - {@link Client}: {@link User.createClient User.createClient()}
+     *   - {@link Service}: {@liok Client.createService Client.createService()}
+     * - {@link Invoke} message chains; {@link IProtocol.replyData replyData}
+     *   - {@link Server.replyData}
+     *   - {@link User.replyData}
+     *   - {@link Client.replyData}
+     *   - {@link Service.replyData}
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png" target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class Server extends protocol.WebServer implements protocol.IProtocol {
+        /**
+         * @hidden
+         */
         private session_map_;
+        /**
+         * @hidden
+         */
         private account_map_;
         /**
          * Default Constructor.
@@ -6334,80 +9941,348 @@ declare namespace samchon.protocol.service {
          * @return A newly created {@link User} object.
          */
         protected abstract createUser(): User;
-        has(account: string): boolean;
-        get(account: string): User;
+        /**
+         * Test wheter an {@link User} exists with the *accountID*.
+         *
+         * @param accountID Account id of {@link User} to find.
+         * @return Exists or not.
+         */
+        has(accountID: string): boolean;
+        /**
+         * Get an {@link User} object by its *accountID*.
+         *
+         * @param accountID Account id of {@link User} to get.
+         * @return An {@link User} object.
+         */
+        get(accountID: string): User;
+        /**
+         * Send an {@link Invoke} message.
+         *
+         * Sends an {@link Invoke} message to all remote clients through the belonged {@link User} and {@link Client}
+         * objects. Sending the {@link Invoke} message to all remote clients, it's came true by passing through
+         * {@link User.sendData User.sendData()}. And the {@link User.sendData} also pass through the
+         * {@link Client.sendData Client.sendData()}.
+         *
+         * ```typescript
+         * class protocol.service.Server
+         * {
+         *     public sendData(invoke: Invoke): void
+         *     {
+         *         for (user: User in this)
+         *             for (client: Client in user)
+         *                 client.sendData(invoke);
+         *     }
+         * }
+         * ```
+         *
+         * @param invoke {@link Invoke} message to send to all remote clients.
+         */
+        sendData(invoke: protocol.Invoke): void;
+        /**
+         * Handle a replied {@link Invoke} message.
+         *
+         * The {@link Server.replyData Server.replyData()} is an abstract method that handling {@link Invoke} message
+         * that should be handled in the {@link Server} level. Overrides this {@link replyData replyData()} method and
+         * defines what to do with the {@link Invoke} message in this {@link Server} level.
+         *
+         * @param invoke An {@link Invoke invoke} message to be handled in {@link Server} level.
+         */
+        abstract replyData(invoke: protocol.Invoke): void;
+        /**
+         * Add a newly connected remote client.
+         *
+         * When a {@link WebClientDriver remote client} connects to this cloud server, then {@link Server} queries the
+         * {WebClientDriver.getSessionID session id} of the {@link WebClientDriver remote client}. If the
+         * {WebClientDriver.getSessionID session id} is new one, then creates a new {@link User} object.
+         *
+         * At next, creates a {@link Client} object who represents the newly connected remote client and insert the
+         * {@link Client} object to the matched {@link User} object which is new or ordinary one following the
+         * {WebClientDriver.getSessionID session id}. At last, a {@link Service} object can be created with referencing
+         * the {@link WebClientDriver.getPath path}.
+         *
+         * List of objects can be created by this method.
+         * - {@link User} by {@link createUser createUser()}.
+         * - {@link Client} by {@link User.createClient User.createClient()}.
+         * - {@link Service} by {@link Client.createService Client.createService()}.
+         *
+         * @param driver A web communicator for remote client.
+         */
+        addClient(driver: protocol.WebClientDriver): void;
         /**
          * @hidden
          */
-        _Get_account_map(): std.HashMap<string, User>;
-        sendData(invoke: protocol.Invoke): void;
-        replyData(invoke: protocol.Invoke): void;
-        addClient(driver: WebClientDriver): void;
-        _Erase_user(user: User): void;
+        private erase_user(user);
     }
 }
-declare namespace samchon.protocol.service {
+declare namespace samchon.templates.service {
+    /**
+     * A service.
+     *
+     * The {@link Service} is an abstract class who represents a service, that is providing functions a specific page.
+     *
+     * Extends the {@link Service} class and defines its own service, which to be provided for the specific weg page,
+     * by overriding the {@link replyData replyData()} method. Note that, the service, functions for the specific page
+     * should be defined in this {@link Service} class, not its parent {@link Client} class who represents a remote client
+     * and takes communication responsibility.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png" target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
+     * @author Jeongho Nam <http://samchon.org>
+     */
     abstract class Service implements protocol.IProtocol {
+        /**
+         * @hidden
+         */
         private client_;
+        /**
+         * @hidden
+         */
         private path_;
         /**
-         * Default Constructor.
+         * Construct from parent {@link Client} and requested path.
+         *
+         * @param client Driver of remote client.
+         * @param path Requested path that identifies this {@link Service}.
          */
         constructor(client: Client, path: string);
-        destructor(): void;
+        /**
+         * Default Destructor.
+         *
+         * This {@link destructor destructor()} method is call when the {@link Service} object is destructed and the
+         * {@link Service} object is destructed when its parent {@link Client} object has
+         * {@link Client.destructor destructed} or the {@link Client} object {@link Client.changeService changed} its
+         * child {@link Service service} object to another one.
+         *
+         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
+         * by those *destruction* cases. Also, if your derived {@link Service} class has something to do on the
+         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
+         */
+        protected destructor(): void;
         /**
          * Get client.
          */
         getClient(): Client;
         /**
-         * Get path.
+         * Get requested path.
          */
         getPath(): string;
+        /**
+         * Send an {@link Invoke} message.
+         *
+         * Sends an {@link Invoke} message to remote system through parent {@link Client} object ({@link Client.sendData}).
+         *
+         * @param invoke An {@link Invoke} message to send to the remte system.
+         */
         sendData(invoke: protocol.Invoke): void;
-        replyData(invoke: protocol.Invoke): void;
+        /**
+         * @inheritdoc
+         */
+        abstract replyData(invoke: protocol.Invoke): void;
     }
 }
-declare namespace samchon.protocol.service {
-    abstract class User extends collection.HashMapCollection<number, Client> implements protocol.IProtocol {
-        private server_;
-        private session_id_;
-        private sequence_;
-        private account_id_;
-        private authority_;
-        /**
-         * Construct from a Server.
-         */
-        constructor(server: Server);
-        protected abstract createClient(driver: WebClientDriver): Client;
+declare namespace samchon.templates.service {
+    /**
+     * An user.
+     *
+     * The {@link User} is an abstract class groupping {@link Client} objects, who communicates with remote client, with
+     * same *session id*. This {link User} represents a *remote user* literally. Within framework of remote system,
+     * an {@link User} corresponds to a web-browser and a {@link Client} represents a window in the web-browser.
+     *
+     * Extends this {@link User} class and override the {@link createClient} method, a factory method creating a child
+     * {@link Client} object. I repeat, the {@link User} class represents a *remote user*, groupping {@link Client}
+     * objects with same *session id*. If your cloud server has some processes to be handled in the **user level**, then
+     * defines method in this {@link User} class. Methods managing **account** under below are some of them:
+     *
+     * - {@link setAccount setAccount()}
+     * - {@link getAccountID getAccountID()}
+     * - {@link getAuthority getAuthority()}
+     *
+     * The children {@link Client} objects, they're contained with their key, the {@link Client.getNo sequence number}.
+     * If you {@link User.erase erase} the children {@link Client} object by yourself, then their connection with the
+     * remote clients will be {@link Client.close closed} and their {@link Client.destructor destruction method} will be
+     * called. If you remove {@link clear all children}, then this {@link User} object will be also
+     * {@link destructor destructed} and erased from the parent {@link Server} object.
+     *
+     * <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png" target="_blank">
+     *	<img src="http://samchon.github.io/framework/images/design/ts_class_diagram/templates_cloud_service.png"
+     *		 style="max-width: 100%" />
+     * </a>
+     *
+     * @handbook [Templates - Cloud Service](https://github.com/samchon/framework/wiki/TypeScript-Templates-Cloud_Service)
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class User extends collections.HashMapCollection<number, Client> implements protocol.IProtocol {
         /**
          * @hidden
          */
-        _Create_child(driver: WebClientDriver): Client;
+        private server_;
+        /**
+         * @hidden
+         */
+        private session_id_;
+        /**
+         * @hidden
+         */
+        private sequence_;
+        /**
+         * @hidden
+         */
+        private account_id_;
+        /**
+         * @hidden
+         */
+        private authority_;
+        /**
+         * Construct from its parent {@link Server}.
+         *
+         * @param server The parent {@link Server} object.
+         */
+        constructor(server: Server);
+        /**
+         * Default Destructor.
+         *
+         * This {@link destructor destructor()} method is called when the {@link User} object is destructed. The
+         * {@link User} object is destructed when connections with the remote clients are all closed, that is all the
+         * children {@link Client} objects are all removed, and 30 seconds has left. If some remote client connects
+         * within the 30 seconds, then the {@link User} object doesn't be destructed.
+         *
+         * Note that, don't call this {@link destructor destructor()} method by yourself. It must be called automatically
+         * by those *destruction* cases. Also, if your derived {@link User} class has something to do on the
+         * *destruction*, then overrides this {@link destructor destructor()} method and defines the something to do.
+         * Overriding this {@link destructor destructor()}, don't forget to calling ```super.destructor();``` on tail.
+         *
+         * ```typescript
+         * class MyUser extends protocol.service.User
+         * {
+         *     protected destructor(): void
+         *     {
+         *         // DO SOMETHING
+         *         this.do_something();
+         *
+         *         // CALL SUPER.DESTRUCTOR() ON TAIL. DON'T FORGET THIS
+         *         super.destructor();
+         *     }
+         * }
+         * ```
+         */
+        protected destructor(): void;
+        /**
+         * Factory method creating a {@link Client} object.
+         *
+         * @param driver A web communicator for remote client.
+         * @return A newly created {@link Client} object.
+         */
+        protected abstract createClient(driver: protocol.WebClientDriver): Client;
         /**
          * @hidden
          */
         private handle_erase_client(event);
+        /**
+         * Get parent {@lin Server} object.
+         *
+         * @return Parent {@link Server} object.
+         */
         getServer(): Server;
+        /**
+         * Get account id.
+         *
+         * @return Account ID.
+         */
         getAccountID(): string;
+        /**
+         * Get authority.
+         *
+         * @return Authority
+         */
         getAuthority(): number;
+        /**
+         * Set *account id* and *authority*.
+         *
+         * The {@link setAccount setAccount()} is a method configuring *account id* and *authority* of this {@link User}.
+         *
+         * After the configuring, the {@link getAccountID account id} is enrolled into the parent {@link Server} as a
+         * **key** for this {@link User} object. You can test existence and access this {@link User} object from
+         * {@link Server.has Server.has()} and {@link Server.get Server.get()} with the {@link getAccountID account id}.
+         * Of course, if ordinary {@link getAccountID account id} had existed, then the ordinary **key** will be
+         * replaced.
+         *
+         * As you suggest, this {@link setAccount setAccount()} is something like a **log-in** function. If what you want
+         * is not **logging-in**, but **logging-out**, then configure the *account id* to empty string ``""```` or call
+         * the {@link lgout logout()} method.
+         *
+         * @param id To be account id.
+         * @param authority To be authority.
+         */
         setAccount(id: string, authority: number): void;
         /**
-         * @hidden
+         * Log-out.
+         *
+         * This {@link logout logout()} method configures {@link getAccountID account id} to empty string and
+         * {@link getAuthority authority} to zero.
+         *
+         * The ordinary {@link getAccountID account id} will be also erased from the parent {@link Server} object. You
+         * can't access this {@link User} object from {@link Server.has Server.has()} and {@link Server.get Server.get()}
+         * with the ordinary {@link getAccountID account id} more.
          */
-        _Get_session_id(): string;
+        logout(): void;
         /**
-         * @hidden
+         * Send an {@link Invoke} message.
+         *
+         * Sends an {@link Invoke} message to all remote clients through the belonged {@link Client} objects. Sending the
+         * {@link Invoke} message to all remote clients, it's came true by passing through the
+         * {@link Client.sendData Client.sendData()} methods.
+         *
+         * ```typescript
+         * class protocol.service.User
+         * {
+         *     public sendData(invoke: Invoke): void
+         *     {
+         *         for (let it = this.begin(); !it.equal_to(this.end()); it = it.next())
+         *             it.second.sendData(invoke);
+         *     }
+         * }
+         * ```
+         *
+         * @param invoke {@link Invoke} message to send to all remote clients.
          */
-        _Fetch_sequence(): number;
-        /**
-         * @hidden
-         */
-        _Set_session_id(val: string): void;
         sendData(invoke: protocol.Invoke): void;
+        /**
+         * Handle a replied {@link Invoke} message.
+         *
+         * The default {@link User.replyData User.replyData()} shifts chain to its parent {@link Server} object, by
+         * calling the {@link Server.replyData Server.replyData()} method. If there're some {@link Invoke} message to be
+         * handled in this {@link User} level, then override this method and defines what to do with the {@link Invoke}
+         * message in this {@link User} level.
+         *
+         * ```typescript
+         * class protocol.service.User
+         * {
+         *     public replyData(invoke: protocol.Invoke): void
+         *     {
+         *         this.getServer().replyData(invoke);
+         *     }
+         * }
+         *
+         * class MyUser extends protocol.service.User
+         * {
+         *     public replyData(invoke: protocol.Invoke): void
+         *     {
+         *          if (invoke.apply(this) == false) // IS TARGET TO BE HANDLED IN THIS USER LEVEL
+         *              super.replyData(invoke); // SHIFT TO SERVER
+         *     }
+         * }
+         * ```
+         *
+         * @param invoke An {@link Invoke invoke} message to be handled in {@link User} level.
+         */
         replyData(invoke: protocol.Invoke): void;
     }
 }
-declare namespace samchon.protocol.slave {
+declare namespace samchon.templates.slave {
     interface ISlaveClient extends SlaveSystem {
         connect(ip: string, port: number): void;
     }
@@ -6419,25 +10294,22 @@ declare namespace samchon.protocol.slave {
         /**
          * @inheritdoc
          */
-        protected abstract createServerConnector(): IServerConnector;
+        protected abstract createServerConnector(): protocol.IServerConnector;
         /**
          * @inheritdoc
          */
         connect(ip: string, port: number): void;
     }
 }
-declare namespace samchon.protocol.slave {
-    interface ISlaveServer extends SlaveSystem, IServer {
+declare namespace samchon.templates.slave {
+    interface ISlaveServer extends SlaveSystem, protocol.IServer {
     }
     abstract class SlaveServer extends SlaveSystem implements ISlaveServer {
         private server_base_;
         constructor();
-        protected abstract createServerBase(): IServerBase;
+        protected abstract createServerBase(): protocol.IServerBase;
         open(port: number): void;
         close(): void;
-        addClient(driver: IClientDriver): void;
+        addClient(driver: protocol.IClientDriver): void;
     }
 }
-declare namespace samchon.test {
-    function test_collection(): void;
-}
diff --git a/typescript-stl/index.d.ts b/typescript-stl/index.d.ts
index 35bd397459..e0a5a49700 100644
--- a/typescript-stl/index.d.ts
+++ b/typescript-stl/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for TypeScript-STL v1.1.0
+// Type definitions for TypeScript-STL v1.1.3
 // Project: https://github.com/samchon/typescript-stl
 // Definitions by: Jeongho Nam <http://samchon.org>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -22,93 +22,6 @@ declare module "typescript-stl"
  * @author Jeongho Nam <http://samchon.org>
  */
 declare namespace std {
-    /**
-     * Type definition of {@link Vector} and it's the original name used in C++.
-     */
-    export import vector = Vector;
-    /**
-     * Type definition of {@link List} and it's the original name used in C++.
-     */
-    export import list = List;
-    /**
-     * Type definition of {@link Deque} and it's the original name used in C++.
-     */
-    export import deque = Deque;
-    /**
-     * Type definition of {@link Stack} and it's the original name used in C++.
-     */
-    type stack<T> = Stack<T>;
-    /**
-     * Type definition of {@link Queue} and it's the original name used in C++.
-     */
-    type queue<T> = Queue<T>;
-    /**
-     * Type definition of {@link PriorityQueue} and it's the original name used in C++.
-     */
-    type priority_queue<T> = PriorityQueue<T>;
-    var stack: typeof Stack;
-    var queue: typeof Queue;
-    var priority_queue: typeof PriorityQueue;
-    /**
-     * Type definition of {@link TreeSet} and it's the original name used in C++.
-     */
-    export import set = TreeSet;
-    /**
-     * Type definition of {@link TreeMultiSet} and it's the original name used in C++.
-     */
-    export import multiset = TreeMultiSet;
-    /**
-     * Type definition of {@link HashSet} and it's the original name used in C++.
-     */
-    export import unordered_set = HashSet;
-    /**
-     * Type definition of {@link HashMultiSet} and it's the original name used in C++.
-     */
-    export import unordered_multiset = HashMultiSet;
-    /**
-     * Type definition of {@link TreeMap} and it's the original name used in C++.
-     */
-    export import map = TreeMap;
-    /**
-     * Type definition of {@link TreeMultiMap} and it's the original name used in C++.
-     */
-    export import multimap = TreeMultiMap;
-    /**
-     * Type definition of {@link HashMap} and it's the original name used in C++.
-     */
-    export import unordered_map = HashMap;
-    /**
-     * Type definition of {@link HashMultiMap} and it's the original name used in C++.
-     */
-    export import unordered_multimap = HashMultiMap;
-    type exception = Exception;
-    type logic_error = LogicError;
-    type domain_error = DomainError;
-    type invalid_argument = InvalidArgument;
-    type length_error = LengthError;
-    type out_of_range = OutOfRange;
-    type runtime_error = RuntimeError;
-    type overflow_error = OverflowError;
-    type underflow_error = UnderflowError;
-    type range_error = RangeError;
-    type system_error = SystemError;
-    type error_category = ErrorCategory;
-    type error_condition = ErrorCondition;
-    type error_code = ErrorCode;
-    var exception: typeof Exception;
-    var logic_error: typeof LogicError;
-    var domain_error: typeof DomainError;
-    var invalid_argument: typeof InvalidArgument;
-    var length_error: typeof LengthError;
-    var out_of_range: typeof OutOfRange;
-    var runtime_error: typeof RuntimeError;
-    var overflow_error: typeof OverflowError;
-    var underflow_error: typeof UnderflowError;
-    var range_error: typeof RangeError;
-    var system_error: typeof SystemError;
-    var error_category: typeof ErrorCategory;
-    var error_condition: typeof ErrorCondition;
-    var error_code: typeof ErrorCode;
 }
 /**
  * Base classes composing STL in background.
@@ -738,7 +651,7 @@ declare namespace std {
      *
      * @return An iterator to the end of the destination range where elements have been copied.
      */
-    function copy<T, InputIterator extends Iterator<T>, OutputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator): OutputIterator;
+    function copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator): OutputIterator;
     /**
      * <p> Copy elements. </p>
      *
@@ -762,7 +675,7 @@ declare namespace std {
      *
      * @return An iterator to the end of the destination range where elements have been copied.
      */
-    function copy_n<T, InputIterator extends Iterator<T>, OutputIterator extends Iterator<T>>(first: InputIterator, n: number, result: OutputIterator): OutputIterator;
+    function copy_n<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, n: number, result: OutputIterator): OutputIterator;
     /**
      * <p> Copy certain elements of range. </p>
      *
@@ -781,7 +694,7 @@ declare namespace std {
      *
      * @return An iterator to the end of the destination range where elements have been copied.
      */
-    function copy_if<T, InputIterator extends Iterator<T>, OutputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (x: T) => boolean): OutputIterator;
+    function copy_if<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (x: T) => boolean): OutputIterator;
     /**
      * <p> Copy range of elements backward. </p>
      *
@@ -808,7 +721,7 @@ declare namespace std {
      *
      * @return An iterator to the first element of the destination sequence where elements have been copied.
      */
-    function copy_backward<T, BidirectionalIterator1 extends Iterator<T>, BidirectionalIterator2 extends Iterator<T>>(first: BidirectionalIterator1, last: BidirectionalIterator1, result: BidirectionalIterator2): BidirectionalIterator2;
+    function copy_backward<T, BidirectionalIterator1 extends Iterator<T>, BidirectionalIterator2 extends base.ILinearIterator<T>>(first: BidirectionalIterator1, last: BidirectionalIterator1, result: BidirectionalIterator2): BidirectionalIterator2;
     /**
      * <p> Fill range with value. </p>
      *
@@ -822,7 +735,7 @@ declare namespace std {
      *				but not the element pointed by <i>last</i>.
      * @param val Value to assign to the elements in the filled range.
      */
-    function fill<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T): void;
+    function fill<T, ForwardIterator extends base.ILinearIterator<T>>(first: ForwardIterator, last: ForwardIterator, val: T): void;
     /**
      * <p> Fill sequence with value. </p>
      *
@@ -835,7 +748,7 @@ declare namespace std {
      *
      * @return An iterator pointing to the element that follows the last element filled.
      */
-    function fill_n<T, OutputIterator extends Iterator<T>>(first: OutputIterator, n: number, val: T): OutputIterator;
+    function fill_n<T, OutputIterator extends base.ILinearIterator<T>>(first: OutputIterator, n: number, val: T): OutputIterator;
     /**
      * <p> Transform range. </p>
      *
@@ -853,7 +766,7 @@ declare namespace std {
      *
      * @return An iterator pointing to the element that follows the last element written in the <i>result</i> sequence.
      */
-    function transform<T, InputIterator extends Iterator<T>, OutputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, op: (val: T) => T): OutputIterator;
+    function transform<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, op: (val: T) => T): OutputIterator;
     /**
      * <p> Transform range. </p>
      *
@@ -874,7 +787,7 @@ declare namespace std {
      *
      * @return An iterator pointing to the element that follows the last element written in the <i>result</i> sequence.
      */
-    function transform<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, result: OutputIterator, binary_op: (x: T, y: T) => T): OutputIterator;
+    function transform<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, result: OutputIterator, binary_op: (x: T, y: T) => T): OutputIterator;
     /**
      * <p> Generate values for range with function. </p>
      *
@@ -888,7 +801,7 @@ declare namespace std {
      * @param gen Generator function that is called with no arguments and returns some value of a type convertible to
      *			  those pointed by the iterators.
      */
-    function generate<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, gen: () => T): void;
+    function generate<T, ForwardIterator extends base.ILinearIterator<T>>(first: ForwardIterator, last: ForwardIterator, gen: () => T): void;
     /**
      * <p> Generate values for sequence with function. </p>
      *
@@ -903,7 +816,7 @@ declare namespace std {
      *
      * @return An iterator pointing to the element that follows the last element whose value has been generated.
      */
-    function generate_n<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, n: number, gen: () => T): ForwardIterator;
+    function generate_n<T, ForwardIterator extends base.ILinearIterator<T>>(first: ForwardIterator, n: number, gen: () => T): ForwardIterator;
     /**
      * <p> Remove consecutive duplicates in range. </p>
      *
@@ -975,7 +888,7 @@ declare namespace std {
      *
      * @return An iterator pointing to the end of the copied range, which contains no consecutive duplicates.
      */
-    function unique_copy<T, InputIterator extends Iterator<T>, OutputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator): OutputIterator;
+    function unique_copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator): OutputIterator;
     /**
      * <p> Copy range removing duplicates. </p>
      *
@@ -1001,7 +914,7 @@ declare namespace std {
      *
      * @return An iterator pointing to the end of the copied range, which contains no consecutive duplicates.
      */
-    function unique_copy<T, InputIterator extends Iterator<T>, OutputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (x: T, y: T) => boolean): OutputIterator;
+    function unique_copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (x: T, y: T) => boolean): OutputIterator;
     /**
      * <p> Remove value from range. </p>
      *
@@ -1069,7 +982,7 @@ declare namespace std {
      * @return An iterator pointing to the end of the copied range, which includes all the elements in
      *		   [<i>first</i>, <i>last</i>) except those that compare equal to <i>val</i>.
      */
-    function remove_copy<T, InputIterator extends Iterator<T>, OutputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, val: T): OutputIterator;
+    function remove_copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, val: T): OutputIterator;
     /**
      * <p> Copy range removing values. </p>
      *
@@ -1093,7 +1006,7 @@ declare namespace std {
      * @return An iterator pointing to the end of the copied range, which includes all the elements in
      *		   [<i>first</i>, <i>last</i>) except those for which <i>pred</i> returns <code>true</code>.
      */
-    function remove_copy_if<T, InputIterator extends Iterator<T>, OutputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (val: T) => boolean): OutputIterator;
+    function remove_copy_if<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (val: T) => boolean): OutputIterator;
     /**
      * <p> Replace value in range. </p>
      *
@@ -1109,7 +1022,7 @@ declare namespace std {
      * @param old_val Value to be replaced.
      * @param new_val Replacement value.
      */
-    function replace<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, old_val: T, new_val: T): void;
+    function replace<T, InputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, old_val: T, new_val: T): void;
     /**
      * <p> Replace value in range. </p>
      *
@@ -1125,7 +1038,7 @@ declare namespace std {
      *			   <code>true</code>, it is replaced). The function shall not modify its argument.
      * @param new_val Value to assign to replaced elements.
      */
-    function replace_if<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean, new_val: T): void;
+    function replace_if<T, InputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean, new_val: T): void;
     /**
      * <p> Copy range replacing value. </p>
      *
@@ -1149,7 +1062,7 @@ declare namespace std {
      *
      * @return An iterator pointing to the element that follows the last element written in the result sequence.
      */
-    function replace_copy<T, InputIterator extends Iterator<T>, OutputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, old_val: T, new_val: T): OutputIterator;
+    function replace_copy<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, old_val: T, new_val: T): OutputIterator;
     /**
      * <p> Copy range replacing value. </p>
      *
@@ -1170,7 +1083,7 @@ declare namespace std {
      *
      * @return An iterator pointing to the element that follows the last element written in the result sequence.
      */
-    function replace_copy_if<T, InputIterator extends Iterator<T>, OutputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (val: T) => boolean, new_val: T): OutputIterator;
+    function replace_copy_if<T, InputIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator, pred: (val: T) => boolean, new_val: T): OutputIterator;
     /**
      * <p> Exchange values of objects pointed to by two iterators. </p>
      *
@@ -1230,7 +1143,7 @@ declare namespace std {
      * @return An output iterator pointing to the end of the copied range, which contains the same elements in reverse
      *		   order.
      */
-    function reverse_copy<T, BidirectionalIterator extends Iterator<T>, OutputIterator extends Iterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator, result: OutputIterator): OutputIterator;
+    function reverse_copy<T, BidirectionalIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: BidirectionalIterator, last: BidirectionalIterator, result: OutputIterator): OutputIterator;
     /**
      * <p> Rotate left the elements in range. </p>
      *
@@ -1266,7 +1179,7 @@ declare namespace std {
      *
      * @return An output iterator pointing to the end of the copied range.
      */
-    function rotate_copy<T, ForwardIterator extends Iterator<T>, OutputIterator extends Iterator<T>>(first: ForwardIterator, middle: ForwardIterator, last: ForwardIterator, result: OutputIterator): OutputIterator;
+    function rotate_copy<T, ForwardIterator extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first: ForwardIterator, middle: ForwardIterator, last: ForwardIterator, result: OutputIterator): OutputIterator;
     /**
      * <p> Randomly rearrange elements in range. </p>
      *
@@ -2147,7 +2060,7 @@ declare namespace std {
      *		   member {@link Pair.second second} points to the element that follows the last element copied to the sequence
      *		   of elements for which <i>pred</i> returned <code>false</code>.
      */
-    function partition_copy<T, InputIterator extends Iterator<T>, OutputIterator1 extends Iterator<T>, OutputIterator2 extends Iterator<T>>(first: InputIterator, last: InputIterator, result_true: OutputIterator1, result_false: OutputIterator2, pred: (val: T) => T): Pair<OutputIterator1, OutputIterator2>;
+    function partition_copy<T, InputIterator extends Iterator<T>, OutputIterator1 extends base.ILinearIterator<T>, OutputIterator2 extends base.ILinearIterator<T>>(first: InputIterator, last: InputIterator, result_true: OutputIterator1, result_false: OutputIterator2, pred: (val: T) => T): Pair<OutputIterator1, OutputIterator2>;
     /**
      * <p> Get partition point. </p>
      *
@@ -2196,7 +2109,7 @@ declare namespace std {
      *
      * @return An iterator pointing to the past-the-end element in the resulting sequence.
      */
-    function merge<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
+    function merge<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
     /**
      * <p> Merge sorted ranges. </p>
      *
@@ -2222,7 +2135,7 @@ declare namespace std {
      *
      * @return An iterator pointing to the past-the-end element in the resulting sequence.
      */
-    function merge<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
+    function merge<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
     /**
      * <p> Merge consecutive sorted ranges. </p>
      *
@@ -2353,7 +2266,7 @@ declare namespace std {
      *
      * @return An iterator to the end of the constructed range.
      */
-    function set_union<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
+    function set_union<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
     /**
      * <p> Union of two sorted ranges. </p>
      *
@@ -2386,7 +2299,7 @@ declare namespace std {
      *
      * @return An iterator to the end of the constructed range.
      */
-    function set_union<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
+    function set_union<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
     /**
      * <p> Intersection of two sorted ranges. </p>
      *
@@ -2414,7 +2327,7 @@ declare namespace std {
      *
      * @return An iterator to the end of the constructed range.
      */
-    function set_intersection<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
+    function set_intersection<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
     /**
      * <p> Intersection of two sorted ranges. </p>
      *
@@ -2446,7 +2359,7 @@ declare namespace std {
      *
      * @return An iterator to the end of the constructed range.
      */
-    function set_intersection<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
+    function set_intersection<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
     /**
      * <p> Difference of two sorted ranges. </p>
      *
@@ -2480,7 +2393,7 @@ declare namespace std {
      *
      * @return An iterator to the end of the constructed range.
      */
-    function set_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
+    function set_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
     /**
      * <p> Difference of two sorted ranges. </p>
      *
@@ -2518,7 +2431,7 @@ declare namespace std {
      *
      * @return An iterator to the end of the constructed range.
      */
-    function set_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
+    function set_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
     /**
      * <p> Symmetric difference of two sorted ranges. </p>
      *
@@ -2552,7 +2465,7 @@ declare namespace std {
      *
      * @return An iterator to the end of the constructed range.
      */
-    function set_symmetric_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
+    function set_symmetric_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator): OutputIterator;
     /**
      * <p> Symmetric difference of two sorted ranges. </p>
      *
@@ -2586,7 +2499,7 @@ declare namespace std {
      *
      * @return An iterator to the end of the constructed range.
      */
-    function set_symmetric_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends Iterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
+    function set_symmetric_difference<T, InputIterator1 extends Iterator<T>, InputIterator2 extends Iterator<T>, OutputIterator extends base.ILinearIterator<T>>(first1: InputIterator1, last1: InputIterator1, first2: InputIterator2, last2: InputIterator2, result: OutputIterator, compare: (x: T, y: T) => boolean): OutputIterator;
 }
 declare namespace std {
     /**
@@ -2751,6 +2664,46 @@ declare namespace std {
      */
     function minmax_element<T, ForwardIterator extends Iterator<T>>(first: ForwardIterator, last: ForwardIterator, compare: (x: T, y: T) => boolean): Pair<ForwardIterator, ForwardIterator>;
 }
+declare namespace std.base {
+    /**
+     * <p> Static class holding enumeration codes of color of Red-black tree. </p>
+     *
+     * <p> Color codes imposed to nodes of RB-Tree are following those rules: </p>
+     *
+     * <ol>
+     *	<li> A node is either <font color='red'>red</font> or <font color='darkBlue'>black</font>. </li>
+     *	<li> The root is <font color='darkBlue'>black</font>. This rule is sometimes omitted. Since the root can
+     *		 always be changed from <font color='red'>red</font> to <font color='darkBlue'>black</font>, but not
+     *		 necessarily vice versa, this rule has little effect on analysis. </li>
+     *	<li> All leaves (NIL; <code>null</code>) are <font color='darkBlue'>black</font>. </li>
+     *  <li> If a node is <font color='red'>red</font>, then both its children are
+     *		 <font color='darkBlue'>black</font>. </li>
+     *  <li> Every path from a given node to any of its descendant NIL nodes contains the same number of
+     *		 <font color='darkBlue'>black</font> nodes. Some definitions: the number of
+     *		 <font color='darkBlue'>black</font> nodes from the root to a node is the node's
+     *		 <font color='darkBlue'>black</font> depth; the uniform number of <font color='darkBlue'>black</font>
+     *		 nodes in all paths from root to the leaves is called the <font color='darkBlue'>black</font>-height of
+     *		 the red-black tree. </li>
+     * </ol>
+     *
+     * @author Migrated by Jeongho Nam <http://samchon.org>
+     */
+    enum Color {
+        /**
+         * <p> Code of color black. </p>
+         *
+         * <ul>
+         *	<li> Those are clearly black: root, leaf nodes or children nodes of red. </li>
+         *	<li> Every path from a given nodes containes the same number of black nodes exclude NIL(s). </li>
+         * </ul>
+         */
+        BLACK = 0,
+        /**
+         * <p> Code of color red. </p>
+         */
+        RED = 1,
+    }
+}
 declare namespace std.base {
     /**
      * <p> An abstract container. </p>
@@ -2844,7 +2797,7 @@ declare namespace std.base {
         /**
          * @inheritdoc
          */
-        abstract push<U extends T>(...items: U[]): number;
+        abstract push(...items: T[]): number;
         /**
          * @inheritdoc
          */
@@ -2863,5021 +2816,6 @@ declare namespace std.base {
         swap(obj: IContainer<T>): void;
     }
 }
-declare namespace std {
-    /**
-     * <p> Bi-directional iterator. </p>
-     *
-     * <p> {@link Iterator Bidirectional iterators} are iterators that can be used to access the sequence of elements
-     * in a range in both directions (towards the end and towards the beginning). </p>
-     *
-     * <p> All {@link IArrayIterator random-access iterators} are also valid {@link Iterrator bidirectional iterators}.
-     * </p>
-     *
-     * <p> There is not a single type of {@link Iterator bidirectional iterator}: {@link IContainer Each container}
-     * may define its own specific iterator type able to iterate through it and access its elements. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * @reference http://www.cplusplus.com/reference/iterator/BidirectionalIterator
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class Iterator<T> {
-        /**
-         * Source container of the iterator is directing for.
-         */
-        protected source_: base.IContainer<T>;
-        /**
-         * Construct from the source {@link IContainer container}.
-         *
-         * @param source The source
-         */
-        constructor(source: base.IContainer<T>);
-        /**
-         * <p> Get iterator to previous element. </p>
-         * <p> If current iterator is the first item(equal with {@link IContainer.begin IContainer.begin()}),
-         * returns {@link IContainer.end IContainer.end()}. </p>
-         *
-         * @return An iterator of the previous item.
-         */
-        abstract prev(): Iterator<T>;
-        /**
-         * <p> Get iterator to next element. </p>
-         * <p> If current iterator is the last item, returns {@link IContainer.end IContainer.end()}. </p>
-         *
-         * @return An iterator of the next item.
-         */
-        abstract next(): Iterator<T>;
-        /**
-         * Advances the {@link Iterator} by <i>n</i> element positions.
-         *
-         * @param n Number of element positions to advance.
-         * @return An advanced iterator.
-         */
-        advance(n: number): Iterator<T>;
-        /**
-         * Get source
-         */
-        get_source(): base.IContainer<T>;
-        /**
-         * <p> Whether an iterator is equal with the iterator. </p>
-         *
-         * <p> Compare two iterators and returns whether they are equal or not. </p>
-         *
-         * <h4> Note </h4>
-         * <p> Iterator's equal_to() only compare souce container and index number. </p>
-         *
-         * <p> Although elements in a pair, key and value are equal_to, if the source map or
-         * index number is different, then the {@link equal_to equal_to()} will return false. If you want to
-         * compare the elements of a pair, compare them directly by yourself. </p>
-         *
-         * @param obj An iterator to compare
-         * @return Indicates whether equal or not.
-         */
-        equal_to<U extends T>(obj: Iterator<U>): boolean;
-        /**
-         * <p> Get value of the iterator is pointing. </p>
-         *
-         * @return A value of the iterator.
-         */
-        value: T;
-        abstract swap(obj: Iterator<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> This class reverses the direction in which a bidirectional or random-access iterator iterates through a range.
-     * </p>
-     *
-     * <p> A copy of the original iterator (the {@link Iterator base iterator}) is kept internally and used to reflect
-     * the operations performed on the {@link ReverseIterator}: whenever the {@link ReverseIterator} is incremented, its
-     * {@link Iterator base iterator} is decreased, and vice versa. A copy of the {@link Iterator base iterator} with the
-     * current state can be obtained at any time by calling member {@link base}. </p>
-     *
-     * <p> Notice however that when an iterator is reversed, the reversed version does not point to the same element in
-     * the range, but to <b>the one preceding it</b>. This is so, in order to arrange for the past-the-end element of a
-     * range: An iterator pointing to a past-the-end element in a range, when reversed, is pointing to the last element
-     * (not past it) of the range (this would be the first element of the reversed range). And if an iterator to the
-     * first element in a range is reversed, the reversed iterator points to the element before the first element (this
-     * would be the past-the-end element of the reversed range). </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * @reference http://www.cplusplus.com/reference/iterator/reverse_iterator
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ReverseIterator<T, Base extends Iterator<T>, This extends ReverseIterator<T, Base, This>> extends Iterator<T> {
-        /**
-         * @hidden
-         */
-        protected base_: Base;
-        /**
-         * Construct from base iterator.
-         *
-         * @param base A reference of the base iterator, which iterates in the opposite direction.
-         */
-        constructor(base: Base);
-        /**
-         * <p> Return base iterator. </p>
-         *
-         * <p> Return a reference of the base iteraotr. </p>
-         *
-         * <p> The base iterator is an iterator of the same type as the one used to construct the {@link ReverseIterator},
-         * but pointing to the element next to the one the {@link ReverseIterator} is currently pointing to
-         * (a {@link ReverseIterator} has always an offset of -1 with respect to its base iterator).
-         *
-         * @return A reference of the base iterator, which iterates in the opposite direction.
-         */
-        base(): Base;
-        /**
-         * @hidden
-         */
-        protected abstract create_neighbor(base: Base): This;
-        /**
-         * <p> Get value of the iterator is pointing. </p>
-         *
-         * @return A value of the reverse iterator.
-         */
-        value: T;
-        /**
-         * @inheritdoc
-         */
-        prev(): This;
-        /**
-         * @inheritdoc
-         */
-        next(): This;
-        /**
-         * @inheritdoc
-         */
-        advance(n: number): This;
-        /**
-         * @inheritdoc
-         */
-        equal_to(obj: This): boolean;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: This): void;
-    }
-    /**
-     * <p> Return distance between {@link Iterator iterators}. </p>
-     *
-     * <p> Calculates the number of elements between <i>first</i> and <i>last</i>. </p>
-     *
-     * <p> If it is a {@link IArrayIterator random-access iterator}, the function uses operator- to calculate this.
-     * Otherwise, the function uses the increase operator {@link Iterator.next next()} repeatedly. </p>
-     *
-     * @param first Iterator pointing to the initial element.
-     * @param last Iterator pointing to the final element. This must be reachable from first.
-     *
-     * @return The number of elements between first and last.
-     */
-    function distance<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator): number;
-    /**
-     * <p> Advance iterator. </p>
-     *
-     * <p> Advances the iterator <i>it</i> by <i>n</i> elements positions. </p>
-     *
-     * @param it Iterator to be advanced.
-     * @param n Number of element positions to advance.
-     *
-     * @return An iterator to the element <i>n</i> positions before <i>it</i>.
-     */
-    function advance<T, InputIterator extends Iterator<T>>(it: InputIterator, n: number): InputIterator;
-    /**
-     * <p> Get iterator to previous element. </p>
-     *
-     * <p> Returns an iterator pointing to the element that <i>it</i> would be pointing to if advanced <i>-n</i> positions. </p>
-     *
-     * @param it Iterator to base position.
-     * @param n Number of element positions offset (1 by default).
-     *
-     * @return An iterator to the element <i>n</i> positions before <i>it</i>.
-     */
-    function prev<T, BidirectionalIterator extends Iterator<T>>(it: BidirectionalIterator, n?: number): BidirectionalIterator;
-    /**
-     * <p> Get iterator to next element. </p>
-     *
-     * <p> Returns an iterator pointing to the element that <i>it</i> would be pointing to if advanced <i>n</i> positions. </p>
-     *
-     * @param it Iterator to base position.
-     * @param n Number of element positions offset (1 by default).
-     *
-     * @return An iterator to the element <i>n</i> positions away from <i>it</i>.
-     */
-    function next<T, ForwardIterator extends Iterator<T>>(it: ForwardIterator, n?: number): ForwardIterator;
-    /**
-     * <p> Iterator to beginning. </p>
-     *
-     * <p> Returns an iterator pointing to the first element in the sequence. </p>
-     *
-     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
-     *
-     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
-     *
-     * @return The same as returned by {@link IContainer.begin container.begin()}.
-     */
-    function begin<T>(container: Vector<T>): VectorIterator<T>;
-    /**
-     * <p> Iterator to beginning. </p>
-     *
-     * <p> Returns an iterator pointing to the first element in the sequence. </p>
-     *
-     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
-     *
-     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
-     *
-     * @return The same as returned by {@link IContainer.begin container.begin()}.
-     */
-    function begin<T>(container: List<T>): ListIterator<T>;
-    /**
-     * <p> Iterator to beginning. </p>
-     *
-     * <p> Returns an iterator pointing to the first element in the sequence. </p>
-     *
-     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
-     *
-     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
-     *
-     * @return The same as returned by {@link IContainer.begin container.begin()}.
-     */
-    function begin<T>(container: Deque<T>): DequeIterator<T>;
-    /**
-     * <p> Iterator to beginning. </p>
-     *
-     * <p> Returns an iterator pointing to the first element in the sequence. </p>
-     *
-     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
-     *
-     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
-     *
-     * @return The same as returned by {@link IContainer.begin container.begin()}.
-     */
-    function begin<T>(container: base.SetContainer<T>): SetIterator<T>;
-    /**
-     * <p> Iterator to beginning. </p>
-     *
-     * <p> Returns an iterator pointing to the first element in the sequence. </p>
-     *
-     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
-     *
-     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
-     *
-     * @return The same as returned by {@link IContainer.begin container.begin()}.
-     */
-    function begin<Key, T>(container: base.MapContainer<Key, T>): MapIterator<Key, T>;
-    /**
-     * <p> Iterator to end. </p>
-     *
-     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
-     *
-     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
-     *
-     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
-     *
-     * @return The same as returned by {@link IContainer.end container.end()}.
-     */
-    function end<T>(container: Vector<T>): VectorIterator<T>;
-    /**
-     * <p> Iterator to end. </p>
-     *
-     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
-     *
-     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
-     *
-     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
-     *
-     * @return The same as returned by {@link IContainer.end container.end()}.
-     */
-    function end<T>(container: List<T>): ListIterator<T>;
-    /**
-     * <p> Iterator to end. </p>
-     *
-     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
-     *
-     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
-     *
-     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
-     *
-     * @return The same as returned by {@link IContainer.end container.end()}.
-     */
-    function end<T>(container: Deque<T>): DequeIterator<T>;
-    /**
-     * <p> Iterator to end. </p>
-     *
-     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
-     *
-     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
-     *
-     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
-     *
-     * @return The same as returned by {@link IContainer.end container.end()}.
-     */
-    function end<T>(container: base.SetContainer<T>): SetIterator<T>;
-    /**
-     * <p> Iterator to end. </p>
-     *
-     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
-     *
-     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
-     *
-     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
-     *
-     * @return The same as returned by {@link IContainer.end container.end()}.
-     */
-    function end<Key, T>(container: base.MapContainer<Key, T>): MapIterator<Key, T>;
-}
-declare namespace std.Deque {
-    type iterator<T> = std.DequeIterator<T>;
-    type reverse_iterator<T> = std.DequeReverseIterator<T>;
-}
-declare namespace std {
-    /**
-     * <p> Double ended queue. </p>
-     *
-     * <p> {@link Deque} (usually pronounced like "<i>deck</i>") is an irregular acronym of
-     * <b>d</b>ouble-<b>e</b>nded <b>q</b>ueue. Double-ended queues are sequence containers with dynamic sizes that can be
-     * expanded or contracted on both ends (either its front or its back). </p>
-     *
-     * <p> Specific libraries may implement deques in different ways, generally as some form of dynamic array. But in any
-     * case, they allow for the individual elements to be accessed directly through random access iterators, with storage
-     * handled automatically by expanding and contracting the container as needed. </p>
-     *
-     * <p> Therefore, they provide a functionality similar to vectors, but with efficient insertion and deletion of
-     * elements also at the beginning of the sequence, and not only at its end. But, unlike {@link Vector Vectors},
-     * {@link Deque Deques} are not guaranteed to store all its elements in contiguous storage locations: accessing
-     * elements in a <u>deque</u> by offsetting a pointer to another element causes undefined behavior. </p>
-     *
-     * <p> Both {@link Vector}s and {@link Deque}s provide a very similar interface and can be used for similar purposes,
-     * but internally both work in quite different ways: While {@link Vector}s use a single array that needs to be
-     * occasionally reallocated for growth, the elements of a {@link Deque} can be scattered in different chunks of
-     * storage, with the container keeping the necessary information internally to provide direct access to any of its
-     * elements in constant time and with a uniform sequential interface (through iterators). Therefore,
-     * {@link Deque Deques} are a little more complex internally than {@link Vector}s, but this allows them to grow more
-     * efficiently under certain circumstances, especially with very long sequences, where reallocations become more
-     * expensive. </p>
-     *
-     * <p> For operations that involve frequent insertion or removals of elements at positions other than the beginning or
-     * the end, {@link Deque Deques} perform worse and have less consistent iterators and references than
-     * {@link List Lists}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /> </a>
-     * </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Sequence </dt>
-     *	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements
-     *		 are accessed by their position in this sequence. </dd>
-     *
-     *	<dt> Dynamic array </dt>
-     *	<dd> Generally implemented as a dynamic array, it allows direct access to any element in the
-     *		 sequence and provides relatively fast addition/removal of elements at the beginning or the end
-     *		 of the sequence. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @reference http://www.cplusplus.com/reference/deque/deque/
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class Deque<T> extends base.Container<T> implements base.IArrayContainer<T>, base.IDequeContainer<T> {
-        /**
-         * @hidden
-         */
-        private static ROW;
-        /**
-         * @hidden
-         */
-        private static MIN_CAPACITY;
-        /**
-         * @hidden
-         */
-        private matrix_;
-        /**
-         * @hidden
-         */
-        private size_;
-        /**
-         * @hidden
-         */
-        private capacity_;
-        /**
-         * @hidden
-         */
-        private get_col_size();
-        /**
-         * <p> Default Constructor. </p>
-         *
-         * <p> Constructs an empty container, with no elements. </p>
-         */
-        constructor();
-        /**
-         * <p> Initializer list Constructor. </p>
-         *
-         * <p> Constructs a container with a copy of each of the elements in <i>array</i>, in the same order. </p>
-         *
-         * @param array An array containing elements to be copied and contained.
-         */
-        constructor(items: Array<T>);
-        /**
-         * <p> Fill Constructor. </p>
-         *
-         * <p> Constructs a container with <i>n</i> elements. Each element is a copy of <i>val</i> (if provided). </p>
-         *
-         * @param n Initial container size (i.e., the number of elements in the container at construction).
-         * @param val Value to fill the container with. Each of the <i>n</i> elements in the container is
-         *			  initialized to a copy of this value.
-         */
-        constructor(size: number, val: T);
-        /**
-         * <p> Copy Constructor. </p>
-         *
-         * <p> Constructs a container with a copy of each of the elements in <i>container</i>, in the same order. </p>
-         *
-         * @param container Another container object of the same type (with the same class template
-         *					arguments <i>T</i>), whose contents are either copied or acquired.
-         */
-        constructor(container: Deque<T>);
-        /**
-         * <p> Range Constructor. </p>
-         *
-         * <p> Constructs a container with as many elements as the range (<i>begin</i>, <i>end<i>), with each
-         * element emplace-constructed from its corresponding element in that range, in the same order. </p>
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * @inheritdoc
-         */
-        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        assign(n: number, val: T): void;
-        /**
-         * @inheritdoc
-         */
-        reserve(capacity: number): void;
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        begin(): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): DequeReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): DequeReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        size(): number;
-        /**
-         * @inheritdoc
-         */
-        empty(): boolean;
-        /**
-         * @inheritdoc
-         */
-        capacity(): number;
-        /**
-         * @inheritdoc
-         */
-        at(index: number): T;
-        /**
-         * @inheritdoc
-         */
-        set(index: number, val: T): void;
-        /**
-         * @inheritdoc
-         */
-        front(): T;
-        /**
-         * @inheritdoc
-         */
-        back(): T;
-        /**
-        // Fetch row and column's index.
-        /**
-         * @hidden
-         */
-        private fetch_index(index);
-        /**
-         * @inheritdoc
-         */
-        push(...items: T[]): number;
-        /**
-         * @inheritdoc
-         */
-        push_front(val: T): void;
-        /**
-         * @inheritdoc
-         */
-        push_back(val: T): void;
-        /**
-         * @inheritdoc
-         */
-        pop_front(): void;
-        /**
-         * @inheritdoc
-         */
-        pop_back(): void;
-        /**
-         * @inheritdoc
-         */
-        insert(position: DequeIterator<T>, val: T): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert(position: DequeIterator<T>, n: number, val: T): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(position: DequeIterator<T>, begin: InputIterator, end: InputIterator): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert(position: DequeReverseIterator<T>, val: T): DequeReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert(position: DequeReverseIterator<T>, n: number, val: T): DequeReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(position: DequeReverseIterator<T>, begin: InputIterator, end: InputIterator): DequeReverseIterator<T>;
-        /**
-         * @hidden
-         */
-        private insert_by_val(position, val);
-        /**
-         * @hidden
-         */
-        protected _Insert_by_repeating_val(position: DequeIterator<T>, n: number, val: T): DequeIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(position: DequeIterator<T>, begin: InputIterator, end: InputIterator): DequeIterator<T>;
-        /**
-         * @hidden
-         */
-        private insert_by_items(position, items);
-        /**
-         * @inheritdoc
-         */
-        erase(position: DequeIterator<T>): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        erase(first: DequeIterator<T>, last: DequeIterator<T>): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        erase(position: DequeReverseIterator<T>): DequeReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        erase(first: DequeReverseIterator<T>, last: DequeReverseIterator<T>): DequeReverseIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Erase_by_range(first: DequeIterator<T>, last: DequeIterator<T>): DequeIterator<T>;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link Deque container} object with same type of elements. Sizes and container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were in <i>obj</i>
-         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
-         * pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link Deque container} of the same type of elements (i.e., instantiated
-         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
-         *			  {@link container Deque}.
-         */
-        swap(obj: Deque<T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> An iterator of {@link Deque}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /> </a>
-     * </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class DequeIterator<T> extends Iterator<T> implements base.IArrayIterator<T> {
-        /**
-         * Sequence number of iterator in the source {@link Deque}.
-         */
-        private index_;
-        /**
-         * <p> Construct from the source {@link Deque container}. </p>
-         *
-         * <h4> Note </h4>
-         * <p> Do not create the iterator directly, by yourself. </p>
-         * <p> Use {@link Deque.begin begin()}, {@link Deque.end end()} in {@link Deque container} instead. </p>
-         *
-         * @param source The source {@link Deque container} to reference.
-         * @param index Sequence number of the element in the source {@link Deque}.
-         */
-        constructor(source: Deque<T>, index: number);
-        /**
-         * @hidden
-         */
-        private deque;
-        /**
-         * @inheritdoc
-         */
-        /**
-         * Set value of the iterator is pointing to.
-         *
-         * @param val Value to set.
-         */
-        value: T;
-        /**
-         * @inheritdoc
-         */
-        index: number;
-        /**
-         * @inheritdoc
-         */
-        prev(): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        next(): DequeIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        advance(n: number): DequeIterator<T>;
-        /**
-         * <p> Whether an iterator is equal with the iterator. </p>
-         *
-         * <p> Compare two iterators and returns whether they are equal or not. </p>
-         *
-         * <h4> Note </h4>
-         * <p> Iterator's equal_to() only compare souce container and index number. </p>
-         *
-         * <p> Although elements in a pair, key and value are equal_to, if the source map or
-         * index number is different, then the {@link equal_to equal_to()} will return false. If you want to
-         * compare the elements of a pair, compare them directly by yourself. </p>
-         *
-         * @param obj An iterator to compare
-         * @return Indicates whether equal or not.
-         */
-        equal_to<U extends T>(obj: DequeIterator<U>): boolean;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: DequeIterator<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> A reverse-iterator of Deque. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /> </a>
-     * </p>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class DequeReverseIterator<T> extends ReverseIterator<T, DequeIterator<T>, DequeReverseIterator<T>> implements base.IArrayIterator<T> {
-        /**
-         * Construct from base iterator.
-         *
-         * @param base A reference of the base iterator, which iterates in the opposite direction.
-         */
-        constructor(base: DequeIterator<T>);
-        /**
-         * @hidden
-         */
-        protected create_neighbor(base: DequeIterator<T>): DequeReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        /**
-         * Set value of the iterator is pointing to.
-         *
-         * @param val Value to set.
-         */
-        value: T;
-        /**
-         * Get index.
-         */
-        index: number;
-    }
-}
-declare namespace std {
-    /**
-     * <p> Function handling termination on exception </p>
-     *
-     * <p> Calls the current terminate handler. </p>
-     *
-     * <p> By default, the terminate handler calls abort. But this behavior can be redefined by calling
-     * {@link set_terminate}. </p>
-     *
-     * <p> This function is automatically called when no <code>catch</code> handler can be found for a thrown exception,
-     * or for some other exceptional circumstance that makes impossible to continue the exception handling process. </p>
-     *
-     * <p> This function is provided so that the terminate handler can be explicitly called by a program that needs to
-     * abnormally terminate, and works even if {@link set_terminate} has not been used to set a custom terminate handler
-     * (calling abort in this case). </p>
-     */
-    function terminate(): void;
-    /**
-     * <p> Set <i>terminate handler</i> function. </p>
-     *
-     * <p> A <i>terminate handler</i> function is a function automatically called when the exception handling process has
-     * to be abandoned for some reason. This happens when no catch handler can be found for a thrown exception, or for
-     * some other exceptional circumstance that makes impossible to continue the exception handling process. </p>
-     *
-     * <p> Before this function is called by the program for the first time, the default behavior is to call abort. </p>
-     *
-     * <p> A program may explicitly call the current terminate handler function by calling {@link terminate}. </p>
-     *
-     * @param f Function that takes no parameters and returns no value (<i>void</i>).
-     */
-    function set_terminate(f: () => void): void;
-    /**
-     * <p> Get <i>terminate handler</i> function. </p>
-     *
-     * <p> The <i>terminate handler</i> function is automatically called when no <code>catch</code> handler can be found
-     * for a thrown exception, or for some other exceptional circumstance that makes impossible to continue the exception
-     * handling process. </p>
-     *
-     * <p> If no such function has been set by a previous call to {@link set_terminate}, the function returns a
-     * <i>null-pointer</i>. </p>
-     *
-     * @return If {@link set_terminate} has previously been called by the program, the function returns the current
-     *		   <i>terminate handler</i> function. Otherwise, it returns a <i>null-pointer</i>.
-     */
-    function get_terminate(): () => void;
-    /**
-     * <p> Standard exception class. </p>
-     *
-     * <p> Base class for standard exceptions. </p>
-     *
-     * <p> All objects thrown by components of the standard library are derived from this class.
-     * Therefore, all standard exceptions can be caught by catching this type by reference. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/exception/exception
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class Exception extends Error {
-        /**
-         * A message representing specification about the Exception.
-         */
-        private description;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-        /**
-         * <p> Get string identifying exception. </p>
-         * <p> Returns a string that may be used to identify the exception. </p>
-         *
-         * <p> The particular representation pointed by the returned value is implementation-defined.
-         * As a virtual function, derived classes may redefine this function so that specify value are
-         * returned. </p>
-         */
-        what(): string;
-        /**
-         * @inheritdoc
-         */
-        message: string;
-        /**
-         * @inheritdoc
-         */
-        name: string;
-    }
-    /**
-     * <p> Logic error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report errors in the internal
-     * logical of the program, such as violation of logical preconditions or class invariants. </p>
-     *
-     * <p> These errors are presumably detectable before the program executes. </p>
-     *
-     * <p> It is used as a base class for several logical error exceptions. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/logic_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class LogicError extends Exception {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Domain error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report domain errors. </p>
-     *
-     * <p> Generally, the domain of a mathematical function is the subset of values that it is defined for.
-     * For example, the square root function is only defined for non-negative numbers. Thus, a negative number
-     * for such a function would qualify as a domain error. </p>
-     *
-     * <p> No component of the standard library throws exceptions of this type. It is designed as a standard
-     * exception to be thrown by programs. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a></p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/domain_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class DomainError extends LogicError {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Invalid argument exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report an invalid argument. </p>
-     *
-     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library
-     * also throw exceptions of this type to signal invalid arguments. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/invalid_argument
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class InvalidArgument extends LogicError {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Length error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report a length error. </p>
-     *
-     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library,
-     * such as vector and string also throw exceptions of this type to signal errors resizing. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/length_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class LengthError extends LogicError {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Out-of-range exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report an out-of-range error. </p>
-     *
-     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library,
-     * such as vector, deque, string and bitset also throw exceptions of this type to signal arguments
-     * out of range. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/out_of_range
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class OutOfRange extends LogicError {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Runtime error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report errors that can only be
-     * detected during runtime. </p>
-     *
-     * <p> It is used as a base class for several runtime error exceptions. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/runtime_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class RuntimeError extends Exception {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Overflow error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to arithmetic overflow errors. </p>
-     *
-     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library
-     * also throw exceptions of this type to signal range errors. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/overflow_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class OverflowError extends RuntimeError {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Underflow error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to arithmetic underflow errors. </p>
-     *
-     * <p> No component of the standard library throws exceptions of this type. It is designed as a standard
-     * exception to be thrown by programs. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/underflow_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class UnderflowError extends RuntimeError {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-    /**
-     * <p> Range error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report range errors in internal
-     * computations. </p>
-     *
-     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library
-     * also throw exceptions of this type to signal range errors. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/stdexcept/range_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class RangeError extends RuntimeError {
-        /**
-         * <p> Construct from a message. </p>
-         *
-         * @param message A message representing specification about the Exception.
-         */
-        constructor(message: string);
-    }
-}
-declare namespace std {
-    /**
-     * <p> Function object class for equality comparison. </p>
-     *
-     * <p> Binary function object class whose call returns whether its two arguments compare <i>equal</i> (as returned by
-     * operator ==). </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function {@link IComparable.equal_to equal_to}
-     * defined. This member function allows the object to be used with the same syntax as a function call. </p>
-     *
-     * @param x First element to compare.
-     * @param y Second element to compare.
-     *
-     * @return Whether the arguments are equal.
-     */
-    function equal_to<T>(x: T, y: T): boolean;
-    /**
-     * <p> Function object class for non-equality comparison. </p>
-     *
-     * <p> Binary function object class whose call returns whether its two arguments compare <i>not equal</i> (as returned
-     * by operator operator!=). </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function {@link IComparable.equal_to equal_to}
-     * defined. This member function allows the object to be used with the same syntax as a function call. </p>
-     *
-     * @param x First element to compare.
-     * @param y Second element to compare.
-     *
-     * @return Whether the arguments are not equal.
-     */
-    function not_equal_to<T>(x: T, y: T): boolean;
-    /**
-     * <p> Function for less-than inequality comparison. </p>
-     *
-     * <p> Binary function returns whether the its first argument compares less than the second. </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function {@link IComparable.less less}
-     * defined. If an object doesn't have the method, then its own uid will be used to compare insteadly.
-     * This member function allows the object to be used with the same syntax as a function call. </p>
-     *
-     * <p> Objects of this class can be used on standard algorithms such as {@link sort sort()}</code>,
-     * {@link merge merge()} or {@link TreeMap.lower_bound lower_bound()}. </p>
-     *
-     * @param <T> Type of arguments to compare by the function call. The type shall supporrt the operation
-     *			  <i>operator<()</i> or method {@link IComparable.less less}.
-     *
-     * @param x First element, the standard of comparison.
-     * @param y Second element compare with the first.
-     *
-     * @return Whether the first parameter is less than the second.
-     */
-    function less<T>(x: T, y: T): boolean;
-    /**
-     * <p> Function object class for less-than-or-equal-to comparison. </p>
-     *
-     * <p> Binary function object class whose call returns whether the its first argument compares {@link less less than} or
-     * {@link equal_to equal to} the second (as returned by operator <=). </p>
-     *
-     * <p> Generically, <i>function objects</i> are instances of a class with member function {@link IComparable.less less}
-     * and {@link IComparable.equal_to equal_to} defined. This member function allows the object to be used with the same
-     * syntax as a function call. </p>
-     *
-     * @param x First element, the standard of comparison.
-     * @param y Second element compare with the first.
-     *
-     * @return Whether the <i>x</i> is {@link less less than} or {@link equal_to equal to} the <i>y</i>.
-     */
-    function less_equal<T>(x: T, y: T): boolean;
-    /**
-     * <p> Function for greater-than inequality comparison. </p>
-     *
-     * <p> Binary function returns whether the its first argument compares greater than the second. </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function {@link less} and
-     * {@link equal_to equal_to()} defined. If an object doesn't have those methods, then its own uid will be used
-     * to compare insteadly. This member function allows the object to be used with the same syntax as a function
-     * call. </p>
-     *
-     * <p> Objects of this class can be used on standard algorithms such as {@link sort sort()},
-     * {@link merge merge()} or {@link TreeMap.lower_bound lower_bound()}. </p>
-     *
-     * @param <T> Type of arguments to compare by the function call. The type shall supporrt the operation
-     *			  <i>operator>()</i> or method {@link IComparable.greater greater}.
-     *
-     * @return Whether the <i>x</i> is greater than the <i>y</i>.
-     */
-    function greater<T>(x: T, y: T): boolean;
-    /**
-     * <p> Function object class for greater-than-or-equal-to comparison. </p>
-     *
-     * <p> Binary function object class whose call returns whether the its first argument compares
-     * {@link greater greater than} or {@link equal_to equal to} the second (as returned by operator >=). </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function {@link IComparable.less less}
-     * defined. If an object doesn't have the method, then its own uid will be used to compare insteadly.
-     * This member function allows the object to be used with the same syntax as a function call. </p>
-     *
-     * @param x First element, the standard of comparison.
-     * @param y Second element compare with the first.
-     *
-     * @return Whether the <i>x</i> is {@link greater greater than} or {@link equal_to equal to} the <i>y</i>.
-     */
-    function greater_equal<T>(x: T, y: T): boolean;
-    /**
-     * <p> Logical AND function object class. </p>
-     *
-     * <p> Binary function object class whose call returns the result of the <i>logical "and"</i> operation between its two
-     * arguments (as returned by operator &&). </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function operator() defined. This member
-     * function allows the object to be used with the same syntax as a function call. </p>
-     *
-     * @param x First element.
-     * @param y Second element.
-     *
-     * @return Result of logical AND operation.
-     */
-    function logical_and<T>(x: T, y: T): boolean;
-    /**
-     * <p> Logical OR function object class. </p>
-     *
-     * <p> Binary function object class whose call returns the result of the <i>logical "or"</i> operation between its two
-     * arguments (as returned by operator ||). </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function operator() defined. This member
-     * function allows the object to be used with the same syntax as a function call. </p>
-     *
-     * @param x First element.
-     * @param y Second element.
-     *
-     * @return Result of logical OR operation.
-     */
-    function logical_or<T>(x: T, y: T): boolean;
-    /**
-     * <p> Logical NOT function object class. </p>
-     *
-     * <p> Unary function object class whose call returns the result of the <i>logical "not"</i> operation on its argument
-     * (as returned by operator !). </p>
-     *
-     * <p> Generically, function objects are instances of a class with member function operator() defined. This member
-     * function allows the object to be used with the same syntax as a function call. </p>
-     *
-     * @param x Target element.
-     *
-     * @return Result of logical NOT operation.
-     */
-    function logical_not<T>(x: T): boolean;
-    /**
-     * <p> Bitwise AND function object class. </p>
-     *
-     * <p> Binary function object class whose call returns the result of applying the <i>bitwise "and"</i> operation between
-     * its two arguments (as returned by operator &). </p>
-     *
-     * @param x First element.
-     * @param y Second element.
-     *
-     * @return Result of bitwise AND operation.
-     */
-    function bit_and(x: number, y: number): number;
-    /**
-     * <p> Bitwise OR function object class. </p>
-     *
-     * <p> Binary function object class whose call returns the result of applying the <i>bitwise "and"</i> operation between
-     * its two arguments (as returned by operator &). </p>
-     *
-     * @param x First element.
-     * @param y Second element.
-     *
-     * @return Result of bitwise OR operation.
-     */
-    function bit_or(x: number, y: number): number;
-    /**
-     * <p> Bitwise XOR function object class. </p>
-     *
-     * <p> Binary function object class whose call returns the result of applying the <i>bitwise "exclusive or"</i>
-     * operation between its two arguments (as returned by operator ^). </p>
-     *
-     * @param x First element.
-     * @param y Second element.
-     *
-     * @return Result of bitwise XOR operation.
-     */
-    function bit_xor(x: number, y: number): number;
-    /**
-     * <p> Comparable instance. </p>
-     *
-     * <p> {@link IComparable} is a common interface for objects who can compare each other. </p>
-     *
-     * @reference https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    interface IComparable<T> extends Object {
-        /**
-         * <p> Indicates whether some other object is &quot;equal to&quot; this one. </p>
-         *
-         * <p> The {@link equal_to} method implements an equivalence relation on non-null object references: </p>
-         *
-         * <ul>
-         *	<li>
-         *		It is <b>reflexive</b>: for any non-null reference value <code>x</code>, <code>x.equal_to(x)</code>
-         *		should return <code>true</code>.
-         *	</li>
-         *	<li>
-         *		It is <b>symmetric</b>: for any non-null reference values <code>x</code> and <code>y</code>,
-         *		<code>x.equal_to(y)</code> should return <code>true</code> if and only if <code>y.equal_to(x)</code>
-         *		returns <code>true</code>. </li>
-         *	<li>
-         *		It is <b>transitive</b>: for any non-null reference values <code>x</code>, <code>y</code>, and
-         *		<code>z</code>, if <code>x.equal_to(y)</code> returns <code>true</code> and <code>y.equal_to(z)</code>
-         *		returns <code>true</code>, then <code>x.equal_to(z)</code> should return <code>true</code>.
-         *	</li>
-         *	<li>
-         *		It is <b>consistent</b>: for any non-null reference values <code>x</code> and <code>y</code>, multiple
-         *		invocations of <code>x.equal_to(y)</code> consistently return <code>true</code> or consistently return
-         *		<code>false</code>, provided no information used in equal_to comparisons on the objects is modified.
-         *	</li>
-         *	<li>
-         *		For any non-null reference value <code>x</code>, <code>x.equal_to(null)</code> should return
-         *		<code>false</code>.
-         *	</li>
-         * </ul>
-         *
-         * <p> The {@link equal_to} method for interface {@link IComparable} implements the most discriminating possible
-         * equivalence relation on objects; that is, for any non-null reference values <code>x</code> and
-         * <code>y</code>, this method returns <code>true</code> if and only if <code>x</code> and <code>y</code>
-         * refer to the same object (<code>x == y</code> has the value <code>true</code>). </p>
-         *
-         * <p> Note that it is generally necessary to override the {@link hash_code} method whenever this method is
-         * overridden, so as to maintain the general contract for the {@link hash_code} method, which states that
-         * equal objects must have equal hash codes. </p>
-         *
-         * <ul>
-         *	<li> {@link IComparable.equal_to} is called by {@link std.equal_to}. </li>
-         * </ul>
-         *
-         * @param obj the reference object with which to compare.
-         *
-         * @return <code>true</code> if this object is the same as the obj argument; <code>false</code> otherwise.
-         */
-        equal_to(obj: T): boolean;
-        /**
-         * <p> Less-than inequality comparison. </p>
-         *
-         * <p> Binary method returns whether the the instance compares less than the <i>obj</i>. </p>
-         *
-         * <ul>
-         *	<li>
-         *		{@link IComparable.less} is called by {@link std.less}. Also, this method can be used on standard
-         *		algorithms such as {@link sort sort()}</code>, {@link merge merge()} or
-         *		{@link TreeMap.lower_bound lower_bound()}.
-         *	</li>
-         * </ul>
-         *
-         * @param obj the reference object with which to compare.
-         *
-         * @return Whether the first parameter is less than the second.
-         */
-        less(obj: T): boolean;
-        /**
-         * <p> Issue a hash code. </p>
-         *
-         * <p> Returns a hash code value for the object. This method is supported for the benefit of hash tables such
-         * as those provided by hash containers; {@link HashSet}, {@link HashMap}, {@link MultiHashSet} and
-         * {@link MultiHashMap}. </p>
-         *
-         * <p> As much as is reasonably practical, the {@link hash_code} method defined by interface
-         * {@link IComparable} does return distinct integers for distinct objects. (This is typically implemented by
-         * converting the internal address of the object into an integer, but this implementation technique is not
-         * required by the JavaScript programming language.) </p>
-         *
-         * <ul>
-         *	<li>
-         *		{@link IComparable.hash_code} is called by {@link std.hash_code}. If you want to keep basically
-         *		provided hash function, then returns {@link std.Hash.code}; <code>return std.Hash.code(this);</code>
-         *	</li>
-         * </ul>
-         *
-         * @return An hash code who represents the object.
-         */
-        hash(): number;
-    }
-    /**
-     * <p> Default hash function for number. </p>
-     *
-     * <p> Unary function that defines the default hash function used by the standard library. </p>
-     *
-     * <p> The functional call returns a hash value of its argument: A hash value is a value that depends solely on
-     * its argument, returning always the same value for the same argument (for a given execution of a program). The
-     * value returned shall have a small likelihood of being the same as the one returned for a different argument.
-     * </p>
-     *
-     * @param val Value to be hashed.
-     *
-     * @return Returns a hash value for its argument, as a value of type number. The number is an unsigned integer.
-     */
-    function hash(val: number): number;
-    /**
-     * <p> Default hash function for string. </p>
-     *
-     * <p> Unary function that defines the default hash function used by the standard library. </p>
-     *
-     * <p> The functional call returns a hash value of its argument: A hash value is a value that depends solely on
-     * its argument, returning always the same value for the same argument (for a given execution of a program). The
-     * value returned shall have a small likelihood of being the same as the one returned for a different argument.
-     * </p>
-     *
-     * @param str A string to be hashed.
-     *
-     * @return Returns a hash value for its argument, as a value of type number. The number is an unsigned integer.
-     */
-    function hash(str: string): number;
-    /**
-     * <p> Default hash function for Object. </p>
-     *
-     * <p> Unary function that defines the default hash function used by the standard library. </p>
-     *
-     * <p> The functional call returns a hash value of its argument: A hash value is a value that depends solely on
-     * its argument, returning always the same value for the same argument (for a given execution of a program). The
-     * value returned shall have a small likelihood of being the same as the one returned for a different argument.
-     * </p>
-     *
-     * <p> The default {@link hash} function of Object returns a value returned from {@link hash hash(number)} with
-     * an <b>unique id</b> of each Object. If you want to specify {@link hash} function of a specific class, then
-     * define a member function <code>public hash(): number</code> in the class. </p>
-     *
-     * @param obj Object to be hashed.
-     *
-     * @return Returns a hash value for its argument, as a value of type number. The number is an unsigned integer.
-     */
-    function hash(obj: Object): number;
-    /**
-     * <p> Exchange contents of {@link IContainers containers}. </p>
-     *
-     * <p> The contents of container <i>left</i> are exchanged with those of <i>right</i>. Both container objects must have
-     * same type of elements (same template parameters), although sizes may differ. </p>
-     *
-     * <p> After the call to this member function, the elements in <i>left</i> are those which were in <i>right</i> before
-     * the call, and the elements of <i>right</i> are those which were in <i>left</i>. All iterators, references and
-     * pointers remain valid for the swapped objects. </p>
-     *
-     * <p> This is an overload of the generic algorithm swap that improves its performance by mutually transferring
-     * ownership over their assets to the other container (i.e., the containers exchange references to their data, without
-     * actually performing any element copy or movement): It behaves as if <i>left</i>.
-     * {@link IContainer.swap swap}(<i>right</i>) was called. </p>
-     *
-     * @param left A {@link IContainer container} to swap its contents.
-     * @param right A {@link IContainer container} to swap its contents.
-     */
-    function swap<T>(left: base.IContainer<T>, right: base.IContainer<T>): void;
-    /**
-     * <p> Exchange contents of queues. </p>
-     *
-     * <p> Exchanges the contents of <i>left</i> and <i>right</i>. </p>
-     *
-     * @param left A {@link Queue} container of the same type. Size may differ.
-     * @param right A {@link Queue} container of the same type. Size may differ.
-     */
-    function swap<T>(left: Queue<T>, right: Queue<T>): void;
-    /**
-     * <p> Exchange contents of {@link PriorityQueue PriorityQueues}. </p>
-     *
-     * <p> Exchanges the contents of <i>left</i> and <i>right</i>. </p>
-     *
-     * @param left A {@link PriorityQueue} container of the same type. Size may differ.
-     * @param right A {@link PriorityQueue} container of the same type. Size may differ.
-     */
-    function swap<T>(left: PriorityQueue<T>, right: PriorityQueue<T>): void;
-    /**
-     * <p> Exchange contents of {@link Stack Stacks}. </p>
-     *
-     * <p> Exchanges the contents of <i>left</i> and <i>right</i>. </p>
-     *
-     * @param left A {@link Stack} container of the same type. Size may differ.
-     * @param right A {@link Stack} container of the same type. Size may differ.
-     */
-    function swap<T>(left: Stack<T>, right: Stack<T>): void;
-    /**
-     * <p> Exchanges the contents of two {@link UniqueMap unique maps}. </p>
-     *
-     * <p> The contents of container <i>left</i> are exchanged with those of <i>right</i>. Both container objects must
-     * be of the same type (same template parameters), although sizes may differ. </p>
-     *
-     * <p> After the call to this member function, the elements in <i>left</i> are those which were in <i>right</i>
-     * before the call, and the elements of <i>right</i> are those which were in <i>left</i>. All iterators, references
-     * and pointers remain valid for the swapped objects. </p>
-     *
-     * <p> This is an overload of the generic algorithm swap that improves its performance by mutually transferring
-     * ownership over their assets to the other container (i.e., the containers exchange references to their data,
-     * without actually performing any element copy or movement): It behaves as if
-     * <i>left</i>.{@link UniqueMap.swap swap}(<i>right</i>) was called. </p>
-     *
-     * @param left An {@link UniqueMap unique map} to swap its conents.
-     * @param right An {@link UniqueMap unique map} to swap its conents.
-     */
-    function swap<Key, T>(left: base.UniqueMap<Key, T>, right: base.UniqueMap<Key, T>): void;
-    /**
-     * <p> Exchanges the contents of two {@link MultiMap multi maps}. </p>
-     *
-     * <p> The contents of container <i>left</i> are exchanged with those of <i>right</i>. Both container objects must
-     * be of the same type (same template parameters), although sizes may differ. </p>
-     *
-     * <p> After the call to this member function, the elements in <i>left</i> are those which were in <i>right</i>
-     * before the call, and the elements of <i>right</i> are those which were in <i>left</i>. All iterators, references
-     * and pointers remain valid for the swapped objects. </p>
-     *
-     * <p> This is an overload of the generic algorithm swap that improves its performance by mutually transferring
-     * ownership over their assets to the other container (i.e., the containers exchange references to their data,
-     * without actually performing any element copy or movement): It behaves as if
-     * <i>left</i>.{@link MultiMap.swap swap}(<i>right</i>) was called. </p>
-     *
-     * @param left A {@link MultiMap multi map} to swap its conents.
-     * @param right A {@link MultiMap multi map} to swap its conents.
-     */
-    function swap<Key, T>(left: base.MultiMap<Key, T>, right: base.MultiMap<Key, T>): void;
-}
-declare namespace std {
-    /**
-     * <p> Bind function arguments. </p>
-     *
-     * <p> Returns a function object based on <i>fn</i>, but with its arguments bound to <i>args</i>. </p>
-     *
-     * <p> Each argument may either be bound to a value or be a {@link placeholders placeholder}: </p>
-     * <ul>
-     *	<li> If bound to a value, calling the returned function object will always use that value as argument. </li>
-     *	<li>
-     *		If a {@link placeholders placeholder}, calling the returned function object forwards an argument passed to the
-     *		call (the one whose order number is specified by the placeholder).
-     *	</li>
-     * </ul>
-     *
-     * <p> Calling the returned object returns the same type as fn. </p>
-     *
-     * @param fn A function object, pointer to function or pointer to member.
-     * @param args List of arguments to bind: either values, or {@link placeholders}.
-     *
-     * @return A function object that, when called, calls <i>fn</i> with its arguments bound to <i>args</i>. If <i>fn</i> is
-     *		   a pointer to member, the first argument expected by the returned function is an object of the class <i>fn</i>
-     *		   is a member.
-     */
-    function bind<Ret>(fn: (...args: any[]) => Ret, ...args: any[]): (...args: any[]) => Ret;
-    /**
-     * <p> Bind function arguments. </p>
-     *
-     * <p> Returns a function object based on <i>fn</i>, but with its arguments bound to <i>args</i>. </p>
-     *
-     * <p> Each argument may either be bound to a value or be a {@link placeholders placeholder}: </p>
-     * <ul>
-     *	<li> If bound to a value, calling the returned function object will always use that value as argument. </li>
-     *	<li>
-     *		If a {@link placeholders placeholder}, calling the returned function object forwards an argument passed to the
-     *		call (the one whose order number is specified by the placeholder).
-     *	</li>
-     * </ul>
-     *
-     * <p> Calling the returned object returns the same type as fn. </p>
-     *
-     * @param fn A function object, pointer to function or pointer to member.
-     * @param thisArg This argument, owner object of the member method <i>fn</i>.
-     * @param args List of arguments to bind: either values, or {@link placeholders}.
-     *
-     * @return A function object that, when called, calls <i>fn</i> with its arguments bound to <i>args</i>. If <i>fn</i> is
-     *		   a pointer to member, the first argument expected by the returned function is an object of the class <i>fn</i>
-     *		   is a member.
-     */
-    function bind<Ret, T>(fn: (...args: any[]) => Ret, thisArg: T, ...args: any[]): (...args: any[]) => Ret;
-}
-/**
- * <p> Bind argument placeholders. </p>
- *
- * <p> This namespace declares an unspecified number of objects: <i>_1</i>, <i>_2</i>, <i>_3</i>, ...</i>, which are
- * used to specify placeholders in calls to function {@link std.bind}. </p>
- *
- * <p> When the function object returned by bind is called, an argument with placeholder {@link _1} is replaced by the
- * first argument in the call, {@link _2} is replaced by the second argument in the call, and so on... For example: </p>
- *
- * <code>
- * let vec: Vector<number> = new Vector<number>();
- *
- * let bind = std.bind(Vector.insert, _1, vec.end(), _2, _3);
- * bind.apply(vec, 5, 1); // vec.insert(vec.end(), 5, 1);
- * // [1, 1, 1, 1, 1]
- * </code>
- *
- * <p> When a call to {@link bind} is used as a subexpression in another call to <i>bind</i>, the {@link placeholders}
- * are relative to the outermost {@link bind} expression. </p>
- *
- * @reference http://www.cplusplus.com/reference/functional/placeholders/
- * @author Jeongho Nam <http://samchon.org>
- */
-declare namespace std.placeholders {
-    /**
-     * @hidden
-     */
-    class PlaceHolder {
-        private index_;
-        constructor(index: number);
-        index: number;
-    }
-    /**
-     * Replaced by the first argument in the function call.
-     */
-    const _1: PlaceHolder;
-    /**
-     * Replaced by the second argument in the function call.
-     */
-    const _2: PlaceHolder;
-    /**
-     * Replaced by the third argument in the function call.
-     */
-    const _3: PlaceHolder;
-    const _4: PlaceHolder;
-    const _5: PlaceHolder;
-    const _6: PlaceHolder;
-    const _7: PlaceHolder;
-    const _8: PlaceHolder;
-    const _9: PlaceHolder;
-    const _10: PlaceHolder;
-    const _11: PlaceHolder;
-    const _12: PlaceHolder;
-    const _13: PlaceHolder;
-    const _14: PlaceHolder;
-    const _15: PlaceHolder;
-    const _16: PlaceHolder;
-    const _17: PlaceHolder;
-    const _18: PlaceHolder;
-    const _19: PlaceHolder;
-    const _20: PlaceHolder;
-}
-declare namespace std.base {
-    /**
-     * <p> An abstract map. </p>
-     *
-     * <p> {@link MapContainer MapContainers} are associative containers that store elements formed by a combination
-     * of a <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), and which allows for fast retrieval
-     * of individual elements based on their keys. </p>
-     *
-     * <p> In a {@link MapContainer}, the <i>key values</i> are generally used to identify the elements, while the
-     * <i>mapped values</i> store the content associated to this key. The types of <i>key</i> and
-     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a
-     * {@link Pair} type combining both: </p>
-     *
-     * <p> <code>typedef pair<const Key, T> value_type;</code> </p>
-     *
-     * <p> {@link MapContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
-     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
-     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute position
-     *		in the container.
-     *	</dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd>
-     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
-     *	</dd>
-     * </dl>
-     *
-     * @param <Key> Type of the keys. Each element in a map is identified by its key value.
-     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class MapContainer<Key, T> extends Container<Pair<Key, T>> {
-        /**
-         * <p> {@link List} storing elements. </p>
-         *
-         * <p> Storing elements and keeping those sequence of the {@link MapContainer} are implemented by
-         * {@link data_ this list container}. Implementing index-table is also related with {@link data_ this list}
-         * by storing {@link ListIterator iterators} ({@link MapIterator} references {@link ListIterator}) who are
-         * created from {@link data_ here}. </p>
-         */
-        private data_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        assign<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * <p> Get iterator to element. </p>
-         *
-         * <p> Searches the container for an element with a identifier equivalent to <i>key</i> and returns an
-         * iterator to it if found, otherwise it returns an iterator to {@link end end()}. </p>
-         *
-         * <p> Two keys are considered equivalent if the container's comparison object returns false reflexively
-         * (i.e., no matter the order in which the elements are passed as arguments). </p>
-         *
-         * <p> Another member functions, {@link has has()} and {@link count count()}, can be used to just check
-         * whether a particular <i>key</i> exists. </p>
-         *
-         * @param key Key to be searched for
-         * @return An iterator to the element, if an element with specified <i>key</i> is found, or
-         *		   {@link end end()} otherwise.
-         */
-        abstract find(key: Key): MapIterator<Key, T>;
-        /**
-         * <p> Return iterator to beginning. </p>
-         *
-         * <p> Returns an iterator referring the first element in the  </p>
-         *
-         * <h4> Note </h4>
-         * <p> If the container is {@link empty}, the returned iterator is same with {@link end end()}. </p>
-         *
-         * @return An iterator to the first element in the  The iterator containes the first element's value.
-         */
-        begin(): MapIterator<Key, T>;
-        /**
-         * <p> Return iterator to end. </p>
-         * <p> Returns an iterator referring to the past-the-end element in the  </p>
-         *
-         * <p> The past-the-end element is the theoretical element that would follow the last element in the
-         *  It does not point to any element, and thus shall not be dereferenced. </p>
-         *
-         * <p> Because the ranges used by functions of the container do not include the element reference by their
-         * closing iterator, this function is often used in combination with {@link MapContainer}.{@link begin} to
-         * specify a range including all the elements in the  </p>
-         *
-         * <h4> Note </h4>
-         * <p> Returned iterator from {@link MapContainer}.{@link end} does not refer any element. Trying to accessing
-         * element by the iterator will cause throwing exception ({@link OutOfRange}). </p>
-         *
-         * <p> If the container is {@link empty}, this function returns the same as {@link begin}. </p>
-         *
-         * @return An iterator to the end element in the
-         */
-        end(): MapIterator<Key, T>;
-        /**
-         * <p> Return {@link MapReverseIterator reverse iterator} to <i>reverse beginning</i>. </p>
-         *
-         * <p> Returns a {@link MapReverseIterator reverse iterator} pointing to the last element in the container
-         * (i.e., its <i>reverse beginning</i>). </p>
-         *
-         * {@link MapReverseIterator Reverse iterators} iterate backwards: increasing them moves them towards the
-         * beginning of the container. </p>
-         *
-         * <p> {@link rbegin} points to the element preceding the one that would be pointed to by member {@link end}.
-         * </p>
-         *
-         * @return A {@link MapReverseIterator reverse iterator} to the <i>reverse beginning</i> of the sequence
-         *
-         */
-        rbegin(): MapReverseIterator<Key, T>;
-        /**
-         * <p> Return {@link MapReverseIterator reverse iterator} to <i>reverse end</i>. </p>
-         *
-         * <p> Returns a {@link MapReverseIterator reverse iterator} pointing to the theoretical element right before
-         * the first element in the {@link MapContainer map container} (which is considered its <i>reverse end</i>).
-         * </p>
-         *
-         * <p> The range between {@link MapContainer}.{@link rbegin} and {@link MapContainer}.{@link rend} contains
-         * all the elements of the container (in reverse order). </p>
-         *
-         * @return A {@link MapReverseIterator reverse iterator} to the <i>reverse end</i> of the sequence
-         */
-        rend(): MapReverseIterator<Key, T>;
-        /**
-         * <p> Whether have the item or not. </p>
-         *
-         * <p> Indicates whether a map has an item having the specified identifier. </p>
-         *
-         * @param key Key value of the element whose mapped value is accessed.
-         *
-         * @return Whether the map has an item having the specified identifier.
-         */
-        has(key: Key): boolean;
-        /**
-         * <p> Count elements with a specific key. </p>
-         *
-         * <p> Searches the container for elements whose key is <i>key</i> and returns the number of elements found. </p>
-         *
-         * @param key Key value to be searched for.
-         *
-         * @return The number of elements in the container with a <i>key</i>.
-         */
-        abstract count(key: Key): number;
-        /**
-         * Return the number of elements in the map.
-         */
-        size(): number;
-        /**
-         * @inheritdoc
-         */
-        push<L extends Key, U extends T>(...args: Pair<L, U>[]): number;
-        /**
-         * @inheritdoc
-         */
-        push<L extends Key, U extends T>(...args: [Key, T][]): number;
-        /**
-         * Construct and insert element with hint
-         *
-         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
-         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
-         * container suggested as a hint on where to start the search for its insertion point (the container may or
-         * may not use this suggestion to optimize the insertion operation).
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
-         * the container, and may also take a position *hint*.
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param key The key used both to look up and to insert if not found.
-         * @param value Value, the item.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link MapContainer}.
-         */
-        emplace_hint(hint: MapIterator<Key, T>, key: Key, val: T): MapIterator<Key, T>;
-        /**
-         * Construct and insert element with hint
-         *
-         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
-         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
-         * container suggested as a hint on where to start the search for its insertion point (the container may or
-         * may not use this suggestion to optimize the insertion operation).
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
-         * the container, and may also take a position *hint*.
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param key The key used both to look up and to insert if not found.
-         * @param value Value, the item.
-         *
-         * @return An {@link MapIterator iterator} pointing to either the newly inserted element or to the element
-         *		   that already had an equivalent key in the {@link MapContainer}.
-         */
-        emplace_hint(hint: MapReverseIterator<Key, T>, key: Key, val: T): MapReverseIterator<Key, T>;
-        /**
-         * Construct and insert element with hint
-         *
-         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
-         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
-         * container suggested as a hint on where to start the search for its insertion point (the container may or
-         * may not use this suggestion to optimize the insertion operation).
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
-         * the container, and may also take a position *hint*.
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link MapContainer}.
-         */
-        emplace_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * Construct and insert element with hint
-         *
-         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
-         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
-         * container suggested as a hint on where to start the search for its insertion point (the container may or
-         * may not use this suggestion to optimize the insertion operation).
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
-         * the container, and may also take a position *hint*.
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         *
-         * @return An {@link MapIterator iterator} pointing to either the newly inserted element or to the element
-         *		   that already had an equivalent key in the {@link MapContainer}.
-         */
-        emplace_hint(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting a new element, effectively increasing the container {@link size}
-         * by the number of element inserted (zero or one). </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link MapContainer}.
-         */
-        insert(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting a new element, effectively increasing the container {@link size}
-         * by the number of element inserted (zero or one). </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link MapContainer}.
-         */
-        insert(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size}
-         * by the number of elements inserted. </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link MapContainer}.
-         */
-        insert<L extends Key, U extends T>(hint: MapIterator<Key, T>, tuple: [L, U]): MapIterator<Key, T>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size}
-         * by the number of elements inserted. </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link MapContainer}.
-         */
-        insert<L extends Key, U extends T>(hint: MapReverseIterator<Key, T>, tuple: [L, U]): MapReverseIterator<Key, T>;
-        /**
-         * <p> Insert elements from range iterators. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
-         * the number of elements inserted. </p>
-         *
-         * @param begin Input iterator specifying initial position of a range of elements.
-         * @param end Input iterator specifying final position of a range of elements.
-         *			  Notice that the range includes all the elements between <i>begin</i> and <i>end</i>,
-         *			  including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
-         */
-        insert<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @hidden
-         */
-        protected abstract _Insert_by_pair<L extends Key, U extends T>(pair: Pair<L, U>): any;
-        /**
-         * @hidden
-         */
-        private insert_by_tuple<L, U>(tuple);
-        /**
-         * @hidden
-         */
-        protected abstract _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        private insert_by_hint_with_tuple(hint, tuple);
-        /**
-         * @hidden
-         */
-        protected abstract _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * <p> Erase an elemet by key. </p>
-         *
-         * <p> Removes from the {@link MapContainer map container} a single element. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of element removed (zero or one),
-         * which are destroyed. </p>
-         *
-         * @param key Key of the element to be removed from the {@link MapContainer}.
-         */
-        erase(key: Key): number;
-        /**
-         * <p> Erase an elemet by iterator. </p>
-         *
-         * <p> Removes from the {@link MapContainer map container} a single element. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of element removed (zero or one),
-         * which are destroyed. </p>
-         *
-         * @param it Iterator specifying position winthin the {@link MapContainer map contaier} to be removed.
-         */
-        erase(it: MapIterator<Key, T>): MapIterator<Key, T>;
-        /**
-         * <p> Erase elements by range iterators. </p>
-         *
-         * <p> Removes from the {@link MapContainer map container} a range of elements. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of elements removed, which are
-         * destroyed. </p>
-         *
-         * @param begin An iterator specifying initial position of a range within {@link MApContainer map container}
-         *				to be removed.
-         * @param end An iterator specifying initial position of a range within {@link MApContainer map container}
-         *			  to be removed.
-         *			  Notice that the range includes all the elements between <i>begin</i> and <i>end</i>,
-         *			  including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
-         */
-        erase(begin: MapIterator<Key, T>, end: MapIterator<Key, T>): MapIterator<Key, T>;
-        /**
-         * <p> Erase an elemet by iterator. </p>
-         *
-         * <p> Removes from the {@link MapContainer map container} a single element. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of element removed (zero or one),
-         * which are destroyed. </p>
-         *
-         * @param it Iterator specifying position winthin the {@link MapContainer map contaier} to be removed.
-         */
-        erase(it: MapReverseIterator<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * <p> Erase elements by range iterators. </p>
-         *
-         * <p> Removes from the {@link MapContainer map container} a range of elements. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of elements removed, which are
-         * destroyed. </p>
-         *
-         * @param begin An iterator specifying initial position of a range within {@link MApContainer map container}
-         *				to be removed.
-         * @param end An iterator specifying initial position of a range within {@link MApContainer map container}
-         *			  to be removed.
-         *			  Notice that the range includes all the elements between <i>begin</i> and <i>end</i>,
-         *			  including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
-         */
-        erase(begin: MapReverseIterator<Key, T>, end: MapReverseIterator<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        private erase_by_key(key);
-        /**
-         * @hidden
-         */
-        private erase_by_iterator(first, last?);
-        /**
-         * @hidden
-         */
-        private erase_by_range(begin, end);
-        /**
-         * <p> Abstract method handling insertions for indexing. </p>
-         *
-         * <p> This method, {@link _Handle_insert} is designed to register the <i>first to last</i> to somewhere storing
-         * those {@link MapIterator iterators} for indexing, fast accessment and retrievalance. </p>
-         *
-         * <p> When {@link insert} is called, new elements will be inserted into the {@link data_ list container} and new
-         * {@link MapIterator iterators} <i>first to last</i>, pointing the inserted elements, will be created and the
-         * newly created iterators <i>first to last</i> will be shifted into this method {@link _Handle_insert} after the
-         * insertions. </p>
-         *
-         * <p> If the derived one is {@link RBTree tree-based} like {@link TreeSet}, the {@link MapIterator iterators}
-         * will be registered into the {@link TreeSet.tree_ tree} as a {@link XTreeNode tree node item}. Else if the
-         * derived one is {@link HashBuckets hash-based} like {@link HashSet}, the <i>first</i> to <i>last</i> will be
-         * registered into the {@link HashSet.hash_buckets_ hash bucket}. </p>
-         *
-         * @param first An {@link MapIterator} to the initial position in a sequence.
-         * @param last An {@link MapIterator} to the final position in a sequence. The range used is
-         *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-         *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-         */
-        protected abstract _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * <p> Abstract method handling deletions for indexing. </p>
-         *
-         * <p> This method, {@link _Handle_erase} is designed to unregister the <i>first to last</i> to somewhere storing
-         * those {@link MapIterator iterators} for indexing, fast accessment and retrievalance. </p>
-         *
-         * <p> When {@link erase} is called with <i>first to last</i>, {@link MapIterator iterators} positioning somewhere
-         * place to be deleted, is memorized and shifted to this method {@link _Handle_erase} after the deletion process is
-         * terminated. </p>
-         *
-         * <p> If the derived one is {@link RBTree tree-based} like {@link TreeSet}, the {@link MapIterator iterators}
-         * will be unregistered from the {@link TreeSet.tree_ tree} as a {@link XTreeNode tree node item}. Else if the
-         * derived one is {@link HashBuckets hash-based} like {@link HashSet}, the <i>first to last</i> will be
-         * unregistered from the {@link HashSet.hash_buckets_ hash bucket}. </p>
-         *
-         * @param first An {@link MapIterator} to the initial position in a sequence.
-         * @param last An {@link MapIterator} to the final position in a sequence. The range used is
-         *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-         *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-         */
-        protected abstract _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * @hidden
-         */
-        protected _Swap(obj: MapContainer<Key, T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> An iterator of {@link MapContainer map container}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram" style="max-width: 100%" /></a> </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class MapIterator<Key, T> extends Iterator<Pair<Key, T>> implements IComparable<MapIterator<Key, T>> {
-        /**
-         * A {@link ListIterator} pointing {@link Pair} of <i>key</i> and <i>value</i>.
-         */
-        private list_iterator_;
-        /**
-         * Construct from the {@link MapContainer source map} and {@link ListIterator list iterator}.
-         *
-         * @param source The source {@link MapContainer}.
-         * @param list_iterator A {@link ListIterator} pointing {@link Pair} of <i>key</i> and <i>value</i>.
-         */
-        constructor(source: base.MapContainer<Key, T>, list_iterator: ListIterator<Pair<Key, T>>);
-        /**
-         * Get iterator to previous element.
-         */
-        prev(): MapIterator<Key, T>;
-        /**
-         * Get iterator to next element.
-         */
-        next(): MapIterator<Key, T>;
-        /**
-         * Advances the Iterator by n element positions.
-         *
-         * @param step Number of element positions to advance.
-         * @return An advanced Iterator.
-         */
-        advance(step: number): MapIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        private map;
-        /**
-         * Get ListIterator.
-         */
-        get_list_iterator(): ListIterator<Pair<Key, T>>;
-        /**
-         * @inheritdoc
-         */
-        value: Pair<Key, T>;
-        /**
-         * Get first, key element.
-         */
-        first: Key;
-        /**
-         * Get second, value element.
-         */
-        /**
-         * Set second value.
-         */
-        second: T;
-        /**
-         * <p> Whether an iterator is equal with the iterator. </p>
-         *
-         * <p> Compare two iterators and returns whether they are equal or not. </p>
-         *
-         * @param obj An iterator to compare
-         * @return Indicates whether equal or not.
-         */
-        equal_to<L extends Key, U extends T>(obj: MapIterator<L, U>): boolean;
-        less<L extends Key, U extends T>(obj: MapIterator<L, U>): boolean;
-        hash(): number;
-        swap(obj: MapIterator<Key, T>): void;
-    }
-    /**
-     * <p> A reverse-iterator of {@link MapContainer map container}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram" style="max-width: 100%" /></a> </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class MapReverseIterator<Key, T> extends ReverseIterator<Pair<Key, T>, MapIterator<Key, T>, MapReverseIterator<Key, T>> {
-        /**
-         * Construct from base iterator.
-         *
-         * @param base A reference of the base iterator, which iterates in the opposite direction.
-         */
-        constructor(base: MapIterator<Key, T>);
-        /**
-         * @hidden
-         */
-        protected create_neighbor(base: MapIterator<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * Get first, key element.
-         */
-        first: Key;
-        /**
-         * Get second, value element.
-         */
-        /**
-         * Set second value.
-         */
-        second: T;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An abstract unique-map. </p>
-     *
-     * <p> {@link UniqueMap UniqueMaps} are associative containers that store elements formed by a combination of a
-     * <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), and which allows for fast retrieval of
-     * individual elements based on their keys. </p>
-     *
-     * <p> In a {@link MapContainer}, the <i>key values</i> are generally used to uniquely identify the elements,
-     * while the <i>mapped values</i> store the content associated to this key. The types of <i>key</i> and
-     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a
-     * {@link Pair} type combining both: </p>
-     *
-     * <p> <code>typedef pair<const Key, T> value_type;</code> </p>
-     *
-     * <p> {@link UniqueMap} stores elements, keeps sequence and enables indexing by inserting elements into a
-     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
-     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute position
-     *		in the container.
-     *	</dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd>
-     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
-     *	</dd>
-     *
-     *	<dt> Unique keys </dt>
-     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
-     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class UniqueMap<Key, T> extends MapContainer<Key, T> {
-        /**
-         * @inheritdoc
-         */
-        count(key: Key): number;
-        /**
-         * <p> Get an element </p>
-         *
-         * <p> Returns a reference to the mapped value of the element identified with <i>key</i>. </p>
-         *
-         * @param key Key value of the element whose mapped value is accessed.
-         *
-         * @throw exception out of range
-         *
-         * @return A reference object of the mapped value (_Ty)
-         */
-        get(key: Key): T;
-        /**
-         * <p> Set an item as the specified identifier. </p>
-         *
-         * <p>If the identifier is already in map, change value of the identifier. If not, then insert the object
-         * with the identifier. </p>
-         *
-         * @param key Key value of the element whose mapped value is accessed.
-         * @param val Value, the item.
-         */
-        set(key: Key, val: T): void;
-        /**
-         * <p> Extract an element. </p>
-         *
-         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
-         *
-         * @param key Key value of the element whose mapped value is accessed.
-         *
-         * @return A {@link Pair} containing the value pointed to by <i>key</i>.
-         */
-        extract(key: Key): Pair<Key, T>;
-        /**
-         * <p> Extract an element. </p>
-         *
-         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
-         *
-         * @param it An iterator pointing an element to extract.
-         *
-         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
-         *		   erased. If no such element exists,returns {@link end end()}.
-         */
-        extract(it: MapIterator<Key, T>): MapIterator<Key, T>;
-        /**
-         * <p> Extract an element. </p>
-         *
-         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
-         *
-         * @param it An iterator pointing an element to extract.
-         *
-         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
-         *		   erased. If no such element exists,returns {@link end end()}.
-         */
-        extract(it: MapReverseIterator<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        private extract_by_key(key);
-        /**
-         * @hidden
-         */
-        private extract_by_iterator(it);
-        /**
-         * @hidden
-         */
-        private extract_by_reverse_iterator(it);
-        /**
-         * Construct and insert element.
-         *
-         * Inserts a new element in the {@link UniqueMap} if its *key* is unique. This new element is constructed in
-         * place using args as the arguments for the construction of a *value_type* (which is an  object of a
-         * {@link Pair} type).
-         *
-         * The insertion only takes place if no other element in the container has a *key equivalent* to the one
-         * being emplaced (*keys* in a {@link UniqueMap} container are unique).
-         *
-         * If inserted, this effectively increases the container {@link size} by one.
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
-         * container.
-         *
-         * @param key The key used both to look up and to insert if not found.
-         * @param value Value, the item.
-         *
-         * @return If the function successfully inserts the element (because no equivalent element existed already in
-         *		   the {@link UniqueMap}), the function returns a {@link Pair} of an {@link MapIterator iterator} to
-         *		   the newly inserted element and a value of true. Otherwise, it returns an
-         *		   {@link MapIterator iterator} to the equivalent element within the container and a value of false.
-         */
-        emplace(key: Key, value: T): Pair<MapIterator<Key, T>, boolean>;
-        /**
-         * Construct and insert element.
-         *
-         * Inserts a new element in the {@link UniqueMap} if its *key* is unique. This new element is constructed in
-         * place using args as the arguments for the construction of a *value_type* (which is an  object of a
-         * {@link Pair} type).
-         *
-         * The insertion only takes place if no other element in the container has a *key equivalent* to the one
-         * being emplaced (*keys* in a {@link UniqueMap} container are unique).
-         *
-         * If inserted, this effectively increases the container {@link size} by one.
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
-         * container.
-         *
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         *
-         * @return If the function successfully inserts the element (because no equivalent element existed already in
-         *		   the {@link UniqueMap}), the function returns a {@link Pair} of an {@link MapIterator iterator} to
-         *		   the newly inserted element and a value of true. Otherwise, it returns an
-         *		   {@link MapIterator iterator} to the equivalent element within the container and a value of false.
-         */
-        emplace(pair: Pair<Key, T>): Pair<MapIterator<Key, T>, boolean>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
-         * one. </p>
-         *
-         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
-         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
-         * if so, the element is not inserted, returning an iterator to this existing element (if the function
-         * returns a value). </p>
-         *
-         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
-         *
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         *
-         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
-         *		   inserted element or to the element with an equivalent key in the {@link UniqueMap}. The
-         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
-         *		   false if an equivalent key already existed.
-         */
-        insert(pair: Pair<Key, T>): Pair<MapIterator<Key, T>, boolean>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting a new element, effectively increasing the container size by the
-         * number of elements inserted. </p>
-         *
-         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
-         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
-         * if so, the element is not inserted, returning an iterator to this existing element (if the function
-         * returns a value). </p>
-         *
-         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
-         *
-         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
-         *
-         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
-         *		   inserted element or to the element with an equivalent key in the {@link UniqueMap}. The
-         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
-         *		   false if an equivalent key already existed.
-         */
-        insert<L extends Key, U extends T>(tuple: [L, U]): Pair<MapIterator<Key, T>, boolean>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert<L extends Key, U extends T>(hint: MapIterator<Key, T>, tuple: [L, U]): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert<L extends Key, U extends T>(hint: MapReverseIterator<Key, T>, tuple: [L, U]): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * <p> Insert or assign an element. </p>
-         *
-         * <p> Inserts an element or assigns to the current element if the <i>key</i> already exists. </p>
-         *
-         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
-         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
-         * if so, the element is assigned, returning an iterator to this existing element (if the function returns a
-         * value). </p>
-         *
-         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
-         *
-         * @param key The key used both to look up and to insert if not found.
-         * @param value Value, the item.
-         *
-         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
-         *		   inserted element or to the element with an equivalent key in the {@link UniqueMap}. The
-         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
-         *		   false if an equivalent key already existed so the <i>value</i> is assigned.
-         */
-        insert_or_assign(key: Key, value: T): Pair<MapIterator<Key, T>, boolean>;
-        /**
-         * <p> Insert or assign an element. </p>
-         *
-         * <p> Inserts an element or assigns to the current element if the <i>key</i> already exists. </p>
-         *
-         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
-         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
-         * if so, the element is assigned, returning an iterator to this existing element (if the function returns a
-         * value). </p>
-         *
-         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param key The key used both to look up and to insert if not found.
-         * @param value Value, the item.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link UniqueMap}.
-         */
-        insert_or_assign(hint: MapIterator<Key, T>, key: Key, value: T): MapIterator<Key, T>;
-        /**
-         * <p> Insert or assign an element. </p>
-         *
-         * <p> Inserts an element or assigns to the current element if the <i>key</i> already exists. </p>
-         *
-         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
-         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
-         * if so, the element is assigned, returning an iterator to this existing element (if the function returns a
-         * value). </p>
-         *
-         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param key The key used both to look up and to insert if not found.
-         * @param value Value, the item.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had an
-         *		   equivalent key in the {@link UniqueMap}.
-         */
-        insert_or_assign(hint: MapReverseIterator<Key, T>, key: Key, value: T): MapReverseIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        private insert_or_assign_with_key_value(key, value);
-        /**
-         * @hidden
-         */
-        private insert_or_assign_with_hint(hint, key, value);
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An abstract multi-map. </p>
-     *
-     * <p> {@link MultiMap MultiMaps} are associative containers that store elements formed by a combination of a
-     * <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), and which allows for fast retrieval of
-     * individual elements based on their keys. </p>
-     *
-     * <p> In a {@link MapContainer}, the <i>key values</i> are generally used to identify the elements, while the
-     * <i>mapped values</i> store the content associated to this <i>key</i>. The types of <i>key</i> and
-     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a
-     * {@link Pair} type combining both: </p>
-     *
-     * <p> <code>typedef pair<const Key, T> value_type;</code> </p>
-     *
-     * <p> {@link UniqueMap} stores elements, keeps sequence and enables indexing by inserting elements into a
-     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
-     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute position
-     *		in the container.
-     *	</dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd>
-     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
-     *	</dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the keys. Each element in a map is identified by its key value.
-     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class MultiMap<Key, T> extends MapContainer<Key, T> {
-        /**
-         * Construct and insert element.
-         *
-         * Inserts a new element in the {@link MultiMap}. This new element is constructed in place using <i>args</i>
-         * as the arguments for the element's constructor.
-         *
-         * This effectively increases the container {@link size} by one.
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
-         * container.
-         *
-         * @param key The key used both to look up and to insert if not found.
-         * @param value Value, the item.
-         *
-         * @return An {@link MapIterator iterator} to the newly inserted element.
-         */
-        emplace(key: Key, value: T): MapIterator<Key, T>;
-        /**
-         * Construct and insert element.
-         *
-         * Inserts a new element in the {@link MultiMap}. This new element is constructed in place using <i>args</i>
-         * as the arguments for the element's constructor.
-         *
-         * This effectively increases the container {@link size} by one.
-         *
-         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
-         * container.
-         *
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         * @return An {@link MapIterator iterator} to the newly inserted element.
-         */
-        emplace(pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * <p> Insert elements. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
-         * the number of elements inserted. </p>
-         *
-         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
-         *			   {@link Pair.first first} member, and a *value* for the mapped value as
-         *			   {@link Pair.second second}.
-         *
-         * @return An iterator pointing to the newly inserted element.
-         */
-        insert(pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * <p> Insert elements. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
-         * the number of elements inserted. </p>
-         *
-         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
-         *
-         * @return An iterator pointing to the newly inserted element.
-         */
-        insert<L extends Key, U extends T>(tuple: [L, U]): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert<L extends Key, U extends T>(hint: MapIterator<Key, T>, tuple: [L, U]): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert<L extends Key, U extends T>(hint: MapReverseIterator<Key, T>, tuple: [L, U]): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        insert<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-    }
-}
-declare namespace std.HashMap {
-    type iterator<Key, T> = std.MapIterator<Key, T>;
-    type reverse_iterator<Key, T> = std.MapReverseIterator<Key, T>;
-}
-declare namespace std {
-    /**
-     * <p> Hashed, unordered map. </p>
-     *
-     * <p> {@link HashMap}s are associative containers that store elements formed by the combination of a <i>key value</i>
-     * and a <i>mapped value</i>, and which allows for fast retrieval of individual elements based on their <i>keys</i>.
-     * </p>
-     *
-     * <p> In an {@link HashMap}, the <i>key value</i> is generally used to uniquely identify the element, while the
-     * <i>mapped value</i> is an object with the content associated to this <i>key</i>. Types of <i>key</i> and
-     * <i>mapped value</i> may differ. </p>
-     *
-     * <p> Internally, the elements in the {@link HashMap} are not sorted in any particular order with respect to either
-     * their <i>key</i> or <i>mapped values</i>, but organized into <i>buckets</i> depending on their hash values to allow
-     * for fast access to individual elements directly by their <i>key values</i> (with a constant average time complexity
-     * on average). </p>
-     *
-     * <p> {@link HashMap} containers are faster than {@link TreeMap} containers to access individual elements by their
-     * <i>key</i>, although they are generally less efficient for range iteration through a subset of their elements. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a>
-     * </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     * 	<dt> Associative </dt>
-     * 	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		 position in the container. </dd>
-     *
-     * 	<dt> Hashed </dt>
-     * 	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
-     *		 by their <i>key</i>. </dd>
-     *
-     * 	<dt> Map </dt>
-     * 	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
-     *
-     * 	<dt> Unique keys </dt>
-     * 	<dd> No two elements in the container can have equivalent keys. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the key values.
-     *				Each element in an {@link HashMap} is uniquely identified by its key value.
-     * @param <T> Type of the mapped value.
-     *			  Each element in an {@link HashMap} is used to store some data as its mapped value.
-     *
-     * @reference http://www.cplusplus.com/reference/unordered_map/unordered_map
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class HashMap<Key, T> extends base.UniqueMap<Key, T> implements base.IHashMap<Key, T> {
-        /**
-         * @hidden
-         */
-        private hash_buckets_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from elements.
-         */
-        constructor(items: Pair<Key, T>[]);
-        /**
-         * Contruct from tuples.
-         *
-         * @param array Tuples to be contained.
-         */
-        constructor(array: [Key, T][]);
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: HashMap<Key, T>);
-        /**
-         * Construct from range iterators.
-         */
-        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        begin(): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        begin(index: number): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        end(): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        end(index: number): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(index: number): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rend(index: number): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        bucket_count(): number;
-        /**
-         * @inheritdoc
-         */
-        bucket_size(index: number): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(z: number): void;
-        /**
-         * @inheritdoc
-         */
-        bucket(key: Key): number;
-        /**
-         * @inheritdoc
-         */
-        reserve(n: number): void;
-        /**
-         * @inheritdoc
-         */
-        rehash(n: number): void;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_pair(pair: Pair<Key, T>): any;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link HashMap map} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link HashMap map container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link HashMap container}.
-         */
-        swap(obj: HashMap<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<Pair<Key, T>>): void;
-    }
-}
-declare namespace std.HashMultiMap {
-    type iterator<Key, T> = std.MapIterator<Key, T>;
-    type reverse_iterator<Key, T> = std.MapReverseIterator<Key, T>;
-}
-declare namespace std {
-    /**
-     * <p> Hashed, unordered Multimap. </p>
-     *
-     * <p> {@link HashMultiMap}s are associative containers that store elements formed by the combination of
-     * a <i>key value</i> and a <i>mapped value</i>, much like {@link HashMultiMap} containers, but allowing
-     * different elements to have equivalent <i>keys</i>. </p>
-     *
-     * <p> In an {@link HashMultiMap}, the <i>key value</i> is generally used to uniquely identify the
-     * element, while the <i>mapped value</i> is an object with the content associated to this <i>key</i>.
-     * Types of <i>key</i> and <i>mapped value</i> may differ. </p>
-     *
-     * <p> Internally, the elements in the {@link HashMultiMap} are not sorted in any particular order with
-     * respect to either their <i>key</i> or <i>mapped values</i>, but organized into <i>buckets</i> depending on
-     * their hash values to allow for fast access to individual elements directly by their <i>key values</i>
-     * (with a constant average time complexity on average). </p>
-     *
-     * <p> Elements with equivalent <i>keys</i> are grouped together in the same bucket and in such a way that
-     * an iterator can iterate through all of them. Iterators in the container are doubly linked iterators. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram" style="max-width: 100%" /> </a>
-     * </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Hashed </dt>
-     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
-     *		 by their <i>key</i>. </dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> The container can hold multiple elements with equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the key values.
-     *				Each element in an {@link HashMultiMap} is identified by a key value.
-     * @param <T> Type of the mapped value.
-     *			  Each element in an {@link HashMultiMap} is used to store some data as its mapped value.
-     *
-     * @reference http://www.cplusplus.com/reference/unordered_map/unordered_multimap
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class HashMultiMap<Key, T> extends base.MultiMap<Key, T> {
-        /**
-         * @hidden
-         */
-        private hash_buckets_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from elements.
-         */
-        constructor(items: Pair<Key, T>[]);
-        /**
-         * Contruct from tuples.
-         *
-         * @param array Tuples to be contained.
-         */
-        constructor(array: [Key, T][]);
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: HashMultiMap<Key, T>);
-        /**
-         * Construct from range iterators.
-         */
-        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        count(key: Key): number;
-        /**
-         * @inheritdoc
-         */
-        begin(): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        begin(index: number): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        end(): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        end(index: number): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(index: number): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        rend(index: number): MapReverseIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        bucket_count(): number;
-        /**
-         * @inheritdoc
-         */
-        bucket_size(n: number): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(z: number): void;
-        /**
-         * @inheritdoc
-         */
-        bucket(key: Key): number;
-        /**
-         * @inheritdoc
-         */
-        reserve(n: number): void;
-        /**
-         * @inheritdoc
-         */
-        rehash(n: number): void;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_pair(pair: Pair<Key, T>): any;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link HashMultiMap map} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link HashMultiMap map container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link HashMultiMap container}.
-         */
-        swap(obj: HashMultiMap<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<Pair<Key, T>>): void;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An abstract set. </p>
-     *
-     * <p> {@link SetContainer SetContainers} are containers that store elements allowing fast retrieval of
-     * individual elements based on their value. </p>
-     *
-     * <p> In an {@link SetContainer}, the value of an element is at the same time its <i>key</i>, used to
-     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link SetContainer} cannot be
-     * modified once in the container - they can be inserted and removed, though. </p>
-     *
-     * <p> {@link SetContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
-     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
-     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements. Each element in a {@link SetContainer} container is also identified
-     *			  by this value (each value is itself also the element's <i>key</i>).
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class SetContainer<T> extends Container<T> {
-        /**
-         * <p> {@link List} storing elements. </p>
-         *
-         * <p> Storing elements and keeping those sequence of the {@link SetContainer} are implemented by
-         * {@link data_ this list container}. Implementing index-table is also related with {@link data_ this list}
-         * by storing {@link ListIterator iterators} ({@link SetIterator} references {@link ListIterator}) who are
-         * created from {@link data_ here}. </p>
-         */
-        private data_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        assign<U extends T, InputIterator extends Iterator<U>>(begin: Iterator<U>, end: Iterator<U>): void;
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * <p> Get iterator to element. </p>
-         *
-         * <p> Searches the container for an element with <i>key</i> as value and returns an iterator to it if found,
-         * otherwise it returns an iterator to {@link end end()} (the element past the end of the container). </p>
-         *
-         * <p> Another member function, {@link count count()}, can be used to just check whether a particular element
-         * exists. </p>
-         *
-         * @param key Key to be searched for.
-         *
-         * @return An iterator to the element, if the specified value is found, or {@link end end()} if it is not
-         *		   found in the
-         */
-        abstract find(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        begin(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): SetReverseIterator<T>;
-        /**
-         * <p> Whether have the item or not. </p>
-         *
-         * <p> Indicates whether a set has an item having the specified identifier. </p>
-         *
-         * @param key Key value of the element whose mapped value is accessed.
-         *
-         * @return Whether the set has an item having the specified identifier.
-         */
-        has(val: T): boolean;
-        /**
-         * <p> Count elements with a specific key. </p>
-         *
-         * <p> Searches the container for elements with a value of k and returns the number of elements found. </p>
-         *
-         * @param key Value of the elements to be counted.
-         *
-         * @return The number of elements in the container with a <i>key</i>.
-         */
-        abstract count(val: T): number;
-        /**
-         * @inheritdoc
-         */
-        size(): number;
-        /**
-         * @inheritdoc
-         */
-        push<U extends T>(...args: U[]): number;
-        /**
-         * <p> Insert an element with hint. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container size by the
-         * number of elements inserted. </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param val Value to be inserted as an element.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had its
-         *		   same value in the {@link SetContainer}.
-         */
-        insert(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * <p> Insert an element with hint. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container size by the
-         * number of elements inserted. </p>
-         *
-         * @param hint Hint for the position where the element can be inserted.
-         * @param val Value to be inserted as an element.
-         *
-         * @return An iterator pointing to either the newly inserted element or to the element that already had its
-         *		   same value in the {@link SetContainer}.
-         */
-        insert(hint: SetReverseIterator<T>, val: T): SetReverseIterator<T>;
-        /**
-         * <p> Insert elements with a range of a  </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container size by the
-         * number of elements inserted. </p>
-         *
-         * @param begin An iterator specifying range of the begining element.
-         * @param end An iterator specifying range of the ending element.
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * @hidden
-         */
-        protected abstract _Insert_by_val(val: T): any;
-        /**
-         * @hidden
-         */
-        protected abstract _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * @hidden
-         */
-        protected abstract _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * <p> Erase an element. </p>
-         * <p> Removes from the set container the elements whose value is <i>key</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of elements removed. </p>
-         *
-         * @param key Value of the elements to be erased.
-         *
-         * @return Number of elements erased.
-         */
-        erase(val: T): number;
-        /**
-         * @inheritdoc
-         */
-        erase(it: SetIterator<T>): SetIterator<T>;
-        /**
-         * <p> Erase elements. </p>
-         * <p> Removes from the set container a range of elements.. </p>
-         *
-         * <p> This effectively reduces the container size by the number of elements removed. </p>
-         *
-         * @param begin An iterator specifying a range of beginning to erase.
-         * @param end An iterator specifying a range of end to erase.
-         */
-        erase(begin: SetIterator<T>, end: SetIterator<T>): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        erase(it: SetReverseIterator<T>): SetReverseIterator<T>;
-        /**
-         * <p> Erase elements. </p>
-         * <p> Removes from the set container a range of elements.. </p>
-         *
-         * <p> This effectively reduces the container size by the number of elements removed. </p>
-         *
-         * @param begin An iterator specifying a range of beginning to erase.
-         * @param end An iterator specifying a range of end to erase.
-         */
-        erase(begin: SetReverseIterator<T>, end: SetReverseIterator<T>): SetReverseIterator<T>;
-        /**
-         * @hidden
-         */
-        private erase_by_iterator(first, last?);
-        /**
-         * @hidden
-         */
-        private erase_by_val(val);
-        /**
-         * @hidden
-         */
-        private erase_by_range(begin, end);
-        /**
-         * <p> Abstract method handling insertions for indexing. </p>
-         *
-         * <p> This method, {@link _Handle_insert} is designed to register the <i>first to last</i> to somewhere storing
-         * those {@link SetIterator iterators} for indexing, fast accessment and retrievalance. </p>
-         *
-         * <p> When {@link insert} is called, new elements will be inserted into the {@link data_ list container} and new
-         * {@link SetIterator iterators} <i>first to last</i>, pointing the inserted elements, will be created and the
-         * newly created iterators <i>first to last</i> will be shifted into this method {@link _Handle_insert} after the
-         * insertions. </p>
-         *
-         * <p> If the derived one is {@link RBTree tree-based} like {@link TreeSet}, the {@link SetIterator iterators}
-         * will be registered into the {@link TreeSet.tree_ tree} as a {@link XTreeNode tree node item}. Else if the
-         * derived one is {@link HashBuckets hash-based} like {@link HashSet}, the <i>first</i> to <i>last</i> will be
-         * registered into the {@link HashSet.hash_buckets_ hash bucket}. </p>
-         *
-         * @param first An {@link SetIterator} to the initial position in a sequence.
-         * @param last An {@link SetIterator} to the final position in a sequence. The range used is
-         *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-         *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-         */
-        protected abstract _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * <p> Abstract method handling deletions for indexing. </p>
-         *
-         * <p> This method, {@link _Handle_erase} is designed to unregister the <i>first to last</i> to somewhere storing
-         * those {@link SetIterator iterators} for indexing, fast accessment and retrievalance. </p>
-         *
-         * <p> When {@link erase} is called with <i>first to last</i>, {@link SetIterator iterators} positioning somewhere
-         * place to be deleted, is memorized and shifted to this method {@link _Handle_erase} after the deletion process is
-         * terminated. </p>
-         *
-         * <p> If the derived one is {@link RBTree tree-based} like {@link TreeSet}, the {@link SetIterator iterators}
-         * will be unregistered from the {@link TreeSet.tree_ tree} as a {@link XTreeNode tree node item}. Else if the
-         * derived one is {@link HashBuckets hash-based} like {@link HashSet}, the <i>first to last</i> will be
-         * unregistered from the {@link HashSet.hash_buckets_ hash bucket}. </p>
-         *
-         * @param first An {@link SetIterator} to the initial position in a sequence.
-         * @param last An {@link SetIterator} to the final position in a sequence. The range used is
-         *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
-         *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
-         */
-        protected abstract _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * @hidden
-         */
-        protected _Swap(obj: SetContainer<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> An iterator of a Set. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class SetIterator<T> extends Iterator<T> implements IComparable<SetIterator<T>> {
-        private list_iterator_;
-        /**
-         * <p> Construct from source and index number. </p>
-         *
-         * <h4> Note </h4>
-         * <p> Do not create iterator directly. </p>
-         * <p> Use begin(), find() or end() in Map instead. </p>
-         *
-         * @param map The source Set to reference.
-         * @param index Sequence number of the element in the source Set.
-         */
-        constructor(source: base.SetContainer<T>, it: ListIterator<T>);
-        /**
-         * @inheritdoc
-         */
-        prev(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        next(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        advance(size: number): SetIterator<T>;
-        /**
-         * @hidden
-         */
-        private set;
-        get_list_iterator(): ListIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        value: T;
-        /**
-         * @inheritdoc
-         */
-        equal_to<U extends T>(obj: SetIterator<U>): boolean;
-        /**
-         * @inheritdoc
-         */
-        less<U extends T>(obj: SetIterator<U>): boolean;
-        /**
-         * @inheritdoc
-         */
-        hash(): number;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: SetIterator<T>): void;
-    }
-    /**
-     * <p> A reverse-iterator of Set. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class SetReverseIterator<T> extends ReverseIterator<T, SetIterator<T>, SetReverseIterator<T>> {
-        /**
-         * Construct from base iterator.
-         *
-         * @param base A reference of the base iterator, which iterates in the opposite direction.
-         */
-        constructor(base: SetIterator<T>);
-        /**
-         * @hidden
-         */
-        protected create_neighbor(base: SetIterator<T>): SetReverseIterator<T>;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An abstract set. </p>
-     *
-     * <p> {@link SetContainer SetContainers} are containers that store elements allowing fast retrieval of
-     * individual elements based on their value. </p>
-     *
-     * <p> In an {@link SetContainer}, the value of an element is at the same time its <i>key</i>, used to
-     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link SetContainer} cannot be
-     * modified once in the container - they can be inserted and removed, though. </p>
-     *
-     * <p> {@link SetContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
-     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
-     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements. Each element in a {@link SetContainer} container is also identified
-     *			  by this value (each value is itself also the element's <i>key</i>).
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class MultiSet<T> extends SetContainer<T> {
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
-         * the number of elements inserted. </p>
-         *
-         * @param key Value to be inserted as an element.
-         *
-         * @return An iterator to the newly inserted element.
-         */
-        insert(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: SetReverseIterator<T>, val: T): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-    }
-}
-declare namespace std.HashMultiSet {
-    type iterator<T> = std.SetIterator<T>;
-    type reverse_iterator<T> = std.SetReverseIterator<T>;
-}
-declare namespace std {
-    /**
-     * <p> Hashed, unordered Multiset. </p>
-     *
-     * <p> {@link HashMultiSet HashMultiSets} are containers that store elements in no particular order, allowing fast
-     * retrieval of individual elements based on their value, much like {@link HashMultiSet} containers,
-     * but allowing different elements to have equivalent values. </p>
-     *
-     * <p> In an {@link HashMultiSet}, the value of an element is at the same time its <i>key</i>, used to
-     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link HashMultiSet} cannot be
-     * modified once in the container - they can be inserted and removed, though. </p>
-     *
-     * <p> Internally, the elements in the {@link HashMultiSet} are not sorted in any particular, but
-     * organized into <i>buckets</i> depending on their hash values to allow for fast access to individual
-     * elements directly by their <i>values</i> (with a constant average time complexity on average). </p>
-     *
-     * <p> Elements with equivalent values are grouped together in the same bucket and in such a way that an
-     * iterator can iterate through all of them. Iterators in the container are doubly linked iterators. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Hashed </dt>
-     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
-     *		 by their <i>key</i>. </dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> The container can hold multiple elements with equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *		   Each element in an {@link UnorderedMultiSet} is also identified by this value..
-     *
-     * @reference http://www.cplusplus.com/reference/unordered_set/unordered_multiset
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class HashMultiSet<T> extends base.MultiSet<T> {
-        /**
-         * @hidden
-         */
-        private hash_buckets_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from elements.
-         */
-        constructor(items: T[]);
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: HashMultiSet<T>);
-        /**
-         * Construct from range iterators.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(key: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        count(key: T): number;
-        /**
-         * @inheritdoc
-         */
-        begin(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        begin(index: number): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(index: number): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(index: number): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(index: number): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        bucket_count(): number;
-        /**
-         * @inheritdoc
-         */
-        bucket_size(n: number): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(z: number): void;
-        /**
-         * @inheritdoc
-         */
-        bucket(key: T): number;
-        /**
-         * @inheritdoc
-         */
-        reserve(n: number): void;
-        /**
-         * @inheritdoc
-         */
-        rehash(n: number): void;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_val(val: T): any;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link HashMultiSet set} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link HashMultiSet set container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link HashMultiSet container}.
-         */
-        swap(obj: HashMultiSet<T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> An abstract set. </p>
-     *
-     * <p> {@link SetContainer SetContainers} are containers that store elements allowing fast retrieval of
-     * individual elements based on their value. </p>
-     *
-     * <p> In an {@link SetContainer}, the value of an element is at the same time its <i>key</i>, used to uniquely
-     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link SetContainer} cannot be modified
-     * once in the container - they can be inserted and removed, though. </p>
-     *
-     * <p> {@link SetContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
-     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
-     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     *
-     *	<dt> Unique keys </dt>
-     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements. Each element in a {@link SetContainer} container is also identified
-     *			  by this value (each value is itself also the element's <i>key</i>).
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class UniqueSet<T> extends SetContainer<T> {
-        /**
-         * @inheritdoc
-         */
-        count(key: T): number;
-        /**
-         * <p> Extract an element. </p>
-         *
-         * <p> Extracts the element pointed to by <i>val</i> and erases it from the {@link UniqueSet}. </p>
-         *
-         * @param val Value to be extracted.
-         *
-         * @return A value.
-         */
-        extract(val: T): T;
-        /**
-         * <p> Extract an element. </p>
-         *
-         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
-         *
-         * @param it An iterator pointing an element to extract.
-         *
-         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
-         *		   erased. If no such element exists,returns {@link end end()}.
-         */
-        extract(it: SetIterator<T>): SetIterator<T>;
-        /**
-         * <p> Extract an element. </p>
-         *
-         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
-         *
-         * @param it An iterator pointing an element to extract.
-         *
-         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
-         *		   erased. If no such element exists,returns {@link end end()}.
-         */
-        extract(it: SetReverseIterator<T>): SetReverseIterator<T>;
-        /**
-         * @hidden
-         */
-        private extract_by_key(val);
-        /**
-         * @hidden
-         */
-        private extract_by_iterator(it);
-        /**
-         * @hidden
-         */
-        private extract_by_reverse_iterator(it);
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
-         * the number of element inserted (zero or one). </p>
-         *
-         * <p> Because elements in a {@link UniqueSet UniqueSets} are unique, the insertion operation checks whether
-         * each inserted element is equivalent to an element already in the container, and if so, the element is not
-         * inserted, returning an iterator to this existing element (if the function returns a value). </p>
-         *
-         * <p> For a similar container allowing for duplicate elements, see {@link MultiSet}. </p>
-         *
-         * @param key Value to be inserted as an element.
-         *
-         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
-         *		   inserted element or to the equivalent element already in the {@link UniqueSet}. The
-         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
-         *		   false if an equivalent element already existed.
-         */
-        insert(val: T): Pair<SetIterator<T>, boolean>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert(hint: SetReverseIterator<T>, val: T): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-    }
-}
-declare namespace std.HashSet {
-    type iterator<T> = std.SetIterator<T>;
-    type reverse_iterator<T> = std.SetReverseIterator<T>;
-}
-declare namespace std {
-    /**
-     * <p> Hashed, unordered set. </p>
-     *
-     * <p> {@link HashSet}s are containers that store unique elements in no particular order, and which
-     * allow for fast retrieval of individual elements based on their value. </p>
-     *
-     * <p> In an {@link HashSet}, the value of an element is at the same time its <i>key</i>, that
-     * identifies it uniquely. Keys are immutable, therefore, the elements in an {@link HashSet} cannot be
-     * modified once in the container - they can be inserted and removed, though. </p>
-     *
-     * <p> Internally, the elements in the {@link HashSet} are not sorted in any particular order, but
-     * organized into buckets depending on their hash values to allow for fast access to individual elements
-     * directly by their <i>values</i> (with a constant average time complexity on average). </p>
-     *
-     * <p> {@link HashSet} containers are faster than {@link TreeSet} containers to access individual
-     * elements by their <i>key</i>, although they are generally less efficient for range iteration through a
-     * subset of their elements. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Hashed </dt>
-     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
-     *		 by their <i>key</i>. </dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     *
-     *	<dt> Unique keys </dt>
-     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *			  Each element in an {@link HashSet} is also uniquely identified by this value.
-     *
-     * @reference http://www.cplusplus.com/reference/unordered_set/unordered_set
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class HashSet<T> extends base.UniqueSet<T> implements base.IHashSet<T> {
-        /**
-         * @hidden
-         */
-        private hash_buckets_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from elements.
-         */
-        constructor(items: T[]);
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: HashSet<T>);
-        /**
-         * Construct from range iterators.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(key: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        begin(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        begin(index: number): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(index: number): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(index: number): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(index: number): SetReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        bucket_count(): number;
-        /**
-         * @inheritdoc
-         */
-        bucket_size(n: number): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(): number;
-        /**
-         * @inheritdoc
-         */
-        max_load_factor(z: number): void;
-        /**
-         * @inheritdoc
-         */
-        bucket(key: T): number;
-        /**
-         * @inheritdoc
-         */
-        reserve(n: number): void;
-        /**
-         * @inheritdoc
-         */
-        rehash(n: number): void;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_val(val: T): any;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link HashSet set} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link HashSet set container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link HashSet container}.
-         */
-        swap(obj: HashSet<T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std.List {
-    type iterator<T> = std.ListIterator<T>;
-    type reverse_iterator<T> = std.ListReverseIterator<T>;
-}
-declare namespace std {
-    /**
-     * <p> Doubly linked list. </p>
-     *
-     * <p> {@link List}s are sequence containers that allow constant time insert and erase operations anywhere within the
-     * sequence, and iteration in both directions. </p>
-     *
-     * <p> List containers are implemented as doubly-linked lists; Doubly linked lists can store each of the elements they
-     * contain in different and unrelated storage locations. The ordering is kept internally by the association to each
-     * element of a link to the element preceding it and a link to the element following it. </p>
-     *
-     * <p> They are very similar to forward_list: The main difference being that forward_list objects are single-linked
-     * lists, and thus they can only be iterated forwards, in exchange for being somewhat smaller and more efficient. </p>
-     *
-     * <p> Compared to other base standard sequence containers (array, vector and deque), lists perform generally better
-     * in inserting, extracting and moving elements in any position within the container for which an iterator has already
-     * been obtained, and therefore also in algorithms that make intensive use of these, like sorting algorithms. </p>
-     *
-     * <p> The main drawback of lists and forward_lists compared to these other sequence containers is that they lack
-     * direct access to the elements by their position; For example, to access the sixth element in a list, one has to
-     * iterate from a known position (like the beginning or the end) to that position, which takes linear time in the
-     * distance between these. They also consume some extra memory to keep the linking information associated to each
-     * element (which may be an important factor for large lists of small-sized elements). </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     * 	<dt> Sequence </dt>
-     * 	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements are accessed by
-     *		 their position in this sequence. </dd>
-     *
-     * 	<dt> Doubly-linked list </dt>
-     *	<dd> Each element keeps information on how to locate the next and the previous elements, allowing constant time
-     *		 insert and erase operations before or after a specific element (even of entire ranges), but no direct random
-     *		 access. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @reference http://www.cplusplus.com/reference/list/list/
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class List<T> extends base.Container<T> implements base.IDequeContainer<T> {
-        /**
-         * @hidden
-         */
-        private begin_;
-        /**
-         * @hidden
-         */
-        private end_;
-        /**
-         * @hidden
-         */
-        private size_;
-        /**
-         * <p> Default Constructor. </p>
-         *
-         * <p> Constructs an empty container, with no elements. </p>
-         */
-        constructor();
-        /**
-         * <p> Initializer list Constructor. </p>
-         *
-         * <p> Constructs a container with a copy of each of the elements in <i>array</i>, in the same order. </p>
-         *
-         * @param array An array containing elements to be copied and contained.
-         */
-        constructor(items: Array<T>);
-        /**
-         * <p> Fill Constructor. </p>
-         *
-         * <p> Constructs a container with <i>n</i> elements. Each element is a copy of <i>val</i> (if provided). </p>
-         *
-         * @param n Initial container size (i.e., the number of elements in the container at construction).
-         * @param val Value to fill the container with. Each of the <i>n</i> elements in the container is
-         *			  initialized to a copy of this value.
-         */
-        constructor(size: number, val: T);
-        /**
-         * <p> Copy Constructor. </p>
-         *
-         * <p> Constructs a container with a copy of each of the elements in <i>container</i>, in the same order. </p>
-         *
-         * @param container Another container object of the same type (with the same class template
-         *					arguments <i>T</i>), whose contents are either copied or acquired.
-         */
-        constructor(container: List<T>);
-        /**
-         * <p> Range Constructor. </p>
-         *
-         * <p> Constructs a container with as many elements as the range (<i>begin</i>, <i>end<i>), with each
-         * element emplace-constructed from its corresponding element in that range, in the same order. </p>
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * @inheritdoc
-         */
-        assign(n: number, val: T): void;
-        /**
-         * @inheritdoc
-         */
-        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        begin(): ListIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(): ListIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): ListReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): ListReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        size(): number;
-        /**
-         * @inheritdoc
-         */
-        front(): T;
-        /**
-         * @inheritdoc
-         */
-        back(): T;
-        /**
-         * @inheritdoc
-         */
-        push<U extends T>(...items: U[]): number;
-        /**
-         * @inheritdoc
-         */
-        push_front(val: T): void;
-        /**
-         * @inheritdoc
-         */
-        push_back(val: T): void;
-        /**
-         * @inheritdoc
-         */
-        pop_front(): void;
-        /**
-         * @inheritdoc
-         */
-        pop_back(): void;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new element is inserted.
-         *				   {@link iterator}> is a member type, defined as a
-         *				   {@link ListIterator bidirectional iterator} type that points to elements.
-         * @param val Value to be inserted as an element.
-         *
-         * @return An iterator that points to the newly inserted element; <i>val</i>.
-         */
-        insert(position: ListIterator<T>, val: T): ListIterator<T>;
-        /**
-         * <p> Insert elements by repeated filling. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
-         *				   member type, defined as a {@link ListIterator bidirectional iterator} type that points to
-         *				   elements.
-         * @param size Number of elements to insert.
-         * @param val Value to be inserted as an element.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert(position: ListIterator<T>, size: number, val: T): ListIterator<T>;
-        /**
-         * <p> Insert elements by range iterators. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
-         *				   member type, defined as a {@link ListIterator bidirectional iterator} type that points to
-         *				   elements.
-         * @param begin An iterator specifying range of the begining element.
-         * @param end An iterator specifying range of the ending element.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(position: ListIterator<T>, begin: InputIterator, end: InputIterator): ListIterator<T>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new element is inserted.
-         *				   {@link iterator}> is a member type, defined as a
-         *				   {@link ListReverseIterator bidirectional iterator} type that points to elements.
-         * @param val Value to be inserted as an element.
-         *
-         * @return An iterator that points to the newly inserted element; <i>val</i>.
-         */
-        insert(position: ListReverseIterator<T>, val: T): ListReverseIterator<T>;
-        /**
-         * <p> Insert elements by repeated filling. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
-         *				   member type, defined as a {@link ListReverseIterator bidirectional iterator} type that points to
-         *				   elements.
-         * @param size Number of elements to insert.
-         * @param val Value to be inserted as an element.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert(position: ListReverseIterator<T>, size: number, val: T): ListReverseIterator<T>;
-        /**
-         * <p> Insert elements by range iterators. </p>
-         *
-         * <p> The container is extended by inserting a new element before the element at the specified
-         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
-         * inserted. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
-         * inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
-         *				   member type, defined as a {@link ListReverseIterator bidirectional iterator} type that points to
-         *				   elements.
-         * @param begin An iterator specifying range of the begining element.
-         * @param end An iterator specifying range of the ending element.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(position: ListReverseIterator<T>, begin: InputIterator, end: InputIterator): ListReverseIterator<T>;
-        /**
-         * @hidden
-         */
-        private insert_by_val(position, val);
-        /**
-         * @hidden
-         */
-        protected _Insert_by_repeating_val(position: ListIterator<T>, size: number, val: T): ListIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(position: ListIterator<T>, begin: InputIterator, end: InputIterator): ListIterator<T>;
-        /**
-         * <p> Erase an element. </p>
-         *
-         * <p> Removes from the {@link List} either a single element; <i>position</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of element removed. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} objects are specifically designed to be
-         * efficient inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Iterator pointing to a single element to be removed from the {@link List}.
-         *
-         * @return An iterator pointing to the element that followed the last element erased by the function call.
-         *		   This is the {@link end end()} if the operation erased the last element in the sequence.
-         */
-        erase(position: ListIterator<T>): ListIterator<T>;
-        /**
-         * <p> Erase elements. </p>
-         *
-         * <p> Removes from the {@link List} container a range of elements. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of elements removed. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} objects are specifically designed to be
-         * efficient inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param begin An iterator specifying a range of beginning to erase.
-         * @param end An iterator specifying a range of end to erase.
-         *
-         * @return An iterator pointing to the element that followed the last element erased by the function call.
-         *		   This is the {@link end end()} if the operation erased the last element in the sequence.
-         */
-        erase(begin: ListIterator<T>, end: ListIterator<T>): ListIterator<T>;
-        /**
-         * <p> Erase an element. </p>
-         *
-         * <p> Removes from the {@link List} either a single element; <i>position</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of element removed. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} objects are specifically designed to be
-         * efficient inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param position Iterator pointing to a single element to be removed from the {@link List}.
-         *
-         * @return An iterator pointing to the element that followed the last element erased by the function call.
-         *		   This is the {@link rend rend()} if the operation erased the last element in the sequence.
-         */
-        erase(position: ListReverseIterator<T>): ListReverseIterator<T>;
-        /**
-         * <p> Erase elements. </p>
-         *
-         * <p> Removes from the {@link List} container a range of elements. </p>
-         *
-         * <p> This effectively reduces the container {@link size} by the number of elements removed. </p>
-         *
-         * <p> Unlike other standard sequence containers, {@link List} objects are specifically designed to be
-         * efficient inserting and removing elements in any position, even in the middle of the sequence. </p>
-         *
-         * @param begin An iterator specifying a range of beginning to erase.
-         * @param end An iterator specifying a range of end to erase.
-         *
-         * @return An iterator pointing to the element that followed the last element erased by the function call.
-         *		   This is the {@link rend rend()} if the operation erased the last element in the sequence.
-         */
-        erase(begin: ListReverseIterator<T>, end: ListReverseIterator<T>): ListReverseIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Erase_by_range(first: ListIterator<T>, last: ListIterator<T>): ListIterator<T>;
-        /**
-         * <p> Remove duplicate values. </p>
-         *
-         * <p> Removes all but the first element from every consecutive group of equal elements in the  </p>
-         *
-         * <p> Notice that an element is only removed from the {@link List} container if it compares equal to the
-         * element immediately preceding it. Thus, this function is especially useful for sorted lists. </p>
-         */
-        unique(): void;
-        /**
-         * <p> Remove duplicate values. </p>
-         *
-         * <p> Removes all but the first element from every consecutive group of equal elements in the  </p>
-         *
-         * <p> The argument <i>binary_pred</i> is a specific comparison function that determine the <u>uniqueness</u>
-         * of an element. In fact, any behavior can be implemented (and not only an equality comparison), but notice
-         * that the function will call <code>binary_pred(it.value, it.prev().value)</code> for all pairs of elements
-         * (where <code>it</code> is an iterator to an element, starting from the second) and remove <code>it</code>
-         * from the {@link List} if the predicate returns <code>true</code>.
-         *
-         * <p> Notice that an element is only removed from the {@link List} container if it compares equal to the
-         * element immediately preceding it. Thus, this function is especially useful for sorted lists. </p>
-         *
-         * @param binary_pred Binary predicate that, taking two values of the same type than those contained in the
-         *					  {@link List}, returns <code>true</code> to remove the element passed as first argument
-         *					  from the container, and <code>false</code> otherwise. This shall be a function pointer
-         *					  or a function object.
-         */
-        unique(binary_pred: (left: T, right: T) => boolean): void;
-        /**
-         * <p> Remove elements with specific value. </p>
-         *
-         * <p> Removes from the container all the elements that compare equal to <i>val</i>. This calls the
-         * destructor of these objects and reduces the container {@link size} by the number of elements removed. </p>
-         *
-         * <p> Unlike member function {@link List.erase}, which erases elements by their position (using an
-         * iterator), this function ({@link List.remove}) removes elements by their value. </p>
-         *
-         * <p> A similar function, {@link List.remove_if}, exists, which allows for a condition other than an
-         * equality comparison to determine whether an element is removed. </p>
-         *
-         * @param val Value of the elements to be removed.
-         */
-        remove(val: T): void;
-        /**
-         * <p> Remove elements fulfilling condition. </p>
-         *
-         * <p> Removes from the container all the elements for which <i>pred</i> returns <code>true</code>. This
-         * calls the destructor of these objects and reduces the container {@link size} by the number of elements
-         * removed. </p>
-         *
-         * <p> The function calls <code>pred(it.value)</code> for each element (where <code>it</code> is an iterator
-         * to that element). Any of the elements in the list for which this returns <code>true</code>, are removed
-         * from the  </p>
-         *
-         * @param pred Unary predicate that, taking a value of the same type as those contained in the forward_list
-         *			   object, returns <code>true</code> for those values to be removed from the container, and
-         *			   <code>false</code> for those remaining. This can either be a function pointer or a function
-         *			   object.
-         */
-        remove_if(pred: (val: T) => boolean): void;
-        /**
-         * <p> Merge sorted {@link List Lists}. </p>
-         *
-         * <p> Merges <i>obj</i> into the {@link List} by transferring all of its elements at their respective
-         * ordered positions into the container (<font color='red'>both containers shall already be ordered</font>).
-         * </p>
-         *
-         * <p> This effectively removes all the elements in <i>obj</i> (which becomes {@link empty}), and inserts
-         * them into their ordered position within container (which expands in {@link size} by the number of elements
-         * transferred). The operation is performed without constructing nor destroying any element: they are
-         * transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the value_type supports
-         * move-construction or not. </p>
-         *
-         * <p> This function requires that the {@link List} containers have their elements already ordered by value
-         * ({@link less}) before the call. For an alternative on unordered {@link List Lists}, see
-         * {@link List.splice}. </p>
-         *
-         * <p> Assuming such ordering, each element of <i>obj</i> is inserted at the position that corresponds to its
-         * value according to the strict weak ordering defined by {@link less}. The resulting order of equivalent
-         * elements is stable (i.e., equivalent elements preserve the relative order they had before the call, and
-         * existing elements precede those equivalent inserted from <i>obj</i>). </p>
-         *
-         * The function does nothing if <code>this == obj</code>.
-         *
-         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
-         * 			  Note that this function modifies <i>obj</i> no matter whether an lvalue or rvalue reference is
-         *			  passed.
-         */
-        merge<U extends T>(obj: List<U>): void;
-        /**
-         * <p> Merge sorted {@link List Lists}. </p>
-         *
-         * <p> Merges <i>obj</i> into the {@link List} by transferring all of its elements at their respective
-         * ordered positions into the container (<font color='red'>both containers shall already be ordered</font>).
-         * </p>
-         *
-         * <p> This effectively removes all the elements in <i>obj</i> (which becomes {@link empty}), and inserts
-         * them into their ordered position within container (which expands in {@link size} by the number of elements
-         * transferred). The operation is performed without constructing nor destroying any element: they are
-         * transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the value_type supports
-         * move-construction or not. </p>
-         *
-         * <p> The argument <i>compare</i> is a specific predicate to perform the comparison operation between
-         * elements. This comparison shall produce a strict weak ordering of the elements (i.e., a consistent
-         * transitive comparison, without considering its reflexiveness).
-         *
-         * <p> This function requires that the {@link List} containers have their elements already ordered by
-         * <i>compare</i> before the call. For an alternative on unordered {@link List Lists}, see
-         * {@link List.splice}. </p>
-         *
-         * <p> Assuming such ordering, each element of <i>obj</i> is inserted at the position that corresponds to its
-         * value according to the strict weak ordering defined by <i>compare</i>. The resulting order of equivalent
-         * elements is stable (i.e., equivalent elements preserve the relative order they had before the call, and
-         * existing elements precede those equivalent inserted from <i>obj</i>). </p>
-         *
-         * The function does nothing if <code>this == obj</code>.
-         *
-         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
-         * 			  Note that this function modifies <i>obj</i> no matter whether an lvalue or rvalue reference is
-         *			  passed.
-         * @param compare Binary predicate that, taking two values of the same type than those contained in the
-         *				  {@link list}, returns <code>true</code> if the first argument is considered to go before
-         *				  the second in the strict weak ordering it defines, and <code>false</code> otherwise.
-         *				  This shall be a function pointer or a function object.
-         */
-        merge<U extends T>(obj: List<U>, compare: (left: T, right: T) => boolean): void;
-        /**
-         * <p> Transfer elements from {@link List} to {@link List}. </p>
-         *
-         * <p> Transfers elements from <i>obj</i> into the container, inserting them at <i>position</i>. </p>
-         *
-         * <p> This effectively inserts all elements into the container and removes them from <i>obj</i>, altering
-         * the sizes of both containers. The operation does not involve the construction or destruction of any
-         * element. They are transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the
-         * value_type supports move-construction or not. </p>
-         *
-         * <p> This first version (1) transfers all the elements of <i>obj</i> into the  </p>
-         *
-         * @param position Position within the container where the elements of <i>obj</i> are inserted.
-         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
-         */
-        splice<U extends T>(position: ListIterator<T>, obj: List<U>): void;
-        /**
-         * <p> Transfer an element from {@link List} to {@link List}. </p>
-         *
-         * <p> Transfers an element from <i>obj</i>, which is pointed by an {@link ListIterator iterator} <i>it</i>,
-         * into the container, inserting the element at specified <i>position</i>. </p>
-         *
-         * <p> This effectively inserts an element into the container and removes it from <i>obj</i>, altering the
-         * sizes of both containers. The operation does not involve the construction or destruction of any element.
-         * They are transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the value_type
-         * supports move-construction or not. </p>
-         *
-         * <p> This second version (2) transfers only the element pointed by <i>it</i> from <i>obj</i> into the
-         *  </p>
-         *
-         * @param position Position within the container where the element of <i>obj</i> is inserted.
-         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
-         *			  This parameter may be <code>this</code> if <i>position</i> points to an element not actually
-         *			  being spliced.
-         * @param it {@link ListIterator Iterator} to an element in <i>obj</i>. Only this single element is
-         *			 transferred.
-         */
-        splice<U extends T>(position: ListIterator<T>, obj: List<U>, it: ListIterator<U>): void;
-        /**
-         * <p> Transfer elements from {@link List} to {@link List}. </p>
-         *
-         * <p> Transfers elements from <i>obj</i> into the container, inserting them at <i>position</i>. </p>
-         *
-         * <p> This effectively inserts those elements into the container and removes them from <i>obj</i>, altering
-         * the sizes of both containers. The operation does not involve the construction or destruction of any
-         * element. They are transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the
-         * value_type supports move-construction or not. </p>
-         *
-         * <p> This third version (3) transfers the range [<i>begin</i>, <i>end</i>) from <i>obj</i> into the
-         *  </p>
-         *
-         * @param position Position within the container where the elements of <i>obj</i> are inserted.
-         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
-         *			  This parameter may be <code>this</code> if <i>position</i> points to an element not actually
-         *			  being spliced.
-         * @param begin {@link ListIterator An Iterator} specifying initial position of a range of elements in
-         *				<i>obj</i>. Transfers the elements in the range [<b><i>begin</i></b>, <i>end</i>) to
-         *				<i>position</i>.
-         * @param end {@link ListIterator An Iterator} specifying final position of a range of elements in
-         *			  <i>obj</i>. Transfers the elements in the range [<i>begin</i>, <b><i>end</i></b>) to
-         *			  <i>position</i>. Notice that the range includes all the elements between <i>begin<i/> and
-         *			  <i>end</i>, including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
-         */
-        splice<U extends T>(position: ListIterator<T>, obj: List<U>, begin: ListIterator<U>, end: ListIterator<U>): void;
-        /**
-         * <p> Sort elements in  </p>
-         *
-         * <p> Sorts the elements in the {@link List}, altering their position within the  </p>
-         *
-         * <p> The sorting is performed by applying an algorithm that uses {@link less}. This comparison shall
-         * produce a strict weak ordering of the elements (i.e., a consistent transitive comparison, without
-         * considering its reflexiveness). </p>
-         *
-         * <p> The resulting order of equivalent elements is stable: i.e., equivalent elements preserve the relative
-         * order they had before the call. </p>
-         *
-         * <p> The entire operation does not involve the construction, destruction or copy of any element object.
-         * Elements are moved within the  </p>
-         */
-        sort(): void;
-        /**
-         * <p> Sort elements in  </p>
-         *
-         * <p> Sorts the elements in the {@link List}, altering their position within the  </p>
-         *
-         * <p> The sorting is performed by applying an algorithm that uses <i>compare</i>. This comparison shall
-         * produce a strict weak ordering of the elements (i.e., a consistent transitive comparison, without
-         * considering its reflexiveness). </p>
-         *
-         * <p> The resulting order of equivalent elements is stable: i.e., equivalent elements preserve the relative
-         * order they had before the call. </p>
-         *
-         * <p> The entire operation does not involve the construction, destruction or copy of any element object.
-         * Elements are moved within the  </p>
-         *
-         * @param compare Binary predicate that, taking two values of the same type of those contained in the
-         *				  {@link List}, returns <code>true</code> if the first argument goes before the second
-         *				  argument in the strict weak ordering it defines, and <code>false</code> otherwise. This
-         *				  shall be a function pointer or a function object.
-         */
-        sort(compare: (left: T, right: T) => boolean): void;
-        /**
-         * @hidden
-         */
-        private qsort(first, last, compare);
-        /**
-         * @hidden
-         */
-        private partition(first, last, compare);
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link List container} object with same type of elements. Sizes and container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were in <i>obj</i>
-         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
-         * pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link List container} of the same type of elements (i.e., instantiated
-         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
-         *			  {@link container List}.
-         */
-        swap(obj: List<T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> An iterator, node of a List. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class ListIterator<T> extends Iterator<T> {
-        /**
-         * @hidden
-         */
-        private prev_;
-        /**
-         * @hidden
-         */
-        private next_;
-        /**
-         * @hidden
-         */
-        private value_;
-        /**
-         * <p> Construct from the source {@link List container}. </p>
-         *
-         * <h4> Note </h4>
-         * <p> Do not create the iterator directly, by yourself. </p>
-         * <p> Use {@link List.begin begin()}, {@link List.end end()} in {@link List container} instead. </p>
-         *
-         * @param source The source {@link List container} to reference.
-         * @param prev A refenrece of previous node ({@link ListIterator iterator}).
-         * @param next A refenrece of next node ({@link ListIterator iterator}).
-         * @param value Value to be stored in the node (iterator).
-         */
-        constructor(source: List<T>, prev: ListIterator<T>, next: ListIterator<T>, value: T);
-        private list();
-        /**
-         * @inheritdoc
-         */
-        prev(): ListIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        next(): ListIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        advance(step: number): ListIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        /**
-         * Set value of the iterator is pointing to.
-         *
-         * @param val Value to set.
-         */
-        value: T;
-        /**
-         * @inheritdoc
-         */
-        equal_to(obj: ListIterator<T>): boolean;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: ListIterator<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> A reverse-iterator of List. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class ListReverseIterator<T> extends ReverseIterator<T, ListIterator<T>, ListReverseIterator<T>> {
-        /**
-         * Construct from base iterator.
-         *
-         * @param base A reference of the base iterator, which iterates in the opposite direction.
-         */
-        constructor(base: ListIterator<T>);
-        /**
-         * @hidden
-         */
-        protected create_neighbor(base: ListIterator<T>): ListReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        /**
-         * Set value of the iterator is pointing to.
-         *
-         * @param val Value to set.
-         */
-        value: T;
-    }
-}
-declare namespace std {
-    /**
-     * <p> Priority queue. </p>
-     *
-     * <p> {@link PriorityQueue Priority queues} are a type of container adaptors, specifically designed such that its
-     * first element is always the greatest of the elements it contains, according to some <i>strict weak ordering</i>
-     * criterion. </p>
-     *
-     * <p> This context is similar to a <i>heap</i>, where elements can be inserted at any moment, and only the
-     * <i>max heap</i> element can be retrieved (the one at the top in the {@link PriorityQueue priority queue}). </p>
-     *
-     * <p> {@link PriorityQueue Priority queues} are implemented as <i>container adaptors</i>, which are classes that
-     * use an encapsulated object of a specific container class as its {@link container_ underlying container},
-     * providing a specific set of member functions to access its elements. Elements are popped from the <i>"back"</i>
-     * of the specific container, which is known as the <i>top</i> of the {@link PriorityQueue Priority queue}. </p>
-     *
-     * <p> The {@link container_ underlying container} may be any of the standard container class templates or some
-     * other specifically designed container class. The container shall be accessible through
-     * {@link IArrayIterator random access iterators} and support the following operations: </p>
-     *
-     * <ul>
-     *	<li> empty() </li>
-     *	<li> size() </li>
-     *	<li> front() </li>
-     *	<li> push_back() </li>
-     *	<li> pop_back() </li>
-     * </ul>
-     *
-     * <p> The standard container classes {@link Vector} and {@link Deque} fulfill these requirements. By default, if
-     * no container class is specified for a particular {@link PriorityQueue} class instantiation, the standard
-     * container {@link Vector} is used. </p>
-     *
-     * <p> Support of {@link IArrayIterator random access iterators} is required to keep a heap structure internally
-     * at all times. This is done automatically by the container adaptor by automatically calling the algorithm
-     * functions <i>make_heap</i>, <i>push_heap</i> and <i>pop_heap</i> when needed. </p>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @reference http://www.cplusplus.com/reference/queue/priority_queue/
-     * @author Jeongho Nam
-     */
-    class PriorityQueue<T> {
-        /**
-         * <p> The <i>underlying container</i> for implementing the <i>priority queue</i>. </p>
-         *
-         * <p> Following standard definition from the C++ committee, the <i>underlying container</i> should be one of
-         * {@link Vector} or {@link Deque}, however, I've adopted {@link TreeMultiSet} instead of them. Of course,
-         * there are proper reasons for adapting the {@link TreeMultiSet} even violating standard advice. </p>
-         *
-         * <p> <i>Underlying container</i> of {@link PriorityQueue} must keep a condition; the highest (or lowest)
-         * element must be placed on the terminal node for fast retrieval and deletion. To keep the condition with
-         * {@link Vector} or {@link Deque}, lots of times will only be spent for re-arranging elements. It calls
-         * rearrangement functions like <i>make_heap</i>, <i>push_heap</i> and <i>pop_head</i> for rearrangement. </p>
-         *
-         * <p> However, the {@link TreeMultiSet} container always keeps arrangment automatically without additional
-         * operations and it even meets full criteria of {@link PriorityQueue}. Those are the reason why I've adopted
-         * {@link TreeMultiSet} as the <i>underlying container</i> of {@link PriorityQueue}. </p>
-         */
-        private container_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from compare.
-         *
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(compare: (left: T, right: T) => boolean);
-        /**
-         * Contruct from elements.
-         *
-         * @param array Elements to be contained.
-         */
-        constructor(array: Array<T>);
-        /**
-         * Contruct from elements with compare.
-         *
-         * @param array Elements to be contained.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(array: Array<T>, compare: (left: T, right: T) => boolean);
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: base.IContainer<T>);
-        /**
-         * Copy Constructor with compare.
-         *
-         * @param container A container to be copied.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(container: base.IContainer<T>, compare: (left: T, right: T) => boolean);
-        /**
-         * Range Constructor.
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * Range Constructor with compare.
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>, compare: (left: T, right: T) => boolean);
-        /**
-         * <p> Return size. </p>
-         *
-         * <p> Returns the number of elements in the {@link PriorityQueue}. </p>
-         *
-         * <p> This member function effectively calls member {@link IArray.size size} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return The number of elements in the underlying
-         */
-        size(): number;
-        /**
-         * <p> Test whether container is empty. </p>
-         *
-         * <p> Returns whether the {@link PriorityQueue} is empty: i.e. whether its {@link size} is zero. </p>
-         *
-         * <p> This member function effectively calls member {@link IARray.empty empty} of the
-         * {@link container_ underlying container} object. </p>
-         */
-        empty(): boolean;
-        /**
-         * <p> Access top element. </p>
-         *
-         * <p> Returns a constant reference to the top element in the {@link PriorityQueue}. </p>
-         *
-         * <p> The top element is the element that compares higher in the {@link PriorityQueue}, and the next that is
-         * removed from the container when {@link PriorityQueue.pop} is called. </p>
-         *
-         * <p> This member function effectively calls member {@link IArray.front front} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return A reference to the top element in the {@link PriorityQueue}.
-         */
-        top(): T;
-        /**
-         * <p> Insert element. </p>
-         *
-         * <p> Inserts a new element in the {@link PriorityQueue}. The content of this new element is initialized to
-         * <i>val</i>.
-         *
-         * <p> This member function effectively calls the member function {@link IArray.push_back push_back} of the
-         * {@link container_ underlying container} object, and then reorders it to its location in the heap by calling
-         * the <i>push_heap</i> algorithm on the range that includes all the elements of the  </p>
-         *
-         * @param val Value to which the inserted element is initialized.
-         */
-        push(val: T): void;
-        /**
-         * <p> Remove top element. </p>
-         *
-         * <p> Removes the element on top of the {@link PriorityQueue}, effectively reducing its {@link size} by one.
-         * The element removed is the one with the highest (or lowest) value. </p>
-         *
-         * <p> The value of this element can be retrieved before being popped by calling member
-         * {@link PriorityQueue.top}. </p>
-         *
-         * <p> This member function effectively calls the <i>pop_heap</i> algorithm to keep the heap property of
-         * {@link PriorityQueue PriorityQueues} and then calls the member function {@link IArray.pop_back pop_back} of
-         * the {@link container_ underlying container} object to remove the element. </p>
-         */
-        pop(): void;
-        /**
-         * <p> Swap contents. </p>
-         *
-         * <p> Exchanges the contents of the container adaptor by those of <i>obj</i>, swapping both the
-         * {@link container_ underlying container} value and their comparison function using the corresponding
-         * {@link std.swap swap} non-member functions (unqualified). </p>
-         *
-         * <p> This member function has a <i>noexcept</i> specifier that matches the combined <i>noexcept</i> of the
-         * {@link IArray.swap swap} operations on the {@link container_ underlying container} and the comparison
-         * functions. </p>
-         *
-         * @param obj {@link PriorityQueue} container adaptor of the same type (i.e., instantiated with the same
-         *			  template parameters, <b>T</b>). Sizes may differ.
-         */
-        swap(obj: PriorityQueue<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> FIFO queue. </p>
-     *
-     * <p> {@link Queue}s are a type of container adaptor, specifically designed to operate in a FIFO context
-     * (first-in first-out), where elements are inserted into one end of the container and extracted from the other.
-     * </p>
-     *
-     * <p> {@link Queue}s are implemented as containers adaptors, which are classes that use an encapsulated object of
-     * a specific container class as its underlying container, providing a specific set of member functions to access
-     * its elements. Elements are pushed into the {@link IDeque.back back()} of the specific container and popped from
-     * its {@link IDeque.front front()}. </p>
-     *
-     * <p> {@link container_ The underlying container} may be one of the standard container class template or some
-     * other specifically designed container class. This underlying container shall support at least the following
-     * operations: </p>
-     *
-     * <ul>
-     *	<li> empty </li>
-     *	<li> size </li>
-     *	<li> front </li>
-     *	<li> back </li>
-     *	<li> push_back </li>
-     *	<li> pop_front </li>
-     * </ul>
-     *
-     * <p> The standard container classes {@link Deque} and {@link List} fulfill these requirements.
-     * By default, if no container class is specified for a particular {@link Queue} class instantiation, the standard
-     * container {@link List} is used. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * @param <T> Type of elements.
-     *
-     * @reference http://www.cplusplus.com/reference/queue/queue
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class Queue<T> {
-        /**
-         * The <i>underlying object</i> for implementing the <i>FIFO</i>
-         */
-        private container_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: Queue<T>);
-        /**
-         * <p> Return size. </p>
-         * <p> Returns the number of elements in the {@link Queue}. </p>
-         *
-         * <p> This member function effectively calls member {@link IDeque.size size()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return The number of elements in the {@link container_ underlying container}.
-         */
-        size(): number;
-        /**
-         * <p> Test whether container is empty. </p>
-         * <p> returns whether the {@link Queue} is empty: i.e. whether its <i>size</i> is zero. </p>
-         *
-         * <p> This member function efeectively calls member {@link IDeque.empty empty()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return <code>true</code> if the {@link container_ underlying container}'s size is 0,
-         *		   <code>false</code> otherwise. </p>
-         */
-        empty(): boolean;
-        /**
-         * <p> Access next element. </p>
-         * <p> Returns a value of the next element in the {@link Queue}. </p>
-         *
-         * <p> The next element is the "oldest" element in the {@link Queue} and the same element that is popped out
-         * from the queue when {@link pop Queue.pop()} is called. </p>
-         *
-         * <p> This member function effectively calls member {@link IDeque.front front()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return A value of the next element in the {@link Queue}.
-         */
-        front(): T;
-        /**
-         * <p> Access last element. </p>
-         *
-         * <p> Returns a vaue of the last element in the queue. This is the "newest" element in the queue (i.e. the
-         * last element pushed into the queue). </p>
-         *
-         * <p> This member function effectively calls the member function {@link IDeque.back back()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return A value of the last element in the {@link Queue}.
-         */
-        back(): T;
-        /**
-         * <p> Insert element. </p>
-         *
-         * <p> Inserts a new element at the end of the {@link Queue}, after its current last element.
-         * The content of this new element is initialized to <i>val</i>. </p>
-         *
-         * <p> This member function effectively calls the member function {@link IDeque.push_back push_back()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @param val Value to which the inserted element is initialized.
-         */
-        push(val: T): void;
-        /**
-         * <p> Remove next element. </p>
-         *
-         * <p> Removes the next element in the {@link Queue}, effectively reducing its size by one. </p>
-         *
-         * <p> The element removed is the "oldest" element in the {@link Queue} whose value can be retrieved by calling
-         * member {@link front Queue.front()} </p>.
-         *
-         * <p> This member function effectively calls the member function {@link IDeque.pop_front pop_front()} of the
-         * {@link container_ underlying container} object. </p>
-         */
-        pop(): void;
-        /**
-         * <p> Swap contents. </p>
-         *
-         * <p> Exchanges the contents of the container adaptor (<i>this</i>) by those of <i>obj</i>. </p>
-         *
-         * <p> This member function calls the non-member function {@link IContainer.swap swap} (unqualified) to swap
-         * the {@link container_ underlying containers}. </p>
-         *
-         * @param obj Another {@link Queue} container adaptor of the same type (i.e., instantiated with the same
-         *			  template parameter, <b>T</b>). Sizes may differ. </p>
-         */
-        swap(obj: Queue<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> LIFO stack. </p>
-     *
-     * <p> {@link Stack}s are a type of container adaptor, specifically designed to operate in a LIFO context
-     * (last-in first-out), where elements are inserted and extracted only from one end of the  </p>
-     *
-     * <p> {@link Stack}s are implemented as containers adaptors, which are classes that use an encapsulated object of
-     * a specific container class as its <i>underlying container</i>, providing a specific set of member functions to
-     * access its elements. Elements are pushed/popped from the {@link ILinearContainer.back back()} of the
-     * {@link ILinearContainer specific container}, which is known as the top of the {@link Stack}. </p>
-     *
-     * <p> {@link container_ The underlying container} may be any of the standard container class templates or some
-     * other specifically designed container class. The container shall support the following operations: </p>
-     *
-     * <ul>
-     *	<li> empty </li>
-     *	<li> size </li>
-     *	<li> front </li>
-     *	<li> back </li>
-     *	<li> push_back </li>
-     *	<li> pop_back </li>
-     * </ul>
-     *
-     * <p> The standard container classes {@link Vector}, {@link Deque} and {@link List} fulfill these requirements.
-     * By default, if no container class is specified for a particular {@link Stack} class instantiation, the standard
-     * container {@link List} is used. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
-     * </p>
-     *
-     * @param <T> Type of elements.
-     *
-     * @reference http://www.cplusplus.com/reference/stack/stack
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class Stack<T> {
-        /**
-         * The <i>underlying object</i> for implementing the <i>LIFO</i>
-         */
-        private container_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Copy Constructor.
-         */
-        constructor(stack: Stack<T>);
-        /**
-         * <p> Return size. </p>
-         *
-         * <p> Returns the number of elements in the {@link Stack}. </p>
-         *
-         * <p> This member function effectively calls member {@link ILinearContainer.size size()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return The number of elements in the {@link container_ underlying container}.
-         */
-        size(): number;
-        /**
-         * <p> Test whether container is empty. </p>
-         *
-         * <p> returns whether the {@link Stack} is empty: i.e. whether its <i>size</i> is zero. </p>
-         *
-         * <p> This member function effectively calls member {@link ILinearContainer.empty empty()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return <code>true</code> if the <i>underlying container</i>'s size is 0,
-         *		   <code>false</code> otherwise. </p>
-         */
-        empty(): boolean;
-        /**
-         * <p> Access next element. </p>
-         *
-         * <p> Returns a value of the top element in the {@link Stack} </p>.
-         *
-         * <p> Since {@link Stack}s are last-in first-out containers, the top element is the last element inserted into
-         * the {@link Stack}. </p>
-         *
-         * <p> This member function effectively calls member {@link ILinearContainer.back back()} of the
-         * {@link container_ underlying container} object. </p>
-         *
-         * @return A value of the top element in the {@link Stack}.
-         */
-        top(): T;
-        /**
-         * <p> Insert element. </p>
-         *
-         * <p> Inserts a new element at the top of the {@link Stack}, above its current top element. </p>
-         *
-         * <p> This member function effectively calls the member function
-         * {@link ILinearContainer.push_back push_back()} of the {@link container_ underlying container} object. </p>
-         *
-         * @param val Value to which the inserted element is initialized.
-         */
-        push(val: T): void;
-        /**
-         * <p> Remove top element. </p>
-         *
-         * <p> Removes the element on top of the {@link Stack}, effectively reducing its size by one. </p>
-         *
-         * <p> The element removed is the latest element inserted into the {@link Stack}, whose value can be retrieved
-         * by calling member {@link top Stack.top()} </p>.
-         *
-         * <p> This member function effectively calls the member function {@link ILinearContainer.pop_back pop_back()}
-         * of the {@link container_ underlying container} object. </p>
-         */
-        pop(): void;
-        /**
-         * <p> Swap contents. </p>
-         *
-         * <p> Exchanges the contents of the container adaptor (<i>this</i>) by those of <i>obj</i>. </p>
-         *
-         * <p> This member function calls the non-member function {@link IContainer.swap swap} (unqualified) to swap
-         * the {@link container_ underlying containers}. </p>
-         *
-         * @param obj Another {@link Stack} container adaptor of the same type (i.e., instantiated with the same
-         *			  template parameter, <b>T</b>). Sizes may differ. </p>
-         */
-        swap(obj: Stack<T>): void;
-    }
-}
 declare namespace std.base {
     /**
      * <p> An abstract error instance. </p>
@@ -7992,1686 +2930,6 @@ declare namespace std.base {
         to_bool(): boolean;
     }
 }
-declare namespace std {
-    /**
-     * <p> System error exception. </p>
-     *
-     * <p> This class defines the type of objects thrown as exceptions to report conditions originating during
-     * runtime from the operating system or other low-level application program interfaces which have an
-     * associated {@link ErrorCode}. </p>
-     *
-     * <p> The class inherits from {@link RuntimeError}, to which it adds an {@link ErrorCode} as
-     * member code (and defines a specialized what member). </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/system_error/system_error
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class SystemError extends RuntimeError {
-        /**
-         * @hidden
-         */
-        protected code_: ErrorCode;
-        /**
-         * Construct from an error code.
-         *
-         * @param code An {@link ErrorCode} object.
-         */
-        constructor(code: ErrorCode);
-        /**
-         * Construct from an error code and message.
-         *
-         * @param code An {@link ErrorCode} object.
-         * @param message A message incorporated in the string returned by member {@link what what()}.
-         */
-        constructor(code: ErrorCode, message: string);
-        /**
-         * Construct from a numeric value and error category.
-         *
-         * @param val A numerical value identifying an error code.
-         * @param category A reference to an {@link ErrorCode} object.
-         */
-        constructor(val: number, category: ErrorCategory);
-        /**
-         * Construct from a numeric value, error category and message.
-         *
-         * @param val A numerical value identifying an error code.
-         * @param category A reference to an {@link ErrorCode} object.
-         * @param message A message incorporated in the string returned by member {@link what what()}.
-         */
-        constructor(val: number, category: ErrorCategory, message: string);
-        /**
-         * <p> Get error code. </p>
-         *
-         * <p> Returns the {@link ErrorCode} object associated with the exception. </p>
-         *
-         * <p> This value is either the {@link ErrorCode} passed to the construction or its equivalent
-         * (if constructed with a value and a {@link category}. </p>
-         *
-         * @return The {@link ErrorCode} associated with the object.
-         */
-        code(): ErrorCode;
-    }
-}
-declare namespace std {
-    /**
-     * <p> Error category. </p>
-     *
-     * <p> This type serves as a base class for specific category types. </p>
-     *
-     * <p> Category types are used to identify the source of an error. They also define the relation between
-     * {@link ErrorCode} and {@link ErrorCondition}objects of its category, as well as the message set for {@link ErrorCode}
-     * objects.
-     *
-     * <p> Objects of these types have no distinct values and are not-copyable and not-assignable, and thus can only be
-     * passed by reference. As such, only one object of each of these types shall exist, each uniquely identifying its own
-     * category: all error codes and conditions of a same category shall return a reference to same object. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/system_error/error_category
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    abstract class ErrorCategory {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * <p> Return category name. </p>
-         *
-         * <p> In derived classes, the function returns a string naming the category. </p>
-         *
-         * <p> In {@link ErrorCategory}, it is a pure virtual member function. </p>
-         *
-         * <ul>
-         *	<li> In the {@link GenericCategory} object, it returns <i>"generic"</i>. </li>
-         *	<li> In the {@link SystemCategory} object, it returns <i>"system"</i>. </li>
-         *	<li> In the {@link IOStreamCategory} object, it returns <i>"iostream"</i>. </li>
-         * </ul>
-         *
-         * @return The category name.
-         */
-        abstract name(): string;
-        /**
-         * <p> Error message. </p>
-         *
-         * <p> In derived classes, the function returns a string object with a message describing the error condition
-         * denoted by <i>val</i>. </p>
-         *
-         * <p> In {@link ErrorCategory}, it is a pure virtual member function. </p>
-         *
-         * <p> This function is called both by {@link ErrorCode.message ErrorCode.message()} and
-         * {@link ErrorCondition.message ErrorCondition.message()} to obtain the corresponding message in the
-         * {@link category}. Therefore, numerical values used by custom <i>error codes</i> and
-         * {@link ErrorCondition error conditions} should only match for a category if they describe the same error. </p>
-         *
-         * @param val A numerical value identifying an error condition.
-         *			  If the {@link ErrorCategory} object is the {@link GenericCategory}, this argument is equivalent to an
-         *			  {@link errno} value.
-         *
-         * @return A string object with the message.
-         */
-        abstract message(val: number): string;
-        /**
-         * <p> Default error condition. </p>
-         *
-         * <p> Returns the default {@link ErrorCondition}object of this category that is associated with the
-         * {@link ErrorCode} identified by a value of <i>val</i>. </p>
-         *
-         * <p> Its definition in the base class {@link ErrorCategory} returns the same as constructing an
-         * {@link ErrorCondition} object with:
-         *
-         * <p> <code>new ErrorCondition(val, *this);</code> </p>
-         *
-         * <p> As a virtual member function, this behavior can be overriden in derived classes. </p>
-         *
-         * <p> This function is called by the default definition of member {@link equivalent equivalent()}, which is used to
-         * compare {@link ErrorCondition error conditions} with error codes. </p>
-         *
-         * @param val A numerical value identifying an error condition.
-         *
-         * @return The default {@link ErrorCondition}object associated with condition value <i>val</i> for this category.
-         */
-        default_error_condition(val: number): ErrorCondition;
-        /**
-         * <p> Check error code equivalence. </p>
-         *
-         * <p> Checks whether, for the category, an {@link ErrorCode error code} is equivalent to an
-         * {@link ErrorCondition error condition. </p>
-         *
-         * <p> This function is called by the overloads of comparison operators when an {@link ErrorCondition} object is
-         * compared to an {@link ErrorCode} object to check for equality or inequality. If either one of those objects'
-         * {@link ErrorCategory categories} considers the other equivalent using this function, they are considered
-         * equivalent by the operator. </p>
-         *
-         * <p> As a virtual member function, this behavior can be overridden in derived classes to define a different
-         * correspondence mechanism for each {@link ErrorCategory} type. </p>
-         *
-         * @param val_code A numerical value identifying an error code.
-         * @param cond An object of an {@link ErrorCondition} type.
-         *
-         * @return <code>true</code> if the arguments are considered equivalent. <code>false</code> otherwise.
-         */
-        equivalent(val_code: number, cond: ErrorCondition): boolean;
-        /**
-         * <p> Check error code equivalence. </p>
-         *
-         * <p> Checks whether, for the category, an {@link ErrorCode error code} is equivalent to an
-         * {@link ErrorCondition error condition. </p>
-         *
-         * <p> This function is called by the overloads of comparison operators when an {@link ErrorCondition} object is
-         * compared to an {@link ErrorCode} object to check for equality or inequality. If either one of those objects'
-         * {@link ErrorCategory categories} considers the other equivalent using this function, they are considered
-         * equivalent by the operator. </p>
-         *
-         * <p> As a virtual member function, this behavior can be overridden in derived classes to define a different
-         * correspondence mechanism for each {@link ErrorCategory} type. </p>
-         *
-         * @param code An object of an {@link ErrorCode} type.
-         * @param val_cond A numerical value identifying an error code.
-         *
-         * @return <code>true</code> if the arguments are considered equivalent. <code>false</code> otherwise.
-         */
-        equivalent(code: ErrorCode, val_cond: number): boolean;
-    }
-}
-declare namespace std {
-    /**
-     * <p> Error condition. </p>
-     *
-     * <p> Objects of this type hold a condition {@link value} associated with a {@link category}. </p>
-     *
-     * <p> Objects of this type describe errors in a generic way so that they may be portable across different
-     * systems. This is in contrast with {@link ErrorCode} objects, that may contain system-specific
-     * information. </p>
-     *
-     * <p> Because {@link ErrorCondition}objects can be compared with error_code objects directly by using
-     * <code>relational operators</code>, {@link ErrorCondition}objects are generally used to check whether
-     * a particular {@link ErrorCode} obtained from the system matches a specific error condition no matter
-     * the system. </p>
-     *
-     * <p> The {@link ErrorCategory categories} associated with the {@link ErrorCondition} and the
-     * {@link ErrorCode} define the equivalences between them. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/system_error/error_condition
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class ErrorCondition extends base.ErrorInstance {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from a numeric value and error category.
-         *
-         * @param val A numerical value identifying an error condition.
-         * @param category A reference to an {@link ErrorCategory} object.
-         */
-        constructor(val: number, category: ErrorCategory);
-    }
-}
-declare namespace std {
-    /**
-     * <p> Error code. </p>
-     *
-     * <p> Objects of this type hold an error code {@link value} associated with a {@link category}. </p>
-     *
-     * <p> The operating system and other low-level applications and libraries generate numerical error codes to
-     * represent possible results. These numerical values may carry essential information for a specific platform,
-     * but be non-portable from one platform to another. </p>
-     *
-     * <p> Objects of this class associate such numerical codes to {@link ErrorCategory error categories}, so that they
-     * can be interpreted when needed as more abstract (and portable) {@link ErrorCondition error conditions}. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
-     *
-     * @reference http://www.cplusplus.com/reference/system_error/error_code
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class ErrorCode extends base.ErrorInstance {
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from a numeric value and error category.
-         *
-         * @param val A numerical value identifying an error code.
-         * @param category A reference to an {@link ErrorCategory} object.
-         */
-        constructor(val: number, category: ErrorCategory);
-    }
-}
-declare namespace std.TreeMap {
-    type iterator<Key, T> = std.MapIterator<Key, T>;
-    type reverse_iterator<Key, T> = std.MapReverseIterator<Key, T>;
-}
-declare namespace std {
-    /**
-     * <p> Tree-structured map, <code>std::map</code> of STL. </p>
-     *
-     * <p> {@link TreeMap TreeMaps} are associative containers that store elements formed by a combination of a
-     * <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), following order. </p>
-     *
-     * <p> In a {@link TreeMap}, the <i>key values</i> are generally used to sort and uniquely identify the elements,
-     * while the <i>mapped values</i> store the content associated to this key. The types of <i>key</i> and
-     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a {@link Pair}
-     * type combining both: </p>
-     *
-     * <p> <code>typedef Pair<Key, T> value_type;</code> </p>
-     *
-     * <p> Internally, the elements in a {@link TreeMap} are always sorted by its <i>key</i> following a
-     * <i>strict weak ordering</i> criterion indicated by its internal comparison method {@link less}.
-     *
-     * <p> {@link TreeMap} containers are generally slower than {@link HashMap HashMap} containers to access individual
-     * elements by their <i>key</i>, but they allow the direct iteration on subsets based on their order. </p>
-     *
-     * <p> {@link TreeMap}s are typically implemented as binary search trees. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a></p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		 position in the container. </dd>
-     *
-     *	<dt> Ordered </dt>
-     *	<dd> The elements in the container follow a strict order at all times. All inserted elements are
-     *		 given a position in this order. </dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
-     *
-     *	<dt> Unique keys </dt>
-     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
-     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
-     *
-     * @reference http://www.cplusplus.com/reference/map/map
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class TreeMap<Key, T> extends base.UniqueMap<Key, T> implements base.ITreeMap<Key, T> {
-        /**
-         * @hidden
-         */
-        private tree_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from compare.
-         *
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(compare: (x: Key, y: Key) => boolean);
-        /**
-         * Contruct from elements.
-         *
-         * @param array Elements to be contained.
-         */
-        constructor(array: Array<Pair<Key, T>>);
-        /**
-         * Contruct from elements.
-         *
-         * @param array Elements to be contained.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(array: Array<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * Contruct from tuples.
-         *
-         * @param array Tuples to be contained.
-         */
-        constructor(array: Array<[Key, T]>);
-        /**
-         * Contruct from tuples.
-         *
-         * @param array Tuples to be contained.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(array: Array<[Key, T]>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * Copy Constructor.
-         *
-         * @param container Another map to copy.
-         */
-        constructor(container: TreeMap<Key, T>);
-        /**
-         * Copy Constructor.
-         *
-         * @param container Another map to copy.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(container: TreeMap<Key, T>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * Range Constructor.
-         *
-         * @param begin nput interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
-        /**
-         * Range Constructor.
-         *
-         * @param begin nput interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        key_comp(): (x: Key, y: Key) => boolean;
-        /**
-         * @inheritdoc
-         */
-        value_comp(): (x: Pair<Key, T>, y: Pair<Key, T>) => boolean;
-        /**
-         * @inheritdoc
-         */
-        lower_bound(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        upper_bound(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        equal_range(key: Key): Pair<MapIterator<Key, T>, MapIterator<Key, T>>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_pair(pair: Pair<Key, T>): any;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link TreeMap map} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link TreeMap map container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link TreeMap container}.
-         */
-        swap(obj: TreeMap<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<Pair<Key, T>>): void;
-    }
-}
-declare namespace std.TreeMultiMap {
-    type iterator<Key, T> = std.MapIterator<Key, T>;
-    type reverse_iterator<Key, T> = std.MapReverseIterator<Key, T>;
-}
-declare namespace std {
-    /**
-     * <p> Tree-structured multiple-key map. </p>
-     *
-     * <p> {@link TreeMultiMap TreeMultiMaps} are associative containers that store elements formed by a combination of
-     * a <i>key value</i> and a <i>mapped value</i>, following a specific order, and where multiple elements can
-     * have equivalent keys. </p>
-     *
-     * <p> In a {@link TreeMultiMap}, the <i>key values</i> are generally used to sort and uniquely identify
-     * the elements, while the <i>mapped values</i> store the content associated to this <i>key</i>. The types of
-     * <i>key</i> and <i>mapped value</i> may differ, and are grouped together in member type
-     * <code>value_type</code>, which is a {@link Pair} type combining both: </p>
-     *
-     * <p> <code>typedef Pair<const Key, T> value_type;</code> </p>
-     *
-     * <p> Internally, the elements in a {@link TreeMultiMap}are always sorted by its key following a
-     * strict weak ordering criterion indicated by its internal comparison method (of {@link less}). </p>
-     *
-     * <p> {@link TreeMultiMap}containers are generally slower than {@link HashMap} containers
-     * to access individual elements by their <i>key</i>, but they allow the direct iteration on subsets based
-     * on their order. </p>
-     *
-     * <p> {@link TreeMultiMap TreeMultiMaps} are typically implemented as binary search trees. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank"> <
-     * img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a></p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Ordered </dt>
-     *	<dd>
-     *		The elements in the container follow a strict order at all times. All inserted elements are
-     *		given a position in this order.
-     *	</dd>
-     *
-     *	<dt> Map </dt>
-     *	<dd>
-     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
-     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
-     *	</dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
-     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
-     *
-     * @reference http://www.cplusplus.com/reference/map/multimap
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class TreeMultiMap<Key, T> extends base.MultiMap<Key, T> implements base.ITreeMap<Key, T> {
-        /**
-         * @hidden
-         */
-        private tree_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from compare.
-         *
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(compare: (x: Key, y: Key) => boolean);
-        /**
-         * Contruct from elements.
-         *
-         * @param array Elements to be contained.
-         */
-        constructor(array: Array<Pair<Key, T>>);
-        /**
-         * Contruct from elements.
-         *
-         * @param array Elements to be contained.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(array: Array<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * Contruct from tuples.
-         *
-         * @param array Tuples to be contained.
-         */
-        constructor(array: Array<[Key, T]>);
-        /**
-         * Contruct from tuples.
-         *
-         * @param array Tuples to be contained.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(array: Array<[Key, T]>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * Copy Constructor.
-         *
-         * @param container Another map to copy.
-         */
-        constructor(container: TreeMultiMap<Key, T>);
-        /**
-         * Copy Constructor.
-         *
-         * @param container Another map to copy.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(container: TreeMultiMap<Key, T>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * Range Constructor.
-         *
-         * @param begin nput interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
-        /**
-         * Range Constructor.
-         *
-         * @param begin nput interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        count(key: Key): number;
-        /**
-         * @inheritdoc
-         */
-        key_comp(): (x: Key, y: Key) => boolean;
-        /**
-         * @inheritdoc
-         */
-        value_comp(): (x: Pair<Key, T>, y: Pair<Key, T>) => boolean;
-        /**
-         * @inheritdoc
-         */
-        lower_bound(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        upper_bound(key: Key): MapIterator<Key, T>;
-        /**
-         * @inheritdoc
-         */
-        equal_range(key: Key): Pair<MapIterator<Key, T>, MapIterator<Key, T>>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_pair(pair: Pair<Key, T>): any;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link TreeMapMulti map} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link TreeMapMulti map container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link TreeMapMulti container}.
-         */
-        swap(obj: TreeMultiMap<Key, T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<Pair<Key, T>>): void;
-    }
-}
-declare namespace std.TreeMultiSet {
-    type iterator<T> = std.SetIterator<T>;
-    type reverse_iterator<T> = std.SetReverseIterator<T>;
-}
-declare namespace std {
-    /**
-     * <p> Tree-structured multiple-key set. </p>
-     *
-     * <p> {@link TreeMultiSet TreeMultiSets} are containers that store elements following a specific order, and
-     * where multiple elements can have equivalent values. </p>
-     *
-     * <p> In a {@link TreeMultiSet}, the value of an element also identifies it (the value is itself
-     * the <i>key</i>, of type <i>T</i>). The value of the elements in a {@link TreeMultiSet} cannot
-     * be modified once in the container (the elements are always const), but they can be inserted or removed
-     * from the  </p>
-     *
-     * <p> Internally, the elements in a {@link TreeMultiSet TreeMultiSets} are always sorted following a strict
-     * weak ordering criterion indicated by its internal comparison method (of {@link IComparable.less less}). </p>
-     *
-     * <p> {@link TreeMultiSet} containers are generally slower than {@link HashMultiSet} containers
-     * to access individual elements by their <i>key</i>, but they allow the direct iteration on subsets based on
-     * their order. </p>
-     *
-     * <p> {@link TreeMultiSet TreeMultiSets} are typically implemented as binary search trees. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /> </a></p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Ordered </dt>
-     *	<dd>
-     *		The elements in the container follow a strict order at all times. All inserted elements are
-     *		given a position in this order.
-     *	</dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     *
-     *	<dt> Multiple equivalent keys </dt>
-     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements. Each element in a {@link TreeMultiSet} container is also identified
-     *			  by this value (each value is itself also the element's <i>key</i>).
-     *
-     * @reference http://www.cplusplus.com/reference/set/multiset
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class TreeMultiSet<T> extends base.MultiSet<T> implements base.ITreeSet<T> {
-        /**
-         * @hidden
-         */
-        private tree_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from compare.
-         *
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(compare: (x: T, y: T) => boolean);
-        /**
-         * Contruct from elements.
-         *
-         * @param array Elements to be contained.
-         */
-        constructor(array: Array<T>);
-        /**
-         * Contruct from elements with compare.
-         *
-         * @param array Elements to be contained.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(array: Array<T>, compare: (x: T, y: T) => boolean);
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: TreeMultiSet<T>);
-        /**
-         * Copy Constructor with compare.
-         *
-         * @param container A container to be copied.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(container: TreeMultiSet<T>, compare: (x: T, y: T) => boolean);
-        /**
-         * Range Constructor.
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * Construct from range and compare.
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>, compare: (x: T, y: T) => boolean);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        count(val: T): number;
-        /**
-         * @inheritdoc
-         */
-        key_comp(): (x: T, y: T) => boolean;
-        /**
-         * @inheritdoc
-         */
-        value_comp(): (x: T, y: T) => boolean;
-        /**
-         * @inheritdoc
-         */
-        lower_bound(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        upper_bound(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        equal_range(val: T): Pair<SetIterator<T>, SetIterator<T>>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_val(val: T): any;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link TreeMultiSet set} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link TreeMultiSet set container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link TreeMultiSet container}.
-         */
-        swap(obj: TreeMultiSet<T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std.TreeSet {
-    type iterator<T> = std.SetIterator<T>;
-    type reverse_iterator<T> = std.SetReverseIterator<T>;
-}
-declare namespace std {
-    /**
-     * <p> Tree-structured set, <code>std::set</code> of STL. </p>
-     *
-     * <p> {@link TreeSet}s are containers that store unique elements following a specific order. </p>
-     *
-     * <p> In a {@link TreeSet}, the value of an element also identifies it (the value is itself the
-     * <i>key</i>, of type <i>T</i>), and each value must be unique. The value of the elements in a
-     * {@link TreeSet} cannot be modified once in the container (the elements are always const), but they
-     * can be inserted or removed from the  </p>
-     *
-     * <p> Internally, the elements in a {@link TreeSet} are always sorted following a specific strict weak
-     * ordering criterion indicated by its internal comparison method (of {@link less}). </p>
-     *
-     * <p> {@link TreeSet} containers are generally slower than {@link HashSet} containers to access
-     * individual elements by their <i>key</i>, but they allow the direct iteration on subsets based on their
-     * order. </p>
-     *
-     * <p> {@link TreeSet}s are typically implemented as binary search trees. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /> </a></p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Associative </dt>
-     *	<dd>
-     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
-     *		position in the container.
-     *	</dd>
-     *
-     *	<dt> Ordered </dt>
-     *	<dd>
-     *		The elements in the container follow a strict order at all times. All inserted elements are
-     *		given a position in this order.
-     *	</dd>
-     *
-     *	<dt> Set </dt>
-     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
-     *
-     *	<dt> Unique keys </dt>
-     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *			  Each element in an {@link TreeSet} is also uniquely identified by this value.
-     *
-     * @reference http://www.cplusplus.com/reference/set/set
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class TreeSet<T> extends base.UniqueSet<T> implements base.ITreeSet<T> {
-        /**
-         * @hidden
-         */
-        private tree_;
-        /**
-         * Default Constructor.
-         */
-        constructor();
-        /**
-         * Construct from compare.
-         *
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(compare: (x: T, y: T) => boolean);
-        /**
-         * Contruct from elements.
-         *
-         * @param array Elements to be contained.
-         */
-        constructor(array: Array<T>);
-        /**
-         * Contruct from elements with compare.
-         *
-         * @param array Elements to be contained.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(array: Array<T>, compare: (x: T, y: T) => boolean);
-        /**
-         * Copy Constructor.
-         */
-        constructor(container: TreeMultiSet<T>);
-        /**
-         * Copy Constructor with compare.
-         *
-         * @param container A container to be copied.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(container: TreeMultiSet<T>, compare: (x: T, y: T) => boolean);
-        /**
-         * Range Constructor.
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * Construct from range and compare.
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         * @param compare A binary predicate determines order of elements.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>, compare: (x: T, y: T) => boolean);
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        find(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        key_comp(): (x: T, y: T) => boolean;
-        /**
-         * @inheritdoc
-         */
-        value_comp(): (x: T, y: T) => boolean;
-        /**
-         * @inheritdoc
-         */
-        lower_bound(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        upper_bound(val: T): SetIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        equal_range(val: T): Pair<SetIterator<T>, SetIterator<T>>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_val(val: T): any;
-        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * @inheritdoc
-         */
-        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link TreeSet set} of the same type. Sizes abd container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were
-         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
-         * iterators, references and pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link TreeSet set container} of the same type of elements as this (i.e.,
-         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
-         *			  with that of this {@link TreeSet container}.
-         */
-        swap(obj: TreeSet<T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> Running on Node. </p>
-     *
-     * <p> Test whether the JavaScript is running on Node. </p>
-     *
-     * @references http://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser
-     */
-    function is_node(): boolean;
-    /**
-     * <p> Pair of values. </p>
-     *
-     * <p> This class couples together a pair of values, which may be of different types (<i>T1</i> and
-     * <i>T2</i>). The individual values can be accessed through its public members {@link first} and
-     * {@link second}. </p>
-     *
-     * @param <T1> Type of member {@link first}.
-     * @param <T2> Type of member {@link second}.
-     *
-     * @reference http://www.cplusplus.com/reference/utility/pair
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class Pair<T1, T2> {
-        /**
-         * <p> A first value in the Pair. </p>
-         */
-        first: T1;
-        /**
-         * <p> A second value in the Pair. </p>
-         */
-        second: T2;
-        /**
-         * <p> Construct from pair values. </p>
-         *
-         * @param first The first value of the Pair
-         * @param second The second value of the Pair
-         */
-        constructor(first: T1, second: T2);
-        /**
-         * <p> Whether a Pair is equal with the Pair. <p>
-         * <p> Compare each first and second value of two Pair(s) and returns whether they are equal or not. </p>
-         *
-         * <p> If stored key and value in a Pair are not number or string but an object like a class or struct,
-         * the comparison will be executed by a member method (SomeObject)::equal_to(). If the object does not have
-         * the member method equal_to(), only address of pointer will be compared. </p>
-         *
-         * @param obj A Map to compare
-         * @return Indicates whether equal or not.
-         */
-        equal_to<U1 extends T1, U2 extends T2>(pair: Pair<U1, U2>): boolean;
-        less<U1 extends T1, U2 extends T2>(pair: Pair<U1, U2>): boolean;
-    }
-    /**
-     * <p> Construct {@link Pair} object. </p>
-     *
-     * <p> Constructs a {@link Pair} object with its {@link Pair.first first} element set to <i>x</i> and its
-     * {@link Pair.second second} element set to <i>y</i>. </p>
-     *
-     * <p> The template types can be implicitly deduced from the arguments passed to {@link make_pair}. </p>
-     *
-     * <p> {@link Pair} objects can be constructed from other {@link Pair} objects containing different types, if the
-     * respective types are implicitly convertible. </p>
-     *
-     * @param x Value for member {@link Pair.first first}.
-     * @param y Value for member {@link Pair.second second}.
-     *
-     * @return A {@link Pair} object whose elements {@link Pair.first first} and {@link Pair.second second} are set to
-     *		   <i>x</i> and <i>y</i> respectivelly.
-     */
-    function make_pair<T1, T2>(x: T1, y: T2): Pair<T1, T2>;
-}
-declare namespace std.Vector {
-    type iterator<T> = std.VectorIterator<T>;
-    type reverse_iterator<T> = std.VectorReverseIterator<T>;
-}
-declare namespace std {
-    /**
-     * <p> Vector, the dynamic array. </p>
-     *
-     * <p> {@link Vector}s are sequence containers representing arrays that can change in size. </p>
-     *
-     * <p> Just like arrays, {@link Vector}s use contiguous storage locations for their elements, which means that
-     * their elements can also be accessed using offsets on regular pointers to its elements, and just as efficiently
-     * as in arrays. But unlike arrays, their size can change dynamically, with their storage being handled
-     * automatically by the  </p>
-     *
-     * <p> Internally, {@link Vector}s use a dynamically allocated array to store their elements. This array may need
-     * to be reallocated in order to grow in size when new elements are inserted, which implies allocating a new
-     * array and moving all elements to it. This is a relatively expensive task in terms of processing time, and
-     * thus, {@link Vector}s do not reallocate each time an element is added to the  </p>
-     *
-     * <p> Instead, {@link Vector} containers may allocate some extra storage to accommodate for possible growth, and
-     * thus the container may have an actual {@link capacity} greater than the storage strictly needed to contain its
-     * elements (i.e., its {@link size}). Libraries can implement different strategies for growth to balance between
-     * memory usage and reallocations, but in any case, reallocations should only happen at logarithmically growing
-     * intervals of {@link size} so that the insertion of individual elements at the end of the {@link Vector} can be
-     * provided with amortized constant time complexity (see {@link push_back push_back()}). </p>
-     *
-     * <p> Therefore, compared to arrays, {@link Vector}s consume more memory in exchange for the ability to manage
-     * storage and grow dynamically in an efficient way. </p>
-     *
-     * <p> Compared to the other dynamic sequence containers ({@link Deque}s, {@link List}s), {@link Vector Vectors}
-     * are very efficient accessing its elements (just like arrays) and relatively efficient adding or removing
-     * elements from its end. For operations that involve inserting or removing elements at positions other than the
-     * end, they perform worse than the others, and have less consistent iterators and references than {@link List}s.
-     * </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
-     * </a> </p>
-     *
-     * <h3> Container properties </h3>
-     * <dl>
-     *	<dt> Sequence </dt>
-     *	<dd>
-     *		Elements in sequence containers are ordered in a strict linear sequence. Individual elements are
-     *		accessed by their position in this sequence.
-     *	</dd>
-     *
-     *	<dt> Dynamic array </dt>
-     *	<dd>
-     *		Allows direct access to any element in the sequence, even through pointer arithmetics, and provides
-     *		relatively fast addition/removal of elements at the end of the sequence.
-     *	</dd>
-     * </dl>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @reference http://www.cplusplus.com/reference/vector/vector
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class Vector<T> extends Array<T> implements base.IContainer<T>, base.IArrayContainer<T> {
-        /**
-         * <p> Default Constructor. </p>
-         *
-         * <p> Constructs an empty container, with no elements. </p>
-         */
-        constructor();
-        /**
-         * @inheritdoc
-         */
-        constructor(array: Array<T>);
-        /**
-         * <p> Initializer list Constructor. </p>
-         *
-         * <p> Constructs a container with a copy of each of the elements in <i>array</i>, in the same order. </p>
-         *
-         * @param array An array containing elements to be copied and contained.
-         */
-        constructor(n: number);
-        /**
-         * <p> Fill Constructor. </p>
-         *
-         * <p> Constructs a container with <i>n</i> elements. Each element is a copy of <i>val</i> (if provided). </p>
-         *
-         * @param n Initial container size (i.e., the number of elements in the container at construction).
-         * @param val Value to fill the container with. Each of the <i>n</i> elements in the container is
-         *			  initialized to a copy of this value.
-         */
-        constructor(n: number, val: T);
-        /**
-         * <p> Copy Constructor. </p>
-         *
-         * <p> Constructs a container with a copy of each of the elements in <i>container</i>, in the same order. </p>
-         *
-         * @param container Another container object of the same type (with the same class template
-         *					arguments <i>T</i>), whose contents are either copied or acquired.
-         */
-        constructor(container: Vector<T>);
-        /**
-         * <p> Range Constructor. </p>
-         *
-         * <p> Constructs a container with as many elements as the range (<i>begin</i>, <i>end<i>), with each
-         * element emplace-constructed from its corresponding element in that range, in the same order. </p>
-         *
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         */
-        constructor(begin: Iterator<T>, end: Iterator<T>);
-        /**
-         * @inheritdoc
-         */
-        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
-        /**
-         * @inheritdoc
-         */
-        assign(n: number, val: T): void;
-        /**
-         * @inheritdoc
-         */
-        reserve(size: number): void;
-        /**
-         * @inheritdoc
-         */
-        clear(): void;
-        /**
-         * @inheritdoc
-         */
-        begin(): VectorIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        end(): VectorIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rbegin(): VectorReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        rend(): VectorReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        size(): number;
-        /**
-         * @inheritdoc
-         */
-        capacity(): number;
-        /**
-         * @inheritdoc
-         */
-        empty(): boolean;
-        /**
-         * @inheritdoc
-         */
-        at(index: number): T;
-        /**
-         * @inheritdoc
-         */
-        set(index: number, val: T): T;
-        /**
-         * @inheritdoc
-         */
-        front(): T;
-        /**
-         * @inheritdoc
-         */
-        back(): T;
-        /**
-         * @inheritdoc
-         */
-        push_back(val: T): void;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> The {@link Vector} is extended by inserting new element before the element at the specified
-         * <i>position</i>, effectively increasing the container size by one. </p>
-         *
-         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
-         * {@link size} surpasses the current {@link capacity}. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting element in
-         * positions other than the {@link end end()} causes the container to relocate all the elements that were
-         * after <i>position</i> to its new position. This is generally an inefficient operation compared to the one
-         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
-         *
-         * @param position Position in the {@link Vector} where the new element is inserted.
-         *				   {@link iterator} is a member type, defined as a
-         *				   {@link VectorIterator random access iterator} type that points to elements.
-         * @param val Value to be copied to the inserted element.
-         *
-         * @return An iterator that points to the newly inserted element.
-         */
-        insert(position: VectorIterator<T>, val: T): VectorIterator<T>;
-        /**
-         * <p> Insert elements by repeated filling. </p>
-         *
-         * <p> The {@link Vector} is extended by inserting new elements before the element at the specified
-         * <i>position</i>, effectively increasing the container size by the number of elements inserted. </p>
-         *
-         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
-         * {@link size} surpasses the current {@link capacity}. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
-         * positions other than the {@link end end()} causes the container to relocate all the elements that were
-         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
-         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
-         *
-         * @param position Position in the {@link Vector} where the new elements are inserted.
-         *				   {@link iterator} is a member type, defined as a
-         *				   {@link VectorIterator random access iterator} type that points to elements.
-         * @param n Number of elements to insert. Each element is initialized to a copy of <i>val</i>.
-         * @param val Value to be copied (or moved) to the inserted elements.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert(position: VectorIterator<T>, n: number, val: T): VectorIterator<T>;
-        /**
-         * <p> Insert elements by range iterators. </p>
-         *
-         * <p> The {@link Vector} is extended by inserting new elements before the element at the specified
-         * <i>position</i>, effectively increasing the container size by the number of elements inserted by range
-         * iterators. </p>
-         *
-         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
-         * {@link size} surpasses the current {@link capacity}. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
-         * positions other than the {@link end end()} causes the container to relocate all the elements that were
-         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
-         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
-         *
-         * @param position Position in the {@link Vector} where the new elements are inserted.
-         *				   {@link iterator} is a member type, defined as a
-         *				   {@link VectorIterator random access iterator} type that points to elements.
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(position: VectorIterator<T>, begin: InputIterator, end: InputIterator): VectorIterator<T>;
-        /**
-         * <p> Insert an element. </p>
-         *
-         * <p> The {@link Vector} is extended by inserting new element before the element at the specified
-         * <i>position</i>, effectively increasing the container size by one. </p>
-         *
-         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
-         * {@link size} surpasses the current {@link capacity}. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting element in
-         * positions other than the {@link end end()} causes the container to relocate all the elements that were
-         * after <i>position</i> to its new position. This is generally an inefficient operation compared to the one
-         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
-         *
-         * @param position Position in the {@link Vector} where the new element is inserted.
-         *				   {@link iterator} is a member type, defined as a
-         *				   {@link VectorIterator random access iterator} type that points to elements.
-         * @param val Value to be copied to the inserted element.
-         *
-         * @return An iterator that points to the newly inserted element.
-         */
-        insert(position: VectorReverseIterator<T>, val: T): VectorReverseIterator<T>;
-        /**
-         * <p> Insert elements by repeated filling. </p>
-         *
-         * <p> The {@link Vector} is extended by inserting new elements before the element at the specified
-         * <i>position</i>, effectively increasing the container size by the number of elements inserted. </p>
-         *
-         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
-         * {@link size} surpasses the current {@link capacity}. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
-         * positions other than the {@link end end()} causes the container to relocate all the elements that were
-         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
-         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
-         *
-         * @param position Position in the {@link Vector} where the new elements are inserted.
-         *				   {@link iterator} is a member type, defined as a
-         *				   {@link VectorIterator random access iterator} type that points to elements.
-         * @param n Number of elements to insert. Each element is initialized to a copy of <i>val</i>.
-         * @param val Value to be copied (or moved) to the inserted elements.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert(position: VectorReverseIterator<T>, n: number, val: T): VectorReverseIterator<T>;
-        /**
-         * <p> Insert elements by range iterators. </p>
-         *
-         * <p> The {@link Vector} is extended by inserting new elements before the element at the specified
-         * <i>position</i>, effectively increasing the container size by the number of elements inserted by range
-         * iterators. </p>
-         *
-         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
-         * {@link size} surpasses the current {@link capacity}. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
-         * positions other than the {@link end end()} causes the container to relocate all the elements that were
-         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
-         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
-         *
-         * @param position Position in the {@link Vector} where the new elements are inserted.
-         *				   {@link iterator} is a member type, defined as a
-         *				   {@link VectorIterator random access iterator} type that points to elements.
-         * @param begin Input interator of the initial position in a sequence.
-         * @param end Input interator of the final position in a sequence.
-         *
-         * @return An iterator that points to the first of the newly inserted elements.
-         */
-        insert<U extends T, InputIterator extends Iterator<U>>(position: VectorReverseIterator<T>, begin: InputIterator, end: InputIterator): VectorReverseIterator<T>;
-        /**
-         * @hidden
-         */
-        private insert_by_val(position, val);
-        /**
-         * @hidden
-         */
-        protected _Insert_by_repeating_val(position: VectorIterator<T>, n: number, val: T): VectorIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Insert_by_range<InputIterator extends Iterator<T>>(position: VectorIterator<T>, first: InputIterator, last: InputIterator): VectorIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        pop_back(): void;
-        /**
-         * <p> Erase element. </p>
-         *
-         * <p> Removes from the {@link Vector} either a single element; <i>position</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of element removed. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing an element in
-         * position other than the {@link end end()} causes the container to relocate all the elements after the
-         * segment erased to their new positions. This is generally an inefficient operation compared to the one
-         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
-         *
-         * @param position Iterator pointing to a single element to be removed from the {@link Vector}.
-         *
-         * @return An iterator pointing to the new location of the element that followed the last element erased by
-         *		   the function call. This is the {@link end end()} if the operation erased the last element in the
-         *		   sequence.
-         */
-        erase(position: VectorIterator<T>): VectorIterator<T>;
-        /**
-         * <p> Erase element. </p>
-         *
-         * <p> Removes from the <ode>Vector</code> either a single element; <i>position</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of elements removed. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing elements in
-         * position other than the {@link end end()} causes the container to relocate all the elements after the
-         * segment erased to their new positions. This is generally an inefficient operation compared to the one
-         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
-         *
-         * @param begin An iterator specifying a range of beginning to erase.
-         * @param end An iterator specifying a range of end to erase.
-         *
-         * @return An iterator pointing to the new location of the element that followed the last element erased by
-         *		   the function call. This is the {@link rend rend()} if the operation erased the last element in the
-         *		   sequence.
-         */
-        erase(first: VectorIterator<T>, last: VectorIterator<T>): VectorIterator<T>;
-        /**
-         * <p> Erase element. </p>
-         *
-         * <p> Removes from the {@link Vector} either a single element; <i>position</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of element removed. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing an element in
-         * position other than the {@link end end()} causes the container to relocate all the elements after the
-         * segment erased to their new positions. This is generally an inefficient operation compared to the one
-         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
-         *
-         * @param position Iterator pointing to a single element to be removed from the {@link Vector}.
-         *
-         * @return An iterator pointing to the new location of the element that followed the last element erased by
-         *		   the function call. This is the {@link rend rend()} if the operation erased the last element in the
-         *		   sequence.
-         */
-        erase(position: VectorReverseIterator<T>): VectorReverseIterator<T>;
-        /**
-         * <p> Erase element. </p>
-         *
-         * <p> Removes from the <ode>Vector</code> either a single element; <i>position</i>. </p>
-         *
-         * <p> This effectively reduces the container size by the number of elements removed. </p>
-         *
-         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing elements in
-         * position other than the {@link end end()} causes the container to relocate all the elements after the
-         * segment erased to their new positions. This is generally an inefficient operation compared to the one
-         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
-         *
-         * @param begin An iterator specifying a range of beginning to erase.
-         * @param end An iterator specifying a range of end to erase.
-         *
-         * @return An iterator pointing to the new location of the element that followed the last element erased by
-         *		   the function call. This is the {@link end end()} if the operation erased the last element in the
-         *		   sequence.
-         */
-        erase(first: VectorReverseIterator<T>, last: VectorReverseIterator<T>): VectorReverseIterator<T>;
-        /**
-         * @hidden
-         */
-        protected _Erase_by_range(first: VectorIterator<T>, last: VectorIterator<T>): VectorIterator<T>;
-        /**
-         * <p> Swap content. </p>
-         *
-         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
-         * {@link Vector container} object with same type of elements. Sizes and container type may differ. </p>
-         *
-         * <p> After the call to this member function, the elements in this container are those which were in <i>obj</i>
-         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
-         * pointers remain valid for the swapped objects. </p>
-         *
-         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
-         * algorithm with an optimization that behaves like this member function. </p>
-         *
-         * @param obj Another {@link Vector container} of the same type of elements (i.e., instantiated
-         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
-         *			  {@link container Vector}.
-         */
-        obj(obj: Vector<T>): void;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: base.IContainer<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> An iterator of Vector. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
-     * </p>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class VectorIterator<T> extends Iterator<T> implements base.IArrayIterator<T> {
-        /**
-         * Sequence number of iterator in the source {@link Vector}.
-         */
-        private index_;
-        /**
-         * <p> Construct from the source {@link Vector container}. </p>
-         *
-         * <h4> Note </h4>
-         * <p> Do not create the iterator directly, by yourself. </p>
-         * <p> Use {@link Vector.begin begin()}, {@link Vector.end end()} in {@link Vector container} instead. </p>
-         *
-         * @param source The source {@link Vector container} to reference.
-         * @param index Sequence number of the element in the source {@link Vector}.
-         */
-        constructor(source: Vector<T>, index: number);
-        /**
-         * @hidden
-         */
-        private vector;
-        /**
-         * @inheritdoc
-         */
-        /**
-         * Set value of the iterator is pointing to.
-         *
-         * @param val Value to set.
-         */
-        value: T;
-        /**
-         * Get index.
-         */
-        index: number;
-        /**
-         * @inheritdoc
-         */
-        prev(): VectorIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        next(): VectorIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        advance(n: number): VectorIterator<T>;
-        /**
-         * <p> Whether an iterator is equal with the iterator. </p>
-         *
-         * <p> Compare two iterators and returns whether they are equal or not. </p>
-         *
-         * <h4> Note </h4>
-         * <p> Iterator's equal_to() only compare souce container and index number. </p>
-         *
-         * <p> Although elements in a pair, key and value are equal_to, if the source map or
-         * index number is different, then the {@link equal_to equal_to()} will return false. If you want to
-         * compare the elements of a pair, compare them directly by yourself. </p>
-         *
-         * @param obj An iterator to compare
-         * @return Indicates whether equal or not.
-         */
-        equal_to<U extends T>(obj: VectorIterator<U>): boolean;
-        /**
-         * @inheritdoc
-         */
-        swap(obj: VectorIterator<T>): void;
-    }
-}
-declare namespace std {
-    /**
-     * <p> A reverse-iterator of Vector. </p>
-     *
-     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
-     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
-     * </p>
-     *
-     * @param <T> Type of the elements.
-     *
-     * @author Jeongho Nam <http://samchon.org>
-     */
-    class VectorReverseIterator<T> extends ReverseIterator<T, VectorIterator<T>, VectorReverseIterator<T>> implements base.IArrayIterator<T> {
-        /**
-         * Construct from base iterator.
-         *
-         * @param base A reference of the base iterator, which iterates in the opposite direction.
-         */
-        constructor(base: VectorIterator<T>);
-        /**
-         * @hidden
-         */
-        protected create_neighbor(base: VectorIterator<T>): VectorReverseIterator<T>;
-        /**
-         * @inheritdoc
-         */
-        /**
-         * Set value of the iterator is pointing to.
-         *
-         * @param val Value to set.
-         */
-        value: T;
-        /**
-         * Get index.
-         */
-        index: number;
-    }
-}
-declare namespace std.base {
-    /**
-     * <p> Static class holding enumeration codes of color of Red-black tree. </p>
-     *
-     * <p> Color codes imposed to nodes of RB-Tree are following those rules: </p>
-     *
-     * <ol>
-     *	<li> A node is either <font color='red'>red</font> or <font color='darkBlue'>black</font>. </li>
-     *	<li> The root is <font color='darkBlue'>black</font>. This rule is sometimes omitted. Since the root can
-     *		 always be changed from <font color='red'>red</font> to <font color='darkBlue'>black</font>, but not
-     *		 necessarily vice versa, this rule has little effect on analysis. </li>
-     *	<li> All leaves (NIL; <code>null</code>) are <font color='darkBlue'>black</font>. </li>
-     *  <li> If a node is <font color='red'>red</font>, then both its children are
-     *		 <font color='darkBlue'>black</font>. </li>
-     *  <li> Every path from a given node to any of its descendant NIL nodes contains the same number of
-     *		 <font color='darkBlue'>black</font> nodes. Some definitions: the number of
-     *		 <font color='darkBlue'>black</font> nodes from the root to a node is the node's
-     *		 <font color='darkBlue'>black</font> depth; the uniform number of <font color='darkBlue'>black</font>
-     *		 nodes in all paths from root to the leaves is called the <font color='darkBlue'>black</font>-height of
-     *		 the red-black tree. </li>
-     * </ol>
-     *
-     * @author Migrated by Jeongho Nam <http://samchon.org>
-     */
-    enum Color {
-        /**
-         * <p> Code of color black. </p>
-         *
-         * <ul>
-         *	<li> Those are clearly black: root, leaf nodes or children nodes of red. </li>
-         *	<li> Every path from a given nodes containes the same number of black nodes exclude NIL(s). </li>
-         * </ul>
-         */
-        BLACK = 0,
-        /**
-         * <p> Code of color red. </p>
-         */
-        RED = 1,
-    }
-}
 declare namespace std.base {
     enum Hash {
         MIN_SIZE = 10,
@@ -10429,8 +3687,6 @@ declare namespace std.base {
          */
         set(index: number, val: T): void;
     }
-}
-declare namespace std.base {
     /**
      * <p> Random-access iterator. </p>
      *
@@ -10451,7 +3707,7 @@ declare namespace std.base {
      * @reference http://www.cplusplus.com/reference/iterator/RandomAccessIterator
      * @author Jeongho Nam <http://samchon.org>
      */
-    interface IArrayIterator<T> extends Iterator<T> {
+    interface IArrayIterator<T> extends ILinearIterator<T> {
         /**
          * Get index, sequence number of the iterator in the source {@link IArray array}.
          *
@@ -10596,7 +3852,7 @@ declare namespace std.base {
          *
          * @return New size of the Container.
          */
-        push<U extends T>(...items: U[]): number;
+        push(...items: T[]): number;
         /**
          * <p> Insert an element. </p>
          *
@@ -10807,6 +4063,1487 @@ declare namespace std.base {
          */
         insert<U extends T, InputIterator extends Iterator<U>>(position: Iterator<T>, begin: InputIterator, end: InputIterator): Iterator<T>;
     }
+    /**
+     * An interface for iterators from linear containers.
+     *
+     * {@link ILieanerIterator} is an bi-directional iterator which is created from the related
+     * {@link ILinearContainer linear containers}. Not only accessing to {@link value} of the pointed element from
+     * this {@link ILieanerIterator}, but also modifying the {@link value} is possible.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface ILinearIterator<T> extends Iterator<T> {
+        /**
+         * @inheritdoc
+         */
+        value: T;
+        /**
+         * @inheritdoc
+         */
+        prev(): ILinearIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        next(): ILinearIterator<T>;
+    }
+}
+declare namespace std {
+    /**
+     * <p> Bi-directional iterator. </p>
+     *
+     * <p> {@link Iterator Bidirectional iterators} are iterators that can be used to access the sequence of elements
+     * in a range in both directions (towards the end and towards the beginning). </p>
+     *
+     * <p> All {@link IArrayIterator random-access iterators} are also valid {@link Iterrator bidirectional iterators}.
+     * </p>
+     *
+     * <p> There is not a single type of {@link Iterator bidirectional iterator}: {@link IContainer Each container}
+     * may define its own specific iterator type able to iterate through it and access its elements. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" style="max-width: 100%" /></a>
+     * </p>
+     *
+     * @reference http://www.cplusplus.com/reference/iterator/BidirectionalIterator
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class Iterator<T> {
+        /**
+         * Source container of the iterator is directing for.
+         */
+        protected source_: base.IContainer<T>;
+        /**
+         * Construct from the source {@link IContainer container}.
+         *
+         * @param source The source
+         */
+        constructor(source: base.IContainer<T>);
+        /**
+         * <p> Get iterator to previous element. </p>
+         * <p> If current iterator is the first item(equal with {@link IContainer.begin IContainer.begin()}),
+         * returns {@link IContainer.end IContainer.end()}. </p>
+         *
+         * @return An iterator of the previous item.
+         */
+        abstract prev(): Iterator<T>;
+        /**
+         * <p> Get iterator to next element. </p>
+         * <p> If current iterator is the last item, returns {@link IContainer.end IContainer.end()}. </p>
+         *
+         * @return An iterator of the next item.
+         */
+        abstract next(): Iterator<T>;
+        /**
+         * Advances the {@link Iterator} by <i>n</i> element positions.
+         *
+         * @param n Number of element positions to advance.
+         * @return An advanced iterator.
+         */
+        advance(n: number): Iterator<T>;
+        /**
+         * Get source
+         */
+        get_source(): base.IContainer<T>;
+        /**
+         * <p> Whether an iterator is equal with the iterator. </p>
+         *
+         * <p> Compare two iterators and returns whether they are equal or not. </p>
+         *
+         * <h4> Note </h4>
+         * <p> Iterator's equal_to() only compare souce container and index number. </p>
+         *
+         * <p> Although elements in a pair, key and value are equal_to, if the source map or
+         * index number is different, then the {@link equal_to equal_to()} will return false. If you want to
+         * compare the elements of a pair, compare them directly by yourself. </p>
+         *
+         * @param obj An iterator to compare
+         * @return Indicates whether equal or not.
+         */
+        equal_to<U extends T>(obj: Iterator<U>): boolean;
+        /**
+         * <p> Get value of the iterator is pointing. </p>
+         *
+         * @return A value of the iterator.
+         */
+        readonly value: T;
+        abstract swap(obj: Iterator<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * <p> This class reverses the direction in which a bidirectional or random-access iterator iterates through a range.
+     * </p>
+     *
+     * <p> A copy of the original iterator (the {@link Iterator base iterator}) is kept internally and used to reflect
+     * the operations performed on the {@link ReverseIterator}: whenever the {@link ReverseIterator} is incremented, its
+     * {@link Iterator base iterator} is decreased, and vice versa. A copy of the {@link Iterator base iterator} with the
+     * current state can be obtained at any time by calling member {@link base}. </p>
+     *
+     * <p> Notice however that when an iterator is reversed, the reversed version does not point to the same element in
+     * the range, but to <b>the one preceding it</b>. This is so, in order to arrange for the past-the-end element of a
+     * range: An iterator pointing to a past-the-end element in a range, when reversed, is pointing to the last element
+     * (not past it) of the range (this would be the first element of the reversed range). And if an iterator to the
+     * first element in a range is reversed, the reversed iterator points to the element before the first element (this
+     * would be the past-the-end element of the reversed range). </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/abstract_containers.png" style="max-width: 100%" /></a>
+     * </p>
+     *
+     * @reference http://www.cplusplus.com/reference/iterator/reverse_iterator
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ReverseIterator<T, Base extends Iterator<T>, This extends ReverseIterator<T, Base, This>> extends Iterator<T> {
+        /**
+         * @hidden
+         */
+        protected base_: Base;
+        /**
+         * Construct from base iterator.
+         *
+         * @param base A reference of the base iterator, which iterates in the opposite direction.
+         */
+        constructor(base: Base);
+        /**
+         * <p> Return base iterator. </p>
+         *
+         * <p> Return a reference of the base iteraotr. </p>
+         *
+         * <p> The base iterator is an iterator of the same type as the one used to construct the {@link ReverseIterator},
+         * but pointing to the element next to the one the {@link ReverseIterator} is currently pointing to
+         * (a {@link ReverseIterator} has always an offset of -1 with respect to its base iterator).
+         *
+         * @return A reference of the base iterator, which iterates in the opposite direction.
+         */
+        base(): Base;
+        /**
+         * @hidden
+         */
+        protected abstract create_neighbor(base: Base): This;
+        /**
+         * <p> Get value of the iterator is pointing. </p>
+         *
+         * @return A value of the reverse iterator.
+         */
+        readonly value: T;
+        /**
+         * @inheritdoc
+         */
+        prev(): This;
+        /**
+         * @inheritdoc
+         */
+        next(): This;
+        /**
+         * @inheritdoc
+         */
+        advance(n: number): This;
+        /**
+         * @inheritdoc
+         */
+        equal_to(obj: This): boolean;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: This): void;
+    }
+    /**
+     * <p> Return distance between {@link Iterator iterators}. </p>
+     *
+     * <p> Calculates the number of elements between <i>first</i> and <i>last</i>. </p>
+     *
+     * <p> If it is a {@link IArrayIterator random-access iterator}, the function uses operator- to calculate this.
+     * Otherwise, the function uses the increase operator {@link Iterator.next next()} repeatedly. </p>
+     *
+     * @param first Iterator pointing to the initial element.
+     * @param last Iterator pointing to the final element. This must be reachable from first.
+     *
+     * @return The number of elements between first and last.
+     */
+    function distance<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator): number;
+    /**
+     * <p> Advance iterator. </p>
+     *
+     * <p> Advances the iterator <i>it</i> by <i>n</i> elements positions. </p>
+     *
+     * @param it Iterator to be advanced.
+     * @param n Number of element positions to advance.
+     *
+     * @return An iterator to the element <i>n</i> positions before <i>it</i>.
+     */
+    function advance<T, InputIterator extends Iterator<T>>(it: InputIterator, n: number): InputIterator;
+    /**
+     * <p> Get iterator to previous element. </p>
+     *
+     * <p> Returns an iterator pointing to the element that <i>it</i> would be pointing to if advanced <i>-n</i> positions. </p>
+     *
+     * @param it Iterator to base position.
+     * @param n Number of element positions offset (1 by default).
+     *
+     * @return An iterator to the element <i>n</i> positions before <i>it</i>.
+     */
+    function prev<T, BidirectionalIterator extends Iterator<T>>(it: BidirectionalIterator, n?: number): BidirectionalIterator;
+    /**
+     * <p> Get iterator to next element. </p>
+     *
+     * <p> Returns an iterator pointing to the element that <i>it</i> would be pointing to if advanced <i>n</i> positions. </p>
+     *
+     * @param it Iterator to base position.
+     * @param n Number of element positions offset (1 by default).
+     *
+     * @return An iterator to the element <i>n</i> positions away from <i>it</i>.
+     */
+    function next<T, ForwardIterator extends Iterator<T>>(it: ForwardIterator, n?: number): ForwardIterator;
+    /**
+     * <p> Iterator to beginning. </p>
+     *
+     * <p> Returns an iterator pointing to the first element in the sequence. </p>
+     *
+     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
+     *
+     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
+     *
+     * @return The same as returned by {@link IContainer.begin container.begin()}.
+     */
+    function begin<T>(container: Vector<T>): VectorIterator<T>;
+    /**
+     * <p> Iterator to beginning. </p>
+     *
+     * <p> Returns an iterator pointing to the first element in the sequence. </p>
+     *
+     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
+     *
+     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
+     *
+     * @return The same as returned by {@link IContainer.begin container.begin()}.
+     */
+    function begin<T>(container: List<T>): ListIterator<T>;
+    /**
+     * <p> Iterator to beginning. </p>
+     *
+     * <p> Returns an iterator pointing to the first element in the sequence. </p>
+     *
+     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
+     *
+     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
+     *
+     * @return The same as returned by {@link IContainer.begin container.begin()}.
+     */
+    function begin<T>(container: Deque<T>): DequeIterator<T>;
+    /**
+     * <p> Iterator to beginning. </p>
+     *
+     * <p> Returns an iterator pointing to the first element in the sequence. </p>
+     *
+     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
+     *
+     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
+     *
+     * @return The same as returned by {@link IContainer.begin container.begin()}.
+     */
+    function begin<T>(container: base.SetContainer<T>): SetIterator<T>;
+    /**
+     * <p> Iterator to beginning. </p>
+     *
+     * <p> Returns an iterator pointing to the first element in the sequence. </p>
+     *
+     * <p> If the sequence is empty, the returned value shall not be dereferenced. </p>
+     *
+     * @param container A container object of a class type for which member {@link IContainer.begin begin} is defined.
+     *
+     * @return The same as returned by {@link IContainer.begin container.begin()}.
+     */
+    function begin<Key, T>(container: base.MapContainer<Key, T>): MapIterator<Key, T>;
+    /**
+     * <p> Iterator to end. </p>
+     *
+     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
+     *
+     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
+     *
+     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
+     *
+     * @return The same as returned by {@link IContainer.end container.end()}.
+     */
+    function end<T>(container: Vector<T>): VectorIterator<T>;
+    /**
+     * <p> Iterator to end. </p>
+     *
+     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
+     *
+     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
+     *
+     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
+     *
+     * @return The same as returned by {@link IContainer.end container.end()}.
+     */
+    function end<T>(container: List<T>): ListIterator<T>;
+    /**
+     * <p> Iterator to end. </p>
+     *
+     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
+     *
+     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
+     *
+     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
+     *
+     * @return The same as returned by {@link IContainer.end container.end()}.
+     */
+    function end<T>(container: Deque<T>): DequeIterator<T>;
+    /**
+     * <p> Iterator to end. </p>
+     *
+     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
+     *
+     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
+     *
+     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
+     *
+     * @return The same as returned by {@link IContainer.end container.end()}.
+     */
+    function end<T>(container: base.SetContainer<T>): SetIterator<T>;
+    /**
+     * <p> Iterator to end. </p>
+     *
+     * <p> Returns an iterator pointing to the <i>past-the-end</i> element in the sequence. </p>
+     *
+     * <p> If the sequence is {@link IContainer.empty empty}, the returned value compares equal to the one returned by {@link begin} with the same argument. </p>
+     *
+     * @param container A container of a class type for which member {@link IContainer.end end} is defined.
+     *
+     * @return The same as returned by {@link IContainer.end container.end()}.
+     */
+    function end<Key, T>(container: base.MapContainer<Key, T>): MapIterator<Key, T>;
+}
+declare namespace std.base {
+    /**
+     * <p> An abstract map. </p>
+     *
+     * <p> {@link MapContainer MapContainers} are associative containers that store elements formed by a combination
+     * of a <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), and which allows for fast retrieval
+     * of individual elements based on their keys. </p>
+     *
+     * <p> In a {@link MapContainer}, the <i>key values</i> are generally used to identify the elements, while the
+     * <i>mapped values</i> store the content associated to this key. The types of <i>key</i> and
+     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a
+     * {@link Pair} type combining both: </p>
+     *
+     * <p> <code>typedef pair<const Key, T> value_type;</code> </p>
+     *
+     * <p> {@link MapContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
+     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
+     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram" style="max-width: 100%" /></a> </p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute position
+     *		in the container.
+     *	</dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd>
+     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
+     *	</dd>
+     * </dl>
+     *
+     * @param <Key> Type of the keys. Each element in a map is identified by its key value.
+     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class MapContainer<Key, T> extends Container<Pair<Key, T>> {
+        /**
+         * <p> {@link List} storing elements. </p>
+         *
+         * <p> Storing elements and keeping those sequence of the {@link MapContainer} are implemented by
+         * {@link data_ this list container}. Implementing index-table is also related with {@link data_ this list}
+         * by storing {@link ListIterator iterators} ({@link MapIterator} references {@link ListIterator}) who are
+         * created from {@link data_ here}. </p>
+         */
+        private data_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        assign<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * <p> Get iterator to element. </p>
+         *
+         * <p> Searches the container for an element with a identifier equivalent to <i>key</i> and returns an
+         * iterator to it if found, otherwise it returns an iterator to {@link end end()}. </p>
+         *
+         * <p> Two keys are considered equivalent if the container's comparison object returns false reflexively
+         * (i.e., no matter the order in which the elements are passed as arguments). </p>
+         *
+         * <p> Another member functions, {@link has has()} and {@link count count()}, can be used to just check
+         * whether a particular <i>key</i> exists. </p>
+         *
+         * @param key Key to be searched for
+         * @return An iterator to the element, if an element with specified <i>key</i> is found, or
+         *		   {@link end end()} otherwise.
+         */
+        abstract find(key: Key): MapIterator<Key, T>;
+        /**
+         * <p> Return iterator to beginning. </p>
+         *
+         * <p> Returns an iterator referring the first element in the  </p>
+         *
+         * <h4> Note </h4>
+         * <p> If the container is {@link empty}, the returned iterator is same with {@link end end()}. </p>
+         *
+         * @return An iterator to the first element in the  The iterator containes the first element's value.
+         */
+        begin(): MapIterator<Key, T>;
+        /**
+         * <p> Return iterator to end. </p>
+         * <p> Returns an iterator referring to the past-the-end element in the  </p>
+         *
+         * <p> The past-the-end element is the theoretical element that would follow the last element in the
+         *  It does not point to any element, and thus shall not be dereferenced. </p>
+         *
+         * <p> Because the ranges used by functions of the container do not include the element reference by their
+         * closing iterator, this function is often used in combination with {@link MapContainer}.{@link begin} to
+         * specify a range including all the elements in the  </p>
+         *
+         * <h4> Note </h4>
+         * <p> Returned iterator from {@link MapContainer}.{@link end} does not refer any element. Trying to accessing
+         * element by the iterator will cause throwing exception ({@link OutOfRange}). </p>
+         *
+         * <p> If the container is {@link empty}, this function returns the same as {@link begin}. </p>
+         *
+         * @return An iterator to the end element in the
+         */
+        end(): MapIterator<Key, T>;
+        /**
+         * <p> Return {@link MapReverseIterator reverse iterator} to <i>reverse beginning</i>. </p>
+         *
+         * <p> Returns a {@link MapReverseIterator reverse iterator} pointing to the last element in the container
+         * (i.e., its <i>reverse beginning</i>). </p>
+         *
+         * {@link MapReverseIterator Reverse iterators} iterate backwards: increasing them moves them towards the
+         * beginning of the container. </p>
+         *
+         * <p> {@link rbegin} points to the element preceding the one that would be pointed to by member {@link end}.
+         * </p>
+         *
+         * @return A {@link MapReverseIterator reverse iterator} to the <i>reverse beginning</i> of the sequence
+         *
+         */
+        rbegin(): MapReverseIterator<Key, T>;
+        /**
+         * <p> Return {@link MapReverseIterator reverse iterator} to <i>reverse end</i>. </p>
+         *
+         * <p> Returns a {@link MapReverseIterator reverse iterator} pointing to the theoretical element right before
+         * the first element in the {@link MapContainer map container} (which is considered its <i>reverse end</i>).
+         * </p>
+         *
+         * <p> The range between {@link MapContainer}.{@link rbegin} and {@link MapContainer}.{@link rend} contains
+         * all the elements of the container (in reverse order). </p>
+         *
+         * @return A {@link MapReverseIterator reverse iterator} to the <i>reverse end</i> of the sequence
+         */
+        rend(): MapReverseIterator<Key, T>;
+        /**
+         * <p> Whether have the item or not. </p>
+         *
+         * <p> Indicates whether a map has an item having the specified identifier. </p>
+         *
+         * @param key Key value of the element whose mapped value is accessed.
+         *
+         * @return Whether the map has an item having the specified identifier.
+         */
+        has(key: Key): boolean;
+        /**
+         * <p> Count elements with a specific key. </p>
+         *
+         * <p> Searches the container for elements whose key is <i>key</i> and returns the number of elements found. </p>
+         *
+         * @param key Key value to be searched for.
+         *
+         * @return The number of elements in the container with a <i>key</i>.
+         */
+        abstract count(key: Key): number;
+        /**
+         * Return the number of elements in the map.
+         */
+        size(): number;
+        /**
+         * @inheritdoc
+         */
+        push(...args: Pair<Key, T>[]): number;
+        /**
+         * @inheritdoc
+         */
+        push(...args: [Key, T][]): number;
+        /**
+         * Construct and insert element with hint
+         *
+         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
+         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
+         * container suggested as a hint on where to start the search for its insertion point (the container may or
+         * may not use this suggestion to optimize the insertion operation).
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
+         * the container, and may also take a position *hint*.
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param key The key used both to look up and to insert if not found.
+         * @param value Value, the item.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link MapContainer}.
+         */
+        emplace_hint(hint: MapIterator<Key, T>, key: Key, val: T): MapIterator<Key, T>;
+        /**
+         * Construct and insert element with hint
+         *
+         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
+         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
+         * container suggested as a hint on where to start the search for its insertion point (the container may or
+         * may not use this suggestion to optimize the insertion operation).
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
+         * the container, and may also take a position *hint*.
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param key The key used both to look up and to insert if not found.
+         * @param value Value, the item.
+         *
+         * @return An {@link MapIterator iterator} pointing to either the newly inserted element or to the element
+         *		   that already had an equivalent key in the {@link MapContainer}.
+         */
+        emplace_hint(hint: MapReverseIterator<Key, T>, key: Key, val: T): MapReverseIterator<Key, T>;
+        /**
+         * Construct and insert element with hint
+         *
+         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
+         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
+         * container suggested as a hint on where to start the search for its insertion point (the container may or
+         * may not use this suggestion to optimize the insertion operation).
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
+         * the container, and may also take a position *hint*.
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link MapContainer}.
+         */
+        emplace_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * Construct and insert element with hint
+         *
+         * Inserts a new element in the {@link MapContainer map container}. This new element is constructed in
+         * place using *args* as the arguments for the element's constructor. *hint* points to a location in the
+         * container suggested as a hint on where to start the search for its insertion point (the container may or
+         * may not use this suggestion to optimize the insertion operation).
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves an existing object into
+         * the container, and may also take a position *hint*.
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         *
+         * @return An {@link MapIterator iterator} pointing to either the newly inserted element or to the element
+         *		   that already had an equivalent key in the {@link MapContainer}.
+         */
+        emplace_hint(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * <p> Insert an element. </p>
+         *
+         * <p> Extends the container by inserting a new element, effectively increasing the container {@link size}
+         * by the number of element inserted (zero or one). </p>
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link MapContainer}.
+         */
+        insert(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * <p> Insert an element. </p>
+         *
+         * <p> Extends the container by inserting a new element, effectively increasing the container {@link size}
+         * by the number of element inserted (zero or one). </p>
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link MapContainer}.
+         */
+        insert(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * <p> Insert an element. </p>
+         *
+         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size}
+         * by the number of elements inserted. </p>
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link MapContainer}.
+         */
+        insert<L extends Key, U extends T>(hint: MapIterator<Key, T>, tuple: [L, U]): MapIterator<Key, T>;
+        /**
+         * <p> Insert an element. </p>
+         *
+         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size}
+         * by the number of elements inserted. </p>
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link MapContainer}.
+         */
+        insert<L extends Key, U extends T>(hint: MapReverseIterator<Key, T>, tuple: [L, U]): MapReverseIterator<Key, T>;
+        /**
+         * <p> Insert elements from range iterators. </p>
+         *
+         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
+         * the number of elements inserted. </p>
+         *
+         * @param begin Input iterator specifying initial position of a range of elements.
+         * @param end Input iterator specifying final position of a range of elements.
+         *			  Notice that the range includes all the elements between <i>begin</i> and <i>end</i>,
+         *			  including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
+         */
+        insert<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @hidden
+         */
+        protected abstract _Insert_by_pair<L extends Key, U extends T>(pair: Pair<L, U>): any;
+        /**
+         * @hidden
+         */
+        private insert_by_tuple<L, U>(tuple);
+        /**
+         * @hidden
+         */
+        protected abstract _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        private insert_by_hint_with_tuple(hint, tuple);
+        /**
+         * @hidden
+         */
+        protected abstract _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * <p> Erase an elemet by key. </p>
+         *
+         * <p> Removes from the {@link MapContainer map container} a single element. </p>
+         *
+         * <p> This effectively reduces the container {@link size} by the number of element removed (zero or one),
+         * which are destroyed. </p>
+         *
+         * @param key Key of the element to be removed from the {@link MapContainer}.
+         */
+        erase(key: Key): number;
+        /**
+         * <p> Erase an elemet by iterator. </p>
+         *
+         * <p> Removes from the {@link MapContainer map container} a single element. </p>
+         *
+         * <p> This effectively reduces the container {@link size} by the number of element removed (zero or one),
+         * which are destroyed. </p>
+         *
+         * @param it Iterator specifying position winthin the {@link MapContainer map contaier} to be removed.
+         */
+        erase(it: MapIterator<Key, T>): MapIterator<Key, T>;
+        /**
+         * <p> Erase elements by range iterators. </p>
+         *
+         * <p> Removes from the {@link MapContainer map container} a range of elements. </p>
+         *
+         * <p> This effectively reduces the container {@link size} by the number of elements removed, which are
+         * destroyed. </p>
+         *
+         * @param begin An iterator specifying initial position of a range within {@link MApContainer map container}
+         *				to be removed.
+         * @param end An iterator specifying initial position of a range within {@link MApContainer map container}
+         *			  to be removed.
+         *			  Notice that the range includes all the elements between <i>begin</i> and <i>end</i>,
+         *			  including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
+         */
+        erase(begin: MapIterator<Key, T>, end: MapIterator<Key, T>): MapIterator<Key, T>;
+        /**
+         * <p> Erase an elemet by iterator. </p>
+         *
+         * <p> Removes from the {@link MapContainer map container} a single element. </p>
+         *
+         * <p> This effectively reduces the container {@link size} by the number of element removed (zero or one),
+         * which are destroyed. </p>
+         *
+         * @param it Iterator specifying position winthin the {@link MapContainer map contaier} to be removed.
+         */
+        erase(it: MapReverseIterator<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * <p> Erase elements by range iterators. </p>
+         *
+         * <p> Removes from the {@link MapContainer map container} a range of elements. </p>
+         *
+         * <p> This effectively reduces the container {@link size} by the number of elements removed, which are
+         * destroyed. </p>
+         *
+         * @param begin An iterator specifying initial position of a range within {@link MApContainer map container}
+         *				to be removed.
+         * @param end An iterator specifying initial position of a range within {@link MApContainer map container}
+         *			  to be removed.
+         *			  Notice that the range includes all the elements between <i>begin</i> and <i>end</i>,
+         *			  including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
+         */
+        erase(begin: MapReverseIterator<Key, T>, end: MapReverseIterator<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        private erase_by_key(key);
+        /**
+         * @hidden
+         */
+        private erase_by_iterator(first, last?);
+        /**
+         * @hidden
+         */
+        private erase_by_range(begin, end);
+        /**
+         * @hidden
+         */
+        protected _Swap(obj: MapContainer<Key, T>): void;
+        /**
+         * Merge two maps.
+         *
+         * Extracts and transfers elements from *source* to this container.
+         *
+         * @param source A {@link MapContainer map container} to transfer the elements from.
+         */
+        abstract merge<L extends Key, U extends T>(source: MapContainer<L, U>): void;
+        /**
+         * <p> Abstract method handling insertions for indexing. </p>
+         *
+         * <p> This method, {@link _Handle_insert} is designed to register the <i>first to last</i> to somewhere storing
+         * those {@link MapIterator iterators} for indexing, fast accessment and retrievalance. </p>
+         *
+         * <p> When {@link insert} is called, new elements will be inserted into the {@link data_ list container} and new
+         * {@link MapIterator iterators} <i>first to last</i>, pointing the inserted elements, will be created and the
+         * newly created iterators <i>first to last</i> will be shifted into this method {@link _Handle_insert} after the
+         * insertions. </p>
+         *
+         * <p> If the derived one is {@link RBTree tree-based} like {@link TreeSet}, the {@link MapIterator iterators}
+         * will be registered into the {@link TreeSet.tree_ tree} as a {@link XTreeNode tree node item}. Else if the
+         * derived one is {@link HashBuckets hash-based} like {@link HashSet}, the <i>first</i> to <i>last</i> will be
+         * registered into the {@link HashSet.hash_buckets_ hash bucket}. </p>
+         *
+         * @param first An {@link MapIterator} to the initial position in a sequence.
+         * @param last An {@link MapIterator} to the final position in a sequence. The range used is
+         *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+         *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+         */
+        protected abstract _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * <p> Abstract method handling deletions for indexing. </p>
+         *
+         * <p> This method, {@link _Handle_erase} is designed to unregister the <i>first to last</i> to somewhere storing
+         * those {@link MapIterator iterators} for indexing, fast accessment and retrievalance. </p>
+         *
+         * <p> When {@link erase} is called with <i>first to last</i>, {@link MapIterator iterators} positioning somewhere
+         * place to be deleted, is memorized and shifted to this method {@link _Handle_erase} after the deletion process is
+         * terminated. </p>
+         *
+         * <p> If the derived one is {@link RBTree tree-based} like {@link TreeSet}, the {@link MapIterator iterators}
+         * will be unregistered from the {@link TreeSet.tree_ tree} as a {@link XTreeNode tree node item}. Else if the
+         * derived one is {@link HashBuckets hash-based} like {@link HashSet}, the <i>first to last</i> will be
+         * unregistered from the {@link HashSet.hash_buckets_ hash bucket}. </p>
+         *
+         * @param first An {@link MapIterator} to the initial position in a sequence.
+         * @param last An {@link MapIterator} to the final position in a sequence. The range used is
+         *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+         *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+         */
+        protected abstract _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * <p> An iterator of {@link MapContainer map container}. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram" style="max-width: 100%" /></a> </p>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class MapIterator<Key, T> extends Iterator<Pair<Key, T>> implements IComparable<MapIterator<Key, T>> {
+        /**
+         * A {@link ListIterator} pointing {@link Pair} of <i>key</i> and <i>value</i>.
+         */
+        private list_iterator_;
+        /**
+         * Construct from the {@link MapContainer source map} and {@link ListIterator list iterator}.
+         *
+         * @param source The source {@link MapContainer}.
+         * @param list_iterator A {@link ListIterator} pointing {@link Pair} of <i>key</i> and <i>value</i>.
+         */
+        constructor(source: base.MapContainer<Key, T>, list_iterator: ListIterator<Pair<Key, T>>);
+        /**
+         * Get iterator to previous element.
+         */
+        prev(): MapIterator<Key, T>;
+        /**
+         * Get iterator to next element.
+         */
+        next(): MapIterator<Key, T>;
+        /**
+         * Advances the Iterator by n element positions.
+         *
+         * @param step Number of element positions to advance.
+         * @return An advanced Iterator.
+         */
+        advance(step: number): MapIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        private readonly map;
+        /**
+         * Get ListIterator.
+         */
+        get_list_iterator(): ListIterator<Pair<Key, T>>;
+        /**
+         * @inheritdoc
+         */
+        readonly value: Pair<Key, T>;
+        /**
+         * Get first, key element.
+         */
+        readonly first: Key;
+        /**
+         * Get second, value element.
+         */
+        /**
+         * Set second value.
+         */
+        second: T;
+        /**
+         * <p> Whether an iterator is equal with the iterator. </p>
+         *
+         * <p> Compare two iterators and returns whether they are equal or not. </p>
+         *
+         * @param obj An iterator to compare
+         * @return Indicates whether equal or not.
+         */
+        equal_to<L extends Key, U extends T>(obj: MapIterator<L, U>): boolean;
+        less<L extends Key, U extends T>(obj: MapIterator<L, U>): boolean;
+        hash(): number;
+        swap(obj: MapIterator<Key, T>): void;
+    }
+    /**
+     * <p> A reverse-iterator of {@link MapContainer map container}. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram" style="max-width: 100%" /></a> </p>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class MapReverseIterator<Key, T> extends ReverseIterator<Pair<Key, T>, MapIterator<Key, T>, MapReverseIterator<Key, T>> {
+        /**
+         * Construct from base iterator.
+         *
+         * @param base A reference of the base iterator, which iterates in the opposite direction.
+         */
+        constructor(base: MapIterator<Key, T>);
+        /**
+         * @hidden
+         */
+        protected create_neighbor(base: MapIterator<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * Get first, key element.
+         */
+        readonly first: Key;
+        /**
+         * Get second, value element.
+         */
+        /**
+         * Set second value.
+         */
+        second: T;
+    }
+}
+declare namespace std.base {
+    /**
+     * <p> An abstract multi-map. </p>
+     *
+     * <p> {@link MultiMap MultiMaps} are associative containers that store elements formed by a combination of a
+     * <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), and which allows for fast retrieval of
+     * individual elements based on their keys. </p>
+     *
+     * <p> In a {@link MapContainer}, the <i>key values</i> are generally used to identify the elements, while the
+     * <i>mapped values</i> store the content associated to this <i>key</i>. The types of <i>key</i> and
+     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a
+     * {@link Pair} type combining both: </p>
+     *
+     * <p> <code>typedef pair<const Key, T> value_type;</code> </p>
+     *
+     * <p> {@link UniqueMap} stores elements, keeps sequence and enables indexing by inserting elements into a
+     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
+     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /></a> </p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute position
+     *		in the container.
+     *	</dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd>
+     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
+     *	</dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the keys. Each element in a map is identified by its key value.
+     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class MultiMap<Key, T> extends MapContainer<Key, T> {
+        /**
+         * Construct and insert element.
+         *
+         * Inserts a new element in the {@link MultiMap}. This new element is constructed in place using <i>args</i>
+         * as the arguments for the element's constructor.
+         *
+         * This effectively increases the container {@link size} by one.
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
+         * container.
+         *
+         * @param key The key used both to look up and to insert if not found.
+         * @param value Value, the item.
+         *
+         * @return An {@link MapIterator iterator} to the newly inserted element.
+         */
+        emplace(key: Key, value: T): MapIterator<Key, T>;
+        /**
+         * Construct and insert element.
+         *
+         * Inserts a new element in the {@link MultiMap}. This new element is constructed in place using <i>args</i>
+         * as the arguments for the element's constructor.
+         *
+         * This effectively increases the container {@link size} by one.
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
+         * container.
+         *
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         * @return An {@link MapIterator iterator} to the newly inserted element.
+         */
+        emplace(pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * <p> Insert elements. </p>
+         *
+         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
+         * the number of elements inserted. </p>
+         *
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         *
+         * @return An iterator pointing to the newly inserted element.
+         */
+        insert(pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * <p> Insert elements. </p>
+         *
+         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
+         * the number of elements inserted. </p>
+         *
+         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
+         *
+         * @return An iterator pointing to the newly inserted element.
+         */
+        insert<L extends Key, U extends T>(tuple: [L, U]): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert<L extends Key, U extends T>(hint: MapIterator<Key, T>, tuple: [L, U]): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert<L extends Key, U extends T>(hint: MapReverseIterator<Key, T>, tuple: [L, U]): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        merge<L extends Key, U extends T>(source: MapContainer<L, U>): void;
+    }
+}
+declare namespace std.base {
+    /**
+     * <p> An abstract set. </p>
+     *
+     * <p> {@link SetContainer SetContainers} are containers that store elements allowing fast retrieval of
+     * individual elements based on their value. </p>
+     *
+     * <p> In an {@link SetContainer}, the value of an element is at the same time its <i>key</i>, used to
+     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link SetContainer} cannot be
+     * modified once in the container - they can be inserted and removed, though. </p>
+     *
+     * <p> {@link SetContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
+     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
+     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements. Each element in a {@link SetContainer} container is also identified
+     *			  by this value (each value is itself also the element's <i>key</i>).
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class SetContainer<T> extends Container<T> {
+        /**
+         * <p> {@link List} storing elements. </p>
+         *
+         * <p> Storing elements and keeping those sequence of the {@link SetContainer} are implemented by
+         * {@link data_ this list container}. Implementing index-table is also related with {@link data_ this list}
+         * by storing {@link ListIterator iterators} ({@link SetIterator} references {@link ListIterator}) who are
+         * created from {@link data_ here}. </p>
+         */
+        private data_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        assign<U extends T, InputIterator extends Iterator<U>>(begin: Iterator<U>, end: Iterator<U>): void;
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * <p> Get iterator to element. </p>
+         *
+         * <p> Searches the container for an element with <i>key</i> as value and returns an iterator to it if found,
+         * otherwise it returns an iterator to {@link end end()} (the element past the end of the container). </p>
+         *
+         * <p> Another member function, {@link count count()}, can be used to just check whether a particular element
+         * exists. </p>
+         *
+         * @param key Key to be searched for.
+         *
+         * @return An iterator to the element, if the specified value is found, or {@link end end()} if it is not
+         *		   found in the
+         */
+        abstract find(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        begin(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): SetReverseIterator<T>;
+        /**
+         * <p> Whether have the item or not. </p>
+         *
+         * <p> Indicates whether a set has an item having the specified identifier. </p>
+         *
+         * @param key Key value of the element whose mapped value is accessed.
+         *
+         * @return Whether the set has an item having the specified identifier.
+         */
+        has(val: T): boolean;
+        /**
+         * <p> Count elements with a specific key. </p>
+         *
+         * <p> Searches the container for elements with a value of k and returns the number of elements found. </p>
+         *
+         * @param key Value of the elements to be counted.
+         *
+         * @return The number of elements in the container with a <i>key</i>.
+         */
+        abstract count(val: T): number;
+        /**
+         * @inheritdoc
+         */
+        size(): number;
+        /**
+         * @inheritdoc
+         */
+        push(...args: T[]): number;
+        /**
+         * <p> Insert an element with hint. </p>
+         *
+         * <p> Extends the container by inserting new elements, effectively increasing the container size by the
+         * number of elements inserted. </p>
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param val Value to be inserted as an element.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had its
+         *		   same value in the {@link SetContainer}.
+         */
+        insert(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * <p> Insert an element with hint. </p>
+         *
+         * <p> Extends the container by inserting new elements, effectively increasing the container size by the
+         * number of elements inserted. </p>
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param val Value to be inserted as an element.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had its
+         *		   same value in the {@link SetContainer}.
+         */
+        insert(hint: SetReverseIterator<T>, val: T): SetReverseIterator<T>;
+        /**
+         * <p> Insert elements with a range of a  </p>
+         *
+         * <p> Extends the container by inserting new elements, effectively increasing the container size by the
+         * number of elements inserted. </p>
+         *
+         * @param begin An iterator specifying range of the begining element.
+         * @param end An iterator specifying range of the ending element.
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * @hidden
+         */
+        protected abstract _Insert_by_val(val: T): any;
+        /**
+         * @hidden
+         */
+        protected abstract _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * @hidden
+         */
+        protected abstract _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * <p> Erase an element. </p>
+         * <p> Removes from the set container the elements whose value is <i>key</i>. </p>
+         *
+         * <p> This effectively reduces the container size by the number of elements removed. </p>
+         *
+         * @param key Value of the elements to be erased.
+         *
+         * @return Number of elements erased.
+         */
+        erase(val: T): number;
+        /**
+         * @inheritdoc
+         */
+        erase(it: SetIterator<T>): SetIterator<T>;
+        /**
+         * <p> Erase elements. </p>
+         * <p> Removes from the set container a range of elements.. </p>
+         *
+         * <p> This effectively reduces the container size by the number of elements removed. </p>
+         *
+         * @param begin An iterator specifying a range of beginning to erase.
+         * @param end An iterator specifying a range of end to erase.
+         */
+        erase(begin: SetIterator<T>, end: SetIterator<T>): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        erase(it: SetReverseIterator<T>): SetReverseIterator<T>;
+        /**
+         * <p> Erase elements. </p>
+         * <p> Removes from the set container a range of elements.. </p>
+         *
+         * <p> This effectively reduces the container size by the number of elements removed. </p>
+         *
+         * @param begin An iterator specifying a range of beginning to erase.
+         * @param end An iterator specifying a range of end to erase.
+         */
+        erase(begin: SetReverseIterator<T>, end: SetReverseIterator<T>): SetReverseIterator<T>;
+        /**
+         * @hidden
+         */
+        private erase_by_iterator(first, last?);
+        /**
+         * @hidden
+         */
+        private erase_by_val(val);
+        /**
+         * @hidden
+         */
+        private erase_by_range(begin, end);
+        /**
+         * @hidden
+         */
+        protected _Swap(obj: SetContainer<T>): void;
+        /**
+         * Merge two sets.
+         *
+         * Extracts and transfers elements from *source* to this container.
+         *
+         * @param source A {@link SetContainer set container} to transfer the elements from.
+         */
+        abstract merge<U extends T>(source: SetContainer<U>): void;
+        /**
+         * <p> Abstract method handling insertions for indexing. </p>
+         *
+         * <p> This method, {@link _Handle_insert} is designed to register the <i>first to last</i> to somewhere storing
+         * those {@link SetIterator iterators} for indexing, fast accessment and retrievalance. </p>
+         *
+         * <p> When {@link insert} is called, new elements will be inserted into the {@link data_ list container} and new
+         * {@link SetIterator iterators} <i>first to last</i>, pointing the inserted elements, will be created and the
+         * newly created iterators <i>first to last</i> will be shifted into this method {@link _Handle_insert} after the
+         * insertions. </p>
+         *
+         * <p> If the derived one is {@link RBTree tree-based} like {@link TreeSet}, the {@link SetIterator iterators}
+         * will be registered into the {@link TreeSet.tree_ tree} as a {@link XTreeNode tree node item}. Else if the
+         * derived one is {@link HashBuckets hash-based} like {@link HashSet}, the <i>first</i> to <i>last</i> will be
+         * registered into the {@link HashSet.hash_buckets_ hash bucket}. </p>
+         *
+         * @param first An {@link SetIterator} to the initial position in a sequence.
+         * @param last An {@link SetIterator} to the final position in a sequence. The range used is
+         *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+         *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+         */
+        protected abstract _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * <p> Abstract method handling deletions for indexing. </p>
+         *
+         * <p> This method, {@link _Handle_erase} is designed to unregister the <i>first to last</i> to somewhere storing
+         * those {@link SetIterator iterators} for indexing, fast accessment and retrievalance. </p>
+         *
+         * <p> When {@link erase} is called with <i>first to last</i>, {@link SetIterator iterators} positioning somewhere
+         * place to be deleted, is memorized and shifted to this method {@link _Handle_erase} after the deletion process is
+         * terminated. </p>
+         *
+         * <p> If the derived one is {@link RBTree tree-based} like {@link TreeSet}, the {@link SetIterator iterators}
+         * will be unregistered from the {@link TreeSet.tree_ tree} as a {@link XTreeNode tree node item}. Else if the
+         * derived one is {@link HashBuckets hash-based} like {@link HashSet}, the <i>first to last</i> will be
+         * unregistered from the {@link HashSet.hash_buckets_ hash bucket}. </p>
+         *
+         * @param first An {@link SetIterator} to the initial position in a sequence.
+         * @param last An {@link SetIterator} to the final position in a sequence. The range used is
+         *			   [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and <i>last</i>,
+         *			   including the element pointed by <i>first</i> but not the element pointed by <i>last</i>.
+         */
+        protected abstract _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * <p> An iterator of a Set. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class SetIterator<T> extends Iterator<T> implements IComparable<SetIterator<T>> {
+        private list_iterator_;
+        /**
+         * <p> Construct from source and index number. </p>
+         *
+         * <h4> Note </h4>
+         * <p> Do not create iterator directly. </p>
+         * <p> Use begin(), find() or end() in Map instead. </p>
+         *
+         * @param map The source Set to reference.
+         * @param index Sequence number of the element in the source Set.
+         */
+        constructor(source: base.SetContainer<T>, it: ListIterator<T>);
+        /**
+         * @inheritdoc
+         */
+        prev(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        next(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        advance(size: number): SetIterator<T>;
+        /**
+         * @hidden
+         */
+        private readonly set;
+        get_list_iterator(): ListIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        readonly value: T;
+        /**
+         * @inheritdoc
+         */
+        equal_to<U extends T>(obj: SetIterator<U>): boolean;
+        /**
+         * @inheritdoc
+         */
+        less<U extends T>(obj: SetIterator<U>): boolean;
+        /**
+         * @inheritdoc
+         */
+        hash(): number;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: SetIterator<T>): void;
+    }
+    /**
+     * <p> A reverse-iterator of Set. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class SetReverseIterator<T> extends ReverseIterator<T, SetIterator<T>, SetReverseIterator<T>> {
+        /**
+         * Construct from base iterator.
+         *
+         * @param base A reference of the base iterator, which iterates in the opposite direction.
+         */
+        constructor(base: SetIterator<T>);
+        /**
+         * @hidden
+         */
+        protected create_neighbor(base: SetIterator<T>): SetReverseIterator<T>;
+    }
+}
+declare namespace std.base {
+    /**
+     * <p> An abstract set. </p>
+     *
+     * <p> {@link SetContainer SetContainers} are containers that store elements allowing fast retrieval of
+     * individual elements based on their value. </p>
+     *
+     * <p> In an {@link SetContainer}, the value of an element is at the same time its <i>key</i>, used to
+     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link SetContainer} cannot be
+     * modified once in the container - they can be inserted and removed, though. </p>
+     *
+     * <p> {@link SetContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
+     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
+     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements. Each element in a {@link SetContainer} container is also identified
+     *			  by this value (each value is itself also the element's <i>key</i>).
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class MultiSet<T> extends SetContainer<T> {
+        /**
+         * <p> Insert an element. </p>
+         *
+         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
+         * the number of elements inserted. </p>
+         *
+         * @param key Value to be inserted as an element.
+         *
+         * @return An iterator to the newly inserted element.
+         */
+        insert(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: SetReverseIterator<T>, val: T): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        merge<U extends T>(source: SetContainer<U>): void;
+    }
 }
 declare namespace std.base {
     /**
@@ -12036,6 +6773,449 @@ declare namespace std.base {
         is_less(left: SetIterator<T>, right: SetIterator<T>): boolean;
     }
 }
+declare namespace std.base {
+    /**
+     * <p> An abstract unique-map. </p>
+     *
+     * <p> {@link UniqueMap UniqueMaps} are associative containers that store elements formed by a combination of a
+     * <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), and which allows for fast retrieval of
+     * individual elements based on their keys. </p>
+     *
+     * <p> In a {@link MapContainer}, the <i>key values</i> are generally used to uniquely identify the elements,
+     * while the <i>mapped values</i> store the content associated to this key. The types of <i>key</i> and
+     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a
+     * {@link Pair} type combining both: </p>
+     *
+     * <p> <code>typedef pair<const Key, T> value_type;</code> </p>
+     *
+     * <p> {@link UniqueMap} stores elements, keeps sequence and enables indexing by inserting elements into a
+     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
+     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram" style="max-width: 100%" /></a> </p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute position
+     *		in the container.
+     *	</dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd>
+     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
+     *	</dd>
+     *
+     *	<dt> Unique keys </dt>
+     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
+     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class UniqueMap<Key, T> extends MapContainer<Key, T> {
+        /**
+         * @inheritdoc
+         */
+        count(key: Key): number;
+        /**
+         * <p> Get an element </p>
+         *
+         * <p> Returns a reference to the mapped value of the element identified with <i>key</i>. </p>
+         *
+         * @param key Key value of the element whose mapped value is accessed.
+         *
+         * @throw exception out of range
+         *
+         * @return A reference object of the mapped value (_Ty)
+         */
+        get(key: Key): T;
+        /**
+         * <p> Set an item as the specified identifier. </p>
+         *
+         * <p>If the identifier is already in map, change value of the identifier. If not, then insert the object
+         * with the identifier. </p>
+         *
+         * @param key Key value of the element whose mapped value is accessed.
+         * @param val Value, the item.
+         */
+        set(key: Key, val: T): void;
+        /**
+         * Construct and insert element.
+         *
+         * Inserts a new element in the {@link UniqueMap} if its *key* is unique. This new element is constructed in
+         * place using args as the arguments for the construction of a *value_type* (which is an  object of a
+         * {@link Pair} type).
+         *
+         * The insertion only takes place if no other element in the container has a *key equivalent* to the one
+         * being emplaced (*keys* in a {@link UniqueMap} container are unique).
+         *
+         * If inserted, this effectively increases the container {@link size} by one.
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
+         * container.
+         *
+         * @param key The key used both to look up and to insert if not found.
+         * @param value Value, the item.
+         *
+         * @return If the function successfully inserts the element (because no equivalent element existed already in
+         *		   the {@link UniqueMap}), the function returns a {@link Pair} of an {@link MapIterator iterator} to
+         *		   the newly inserted element and a value of true. Otherwise, it returns an
+         *		   {@link MapIterator iterator} to the equivalent element within the container and a value of false.
+         */
+        emplace(key: Key, value: T): Pair<MapIterator<Key, T>, boolean>;
+        /**
+         * Construct and insert element.
+         *
+         * Inserts a new element in the {@link UniqueMap} if its *key* is unique. This new element is constructed in
+         * place using args as the arguments for the construction of a *value_type* (which is an  object of a
+         * {@link Pair} type).
+         *
+         * The insertion only takes place if no other element in the container has a *key equivalent* to the one
+         * being emplaced (*keys* in a {@link UniqueMap} container are unique).
+         *
+         * If inserted, this effectively increases the container {@link size} by one.
+         *
+         * A similar member function exists, {@link insert}, which either copies or moves existing objects into the
+         * container.
+         *
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         *
+         * @return If the function successfully inserts the element (because no equivalent element existed already in
+         *		   the {@link UniqueMap}), the function returns a {@link Pair} of an {@link MapIterator iterator} to
+         *		   the newly inserted element and a value of true. Otherwise, it returns an
+         *		   {@link MapIterator iterator} to the equivalent element within the container and a value of false.
+         */
+        emplace(pair: Pair<Key, T>): Pair<MapIterator<Key, T>, boolean>;
+        /**
+         * <p> Insert an element. </p>
+         *
+         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
+         * one. </p>
+         *
+         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
+         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
+         * if so, the element is not inserted, returning an iterator to this existing element (if the function
+         * returns a value). </p>
+         *
+         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
+         *
+         * @param pair A single argument of a {@link Pair} type with a value for the *key* as
+         *			   {@link Pair.first first} member, and a *value* for the mapped value as
+         *			   {@link Pair.second second}.
+         *
+         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
+         *		   inserted element or to the element with an equivalent key in the {@link UniqueMap}. The
+         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
+         *		   false if an equivalent key already existed.
+         */
+        insert(pair: Pair<Key, T>): Pair<MapIterator<Key, T>, boolean>;
+        /**
+         * <p> Insert an element. </p>
+         *
+         * <p> Extends the container by inserting a new element, effectively increasing the container size by the
+         * number of elements inserted. </p>
+         *
+         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
+         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
+         * if so, the element is not inserted, returning an iterator to this existing element (if the function
+         * returns a value). </p>
+         *
+         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
+         *
+         * @param tuple Tuple represensts the {@link Pair} to be inserted as an element.
+         *
+         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
+         *		   inserted element or to the element with an equivalent key in the {@link UniqueMap}. The
+         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
+         *		   false if an equivalent key already existed.
+         */
+        insert<L extends Key, U extends T>(tuple: [L, U]): Pair<MapIterator<Key, T>, boolean>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: MapReverseIterator<Key, T>, pair: Pair<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert<L extends Key, U extends T>(hint: MapIterator<Key, T>, tuple: [L, U]): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert<L extends Key, U extends T>(hint: MapReverseIterator<Key, T>, tuple: [L, U]): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        insert<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * <p> Insert or assign an element. </p>
+         *
+         * <p> Inserts an element or assigns to the current element if the <i>key</i> already exists. </p>
+         *
+         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
+         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
+         * if so, the element is assigned, returning an iterator to this existing element (if the function returns a
+         * value). </p>
+         *
+         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
+         *
+         * @param key The key used both to look up and to insert if not found.
+         * @param value Value, the item.
+         *
+         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
+         *		   inserted element or to the element with an equivalent key in the {@link UniqueMap}. The
+         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
+         *		   false if an equivalent key already existed so the <i>value</i> is assigned.
+         */
+        insert_or_assign(key: Key, value: T): Pair<MapIterator<Key, T>, boolean>;
+        /**
+         * <p> Insert or assign an element. </p>
+         *
+         * <p> Inserts an element or assigns to the current element if the <i>key</i> already exists. </p>
+         *
+         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
+         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
+         * if so, the element is assigned, returning an iterator to this existing element (if the function returns a
+         * value). </p>
+         *
+         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param key The key used both to look up and to insert if not found.
+         * @param value Value, the item.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link UniqueMap}.
+         */
+        insert_or_assign(hint: MapIterator<Key, T>, key: Key, value: T): MapIterator<Key, T>;
+        /**
+         * <p> Insert or assign an element. </p>
+         *
+         * <p> Inserts an element or assigns to the current element if the <i>key</i> already exists. </p>
+         *
+         * <p> Because element <i>keys</i> in a {@link UniqueMap} are unique, the insertion operation checks whether
+         * each inserted element has a <i>key</i> equivalent to the one of an element already in the container, and
+         * if so, the element is assigned, returning an iterator to this existing element (if the function returns a
+         * value). </p>
+         *
+         * <p> For a similar container allowing for duplicate elements, see {@link MultiMap}. </p>
+         *
+         * @param hint Hint for the position where the element can be inserted.
+         * @param key The key used both to look up and to insert if not found.
+         * @param value Value, the item.
+         *
+         * @return An iterator pointing to either the newly inserted element or to the element that already had an
+         *		   equivalent key in the {@link UniqueMap}.
+         */
+        insert_or_assign(hint: MapReverseIterator<Key, T>, key: Key, value: T): MapReverseIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        private insert_or_assign_with_key_value(key, value);
+        /**
+         * @hidden
+         */
+        private insert_or_assign_with_hint(hint, key, value);
+        /**
+         * <p> Extract an element. </p>
+         *
+         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
+         *
+         * @param key Key value of the element whose mapped value is accessed.
+         *
+         * @return A {@link Pair} containing the value pointed to by <i>key</i>.
+         */
+        extract(key: Key): Pair<Key, T>;
+        /**
+         * <p> Extract an element. </p>
+         *
+         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
+         *
+         * @param it An iterator pointing an element to extract.
+         *
+         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
+         *		   erased. If no such element exists,returns {@link end end()}.
+         */
+        extract(it: MapIterator<Key, T>): MapIterator<Key, T>;
+        /**
+         * <p> Extract an element. </p>
+         *
+         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
+         *
+         * @param it An iterator pointing an element to extract.
+         *
+         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
+         *		   erased. If no such element exists,returns {@link end end()}.
+         */
+        extract(it: MapReverseIterator<Key, T>): MapReverseIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        private extract_by_key(key);
+        /**
+         * @hidden
+         */
+        private extract_by_iterator(it);
+        /**
+         * @hidden
+         */
+        private extract_by_reverse_iterator(it);
+        /**
+         * Merge two maps.
+         *
+         * Attempts to extract each element in *source* and insert it into this container. If there's an element in this
+         * container with key equivalent to the key of an element from *source*, tnen that element is not extracted from
+         * the *source*. Otherwise, no element with same key exists in this container, then that element will be
+         * transfered from the *source* to this container.
+         *
+         * @param source A {@link MapContainer map container} to transfer the elements from.
+         */
+        merge<L extends Key, U extends T>(source: MapContainer<L, U>): void;
+    }
+}
+declare namespace std.base {
+    /**
+     * <p> An abstract set. </p>
+     *
+     * <p> {@link SetContainer SetContainers} are containers that store elements allowing fast retrieval of
+     * individual elements based on their value. </p>
+     *
+     * <p> In an {@link SetContainer}, the value of an element is at the same time its <i>key</i>, used to uniquely
+     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link SetContainer} cannot be modified
+     * once in the container - they can be inserted and removed, though. </p>
+     *
+     * <p> {@link SetContainer} stores elements, keeps sequence and enables indexing by inserting elements into a
+     * {@link List} and registering {@link ListIterator iterators} of the {@link data_ list container} to an index
+     * table like {@link RBTree tree} or {@link HashBuckets hash-table}. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     *
+     *	<dt> Unique keys </dt>
+     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements. Each element in a {@link SetContainer} container is also identified
+     *			  by this value (each value is itself also the element's <i>key</i>).
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class UniqueSet<T> extends SetContainer<T> {
+        /**
+         * @inheritdoc
+         */
+        count(key: T): number;
+        /**
+         * <p> Insert an element. </p>
+         *
+         * <p> Extends the container by inserting new elements, effectively increasing the container {@link size} by
+         * the number of element inserted (zero or one). </p>
+         *
+         * <p> Because elements in a {@link UniqueSet UniqueSets} are unique, the insertion operation checks whether
+         * each inserted element is equivalent to an element already in the container, and if so, the element is not
+         * inserted, returning an iterator to this existing element (if the function returns a value). </p>
+         *
+         * <p> For a similar container allowing for duplicate elements, see {@link MultiSet}. </p>
+         *
+         * @param key Value to be inserted as an element.
+         *
+         * @return A {@link Pair}, with its member {@link Pair.first} set to an iterator pointing to either the newly
+         *		   inserted element or to the equivalent element already in the {@link UniqueSet}. The
+         *		   {@link Pair.second} element in the {@link Pair} is set to true if a new element was inserted or
+         *		   false if an equivalent element already existed.
+         */
+        insert(val: T): Pair<SetIterator<T>, boolean>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert(hint: SetReverseIterator<T>, val: T): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * <p> Extract an element. </p>
+         *
+         * <p> Extracts the element pointed to by <i>val</i> and erases it from the {@link UniqueSet}. </p>
+         *
+         * @param val Value to be extracted.
+         *
+         * @return A value.
+         */
+        extract(val: T): T;
+        /**
+         * <p> Extract an element. </p>
+         *
+         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
+         *
+         * @param it An iterator pointing an element to extract.
+         *
+         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
+         *		   erased. If no such element exists,returns {@link end end()}.
+         */
+        extract(it: SetIterator<T>): SetIterator<T>;
+        /**
+         * <p> Extract an element. </p>
+         *
+         * <p> Extracts the element pointed to by <i>key</i> and erases it from the {@link UniqueMap}. </p>
+         *
+         * @param it An iterator pointing an element to extract.
+         *
+         * @return An iterator pointing to the element immediately following <i>it</i> prior to the element being
+         *		   erased. If no such element exists,returns {@link end end()}.
+         */
+        extract(it: SetReverseIterator<T>): SetReverseIterator<T>;
+        /**
+         * @hidden
+         */
+        private extract_by_key(val);
+        /**
+         * @hidden
+         */
+        private extract_by_iterator(it);
+        /**
+         * @hidden
+         */
+        private extract_by_reverse_iterator(it);
+        /**
+         * Merge two sets.
+         *
+         * Attempts to extract each element in *source* and insert it into this container. If there's an element in this
+         * container with key equivalent to the key of an element from *source*, tnen that element is not extracted from
+         * the *source*. Otherwise, no element with same key exists in this container, then that element will be
+         * transfered from the *source* to this container.
+         *
+         * @param source A {@link SetContainer set container} to transfer the elements from.
+         */
+        merge<U extends T>(source: SetContainer<U>): void;
+    }
+}
 declare namespace std.base {
     /**
      * <p> A node in an XTree. </p>
@@ -12076,14 +7256,4903 @@ declare namespace std.base {
         /**
          * Get grand-parent.
          */
-        grand_parent: XTreeNode<T>;
+        readonly grand_parent: XTreeNode<T>;
         /**
          * Get sibling, opposite side node in same parent.
          */
-        sibling: XTreeNode<T>;
+        readonly sibling: XTreeNode<T>;
         /**
          * Get uncle, parent's sibling.
          */
-        uncle: XTreeNode<T>;
+        readonly uncle: XTreeNode<T>;
     }
 }
+declare namespace std.Deque {
+    type iterator<T> = std.DequeIterator<T>;
+    type reverse_iterator<T> = std.DequeReverseIterator<T>;
+}
+declare namespace std {
+    /**
+     * <p> Double ended queue. </p>
+     *
+     * <p> {@link Deque} (usually pronounced like "<i>deck</i>") is an irregular acronym of
+     * <b>d</b>ouble-<b>e</b>nded <b>q</b>ueue. Double-ended queues are sequence containers with dynamic sizes that can be
+     * expanded or contracted on both ends (either its front or its back). </p>
+     *
+     * <p> Specific libraries may implement deques in different ways, generally as some form of dynamic array. But in any
+     * case, they allow for the individual elements to be accessed directly through random access iterators, with storage
+     * handled automatically by expanding and contracting the container as needed. </p>
+     *
+     * <p> Therefore, they provide a functionality similar to vectors, but with efficient insertion and deletion of
+     * elements also at the beginning of the sequence, and not only at its end. But, unlike {@link Vector Vectors},
+     * {@link Deque Deques} are not guaranteed to store all its elements in contiguous storage locations: accessing
+     * elements in a <u>deque</u> by offsetting a pointer to another element causes undefined behavior. </p>
+     *
+     * <p> Both {@link Vector}s and {@link Deque}s provide a very similar interface and can be used for similar purposes,
+     * but internally both work in quite different ways: While {@link Vector}s use a single array that needs to be
+     * occasionally reallocated for growth, the elements of a {@link Deque} can be scattered in different chunks of
+     * storage, with the container keeping the necessary information internally to provide direct access to any of its
+     * elements in constant time and with a uniform sequential interface (through iterators). Therefore,
+     * {@link Deque Deques} are a little more complex internally than {@link Vector}s, but this allows them to grow more
+     * efficiently under certain circumstances, especially with very long sequences, where reallocations become more
+     * expensive. </p>
+     *
+     * <p> For operations that involve frequent insertion or removals of elements at positions other than the beginning or
+     * the end, {@link Deque Deques} perform worse and have less consistent iterators and references than
+     * {@link List Lists}. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /> </a>
+     * </p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Sequence </dt>
+     *	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements
+     *		 are accessed by their position in this sequence. </dd>
+     *
+     *	<dt> Dynamic array </dt>
+     *	<dd> Generally implemented as a dynamic array, it allows direct access to any element in the
+     *		 sequence and provides relatively fast addition/removal of elements at the beginning or the end
+     *		 of the sequence. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @reference http://www.cplusplus.com/reference/deque/deque/
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class Deque<T> extends base.Container<T> implements base.IArrayContainer<T>, base.IDequeContainer<T> {
+        /**
+         * @hidden
+         */
+        private static readonly ROW;
+        /**
+         * @hidden
+         */
+        private static readonly MIN_CAPACITY;
+        /**
+         * @hidden
+         */
+        private matrix_;
+        /**
+         * @hidden
+         */
+        private size_;
+        /**
+         * @hidden
+         */
+        private capacity_;
+        /**
+         * @hidden
+         */
+        private get_col_size();
+        /**
+         * <p> Default Constructor. </p>
+         *
+         * <p> Constructs an empty container, with no elements. </p>
+         */
+        constructor();
+        /**
+         * <p> Initializer list Constructor. </p>
+         *
+         * <p> Constructs a container with a copy of each of the elements in <i>array</i>, in the same order. </p>
+         *
+         * @param array An array containing elements to be copied and contained.
+         */
+        constructor(items: Array<T>);
+        /**
+         * <p> Fill Constructor. </p>
+         *
+         * <p> Constructs a container with <i>n</i> elements. Each element is a copy of <i>val</i> (if provided). </p>
+         *
+         * @param n Initial container size (i.e., the number of elements in the container at construction).
+         * @param val Value to fill the container with. Each of the <i>n</i> elements in the container is
+         *			  initialized to a copy of this value.
+         */
+        constructor(size: number, val: T);
+        /**
+         * <p> Copy Constructor. </p>
+         *
+         * <p> Constructs a container with a copy of each of the elements in <i>container</i>, in the same order. </p>
+         *
+         * @param container Another container object of the same type (with the same class template
+         *					arguments <i>T</i>), whose contents are either copied or acquired.
+         */
+        constructor(container: Deque<T>);
+        /**
+         * <p> Range Constructor. </p>
+         *
+         * <p> Constructs a container with as many elements as the range (<i>begin</i>, <i>end<i>), with each
+         * element emplace-constructed from its corresponding element in that range, in the same order. </p>
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * @inheritdoc
+         */
+        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        assign(n: number, val: T): void;
+        /**
+         * @inheritdoc
+         */
+        reserve(capacity: number): void;
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        begin(): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): DequeReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): DequeReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        size(): number;
+        /**
+         * @inheritdoc
+         */
+        empty(): boolean;
+        /**
+         * @inheritdoc
+         */
+        capacity(): number;
+        /**
+         * @inheritdoc
+         */
+        at(index: number): T;
+        /**
+         * @inheritdoc
+         */
+        set(index: number, val: T): void;
+        /**
+         * @inheritdoc
+         */
+        front(): T;
+        /**
+         * @inheritdoc
+         */
+        back(): T;
+        /**
+        // Fetch row and column's index.
+        /**
+         * @hidden
+         */
+        private fetch_index(index);
+        /**
+         * @inheritdoc
+         */
+        push(...items: T[]): number;
+        /**
+         * @inheritdoc
+         */
+        push_front(val: T): void;
+        /**
+         * @inheritdoc
+         */
+        push_back(val: T): void;
+        /**
+         * @inheritdoc
+         */
+        pop_front(): void;
+        /**
+         * @inheritdoc
+         */
+        pop_back(): void;
+        /**
+         * @inheritdoc
+         */
+        insert(position: DequeIterator<T>, val: T): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert(position: DequeIterator<T>, n: number, val: T): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(position: DequeIterator<T>, begin: InputIterator, end: InputIterator): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert(position: DequeReverseIterator<T>, val: T): DequeReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert(position: DequeReverseIterator<T>, n: number, val: T): DequeReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(position: DequeReverseIterator<T>, begin: InputIterator, end: InputIterator): DequeReverseIterator<T>;
+        /**
+         * @hidden
+         */
+        private insert_by_val(position, val);
+        /**
+         * @hidden
+         */
+        protected _Insert_by_repeating_val(position: DequeIterator<T>, n: number, val: T): DequeIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(position: DequeIterator<T>, begin: InputIterator, end: InputIterator): DequeIterator<T>;
+        /**
+         * @hidden
+         */
+        private insert_by_items(position, items);
+        /**
+         * @inheritdoc
+         */
+        erase(position: DequeIterator<T>): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        erase(first: DequeIterator<T>, last: DequeIterator<T>): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        erase(position: DequeReverseIterator<T>): DequeReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        erase(first: DequeReverseIterator<T>, last: DequeReverseIterator<T>): DequeReverseIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Erase_by_range(first: DequeIterator<T>, last: DequeIterator<T>): DequeIterator<T>;
+        /**
+         * <p> Swap content. </p>
+         *
+         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link Deque container} object with same type of elements. Sizes and container type may differ. </p>
+         *
+         * <p> After the call to this member function, the elements in this container are those which were in <i>obj</i>
+         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
+         * pointers remain valid for the swapped objects. </p>
+         *
+         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function. </p>
+         *
+         * @param obj Another {@link Deque container} of the same type of elements (i.e., instantiated
+         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
+         *			  {@link container Deque}.
+         */
+        swap(obj: Deque<T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.IContainer<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * <p> An iterator of {@link Deque}. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /> </a>
+     * </p>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class DequeIterator<T> extends Iterator<T> implements base.IArrayIterator<T> {
+        /**
+         * Sequence number of iterator in the source {@link Deque}.
+         */
+        private index_;
+        /**
+         * <p> Construct from the source {@link Deque container}. </p>
+         *
+         * <h4> Note </h4>
+         * <p> Do not create the iterator directly, by yourself. </p>
+         * <p> Use {@link Deque.begin begin()}, {@link Deque.end end()} in {@link Deque container} instead. </p>
+         *
+         * @param source The source {@link Deque container} to reference.
+         * @param index Sequence number of the element in the source {@link Deque}.
+         */
+        constructor(source: Deque<T>, index: number);
+        /**
+         * @hidden
+         */
+        private readonly deque;
+        /**
+         * @inheritdoc
+         */
+        /**
+         * Set value of the iterator is pointing to.
+         *
+         * @param val Value to set.
+         */
+        value: T;
+        /**
+         * @inheritdoc
+         */
+        readonly index: number;
+        /**
+         * @inheritdoc
+         */
+        prev(): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        next(): DequeIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        advance(n: number): DequeIterator<T>;
+        /**
+         * <p> Whether an iterator is equal with the iterator. </p>
+         *
+         * <p> Compare two iterators and returns whether they are equal or not. </p>
+         *
+         * <h4> Note </h4>
+         * <p> Iterator's equal_to() only compare souce container and index number. </p>
+         *
+         * <p> Although elements in a pair, key and value are equal_to, if the source map or
+         * index number is different, then the {@link equal_to equal_to()} will return false. If you want to
+         * compare the elements of a pair, compare them directly by yourself. </p>
+         *
+         * @param obj An iterator to compare
+         * @return Indicates whether equal or not.
+         */
+        equal_to<U extends T>(obj: DequeIterator<U>): boolean;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: DequeIterator<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * <p> A reverse-iterator of Deque. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /> </a>
+     * </p>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class DequeReverseIterator<T> extends ReverseIterator<T, DequeIterator<T>, DequeReverseIterator<T>> implements base.IArrayIterator<T> {
+        /**
+         * Construct from base iterator.
+         *
+         * @param base A reference of the base iterator, which iterates in the opposite direction.
+         */
+        constructor(base: DequeIterator<T>);
+        /**
+         * @hidden
+         */
+        protected create_neighbor(base: DequeIterator<T>): DequeReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        /**
+         * Set value of the iterator is pointing to.
+         *
+         * @param val Value to set.
+         */
+        value: T;
+        /**
+         * Get index.
+         */
+        readonly index: number;
+    }
+}
+declare namespace std {
+    /**
+     * <p> Function handling termination on exception </p>
+     *
+     * <p> Calls the current terminate handler. </p>
+     *
+     * <p> By default, the terminate handler calls abort. But this behavior can be redefined by calling
+     * {@link set_terminate}. </p>
+     *
+     * <p> This function is automatically called when no <code>catch</code> handler can be found for a thrown exception,
+     * or for some other exceptional circumstance that makes impossible to continue the exception handling process. </p>
+     *
+     * <p> This function is provided so that the terminate handler can be explicitly called by a program that needs to
+     * abnormally terminate, and works even if {@link set_terminate} has not been used to set a custom terminate handler
+     * (calling abort in this case). </p>
+     */
+    function terminate(): void;
+    /**
+     * <p> Set <i>terminate handler</i> function. </p>
+     *
+     * <p> A <i>terminate handler</i> function is a function automatically called when the exception handling process has
+     * to be abandoned for some reason. This happens when no catch handler can be found for a thrown exception, or for
+     * some other exceptional circumstance that makes impossible to continue the exception handling process. </p>
+     *
+     * <p> Before this function is called by the program for the first time, the default behavior is to call abort. </p>
+     *
+     * <p> A program may explicitly call the current terminate handler function by calling {@link terminate}. </p>
+     *
+     * @param f Function that takes no parameters and returns no value (<i>void</i>).
+     */
+    function set_terminate(f: () => void): void;
+    /**
+     * <p> Get <i>terminate handler</i> function. </p>
+     *
+     * <p> The <i>terminate handler</i> function is automatically called when no <code>catch</code> handler can be found
+     * for a thrown exception, or for some other exceptional circumstance that makes impossible to continue the exception
+     * handling process. </p>
+     *
+     * <p> If no such function has been set by a previous call to {@link set_terminate}, the function returns a
+     * <i>null-pointer</i>. </p>
+     *
+     * @return If {@link set_terminate} has previously been called by the program, the function returns the current
+     *		   <i>terminate handler</i> function. Otherwise, it returns a <i>null-pointer</i>.
+     */
+    function get_terminate(): () => void;
+    /**
+     * <p> Standard exception class. </p>
+     *
+     * <p> Base class for standard exceptions. </p>
+     *
+     * <p> All objects thrown by components of the standard library are derived from this class.
+     * Therefore, all standard exceptions can be caught by catching this type by reference. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
+     *
+     * @reference http://www.cplusplus.com/reference/exception/exception
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class Exception extends Error {
+        /**
+         * A message representing specification about the Exception.
+         */
+        private description;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * <p> Construct from a message. </p>
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+        /**
+         * <p> Get string identifying exception. </p>
+         * <p> Returns a string that may be used to identify the exception. </p>
+         *
+         * <p> The particular representation pointed by the returned value is implementation-defined.
+         * As a virtual function, derived classes may redefine this function so that specify value are
+         * returned. </p>
+         */
+        what(): string;
+        /**
+         * @inheritdoc
+         */
+        readonly message: string;
+        /**
+         * @inheritdoc
+         */
+        readonly name: string;
+    }
+    /**
+     * <p> Logic error exception. </p>
+     *
+     * <p> This class defines the type of objects thrown as exceptions to report errors in the internal
+     * logical of the program, such as violation of logical preconditions or class invariants. </p>
+     *
+     * <p> These errors are presumably detectable before the program executes. </p>
+     *
+     * <p> It is used as a base class for several logical error exceptions. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/logic_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class LogicError extends Exception {
+        /**
+         * <p> Construct from a message. </p>
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * <p> Domain error exception. </p>
+     *
+     * <p> This class defines the type of objects thrown as exceptions to report domain errors. </p>
+     *
+     * <p> Generally, the domain of a mathematical function is the subset of values that it is defined for.
+     * For example, the square root function is only defined for non-negative numbers. Thus, a negative number
+     * for such a function would qualify as a domain error. </p>
+     *
+     * <p> No component of the standard library throws exceptions of this type. It is designed as a standard
+     * exception to be thrown by programs. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a></p>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/domain_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class DomainError extends LogicError {
+        /**
+         * <p> Construct from a message. </p>
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * <p> Invalid argument exception. </p>
+     *
+     * <p> This class defines the type of objects thrown as exceptions to report an invalid argument. </p>
+     *
+     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library
+     * also throw exceptions of this type to signal invalid arguments. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/invalid_argument
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class InvalidArgument extends LogicError {
+        /**
+         * <p> Construct from a message. </p>
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * <p> Length error exception. </p>
+     *
+     * <p> This class defines the type of objects thrown as exceptions to report a length error. </p>
+     *
+     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library,
+     * such as vector and string also throw exceptions of this type to signal errors resizing. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/length_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class LengthError extends LogicError {
+        /**
+         * <p> Construct from a message. </p>
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * <p> Out-of-range exception. </p>
+     *
+     * <p> This class defines the type of objects thrown as exceptions to report an out-of-range error. </p>
+     *
+     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library,
+     * such as vector, deque, string and bitset also throw exceptions of this type to signal arguments
+     * out of range. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/out_of_range
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class OutOfRange extends LogicError {
+        /**
+         * <p> Construct from a message. </p>
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * <p> Runtime error exception. </p>
+     *
+     * <p> This class defines the type of objects thrown as exceptions to report errors that can only be
+     * detected during runtime. </p>
+     *
+     * <p> It is used as a base class for several runtime error exceptions. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/runtime_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class RuntimeError extends Exception {
+        /**
+         * <p> Construct from a message. </p>
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * <p> Overflow error exception. </p>
+     *
+     * <p> This class defines the type of objects thrown as exceptions to arithmetic overflow errors. </p>
+     *
+     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library
+     * also throw exceptions of this type to signal range errors. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/overflow_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class OverflowError extends RuntimeError {
+        /**
+         * <p> Construct from a message. </p>
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * <p> Underflow error exception. </p>
+     *
+     * <p> This class defines the type of objects thrown as exceptions to arithmetic underflow errors. </p>
+     *
+     * <p> No component of the standard library throws exceptions of this type. It is designed as a standard
+     * exception to be thrown by programs. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/underflow_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class UnderflowError extends RuntimeError {
+        /**
+         * <p> Construct from a message. </p>
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+    /**
+     * <p> Range error exception. </p>
+     *
+     * <p> This class defines the type of objects thrown as exceptions to report range errors in internal
+     * computations. </p>
+     *
+     * <p> It is a standard exception that can be thrown by programs. Some components of the standard library
+     * also throw exceptions of this type to signal range errors. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
+     *
+     * @reference http://www.cplusplus.com/reference/stdexcept/range_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class RangeError extends RuntimeError {
+        /**
+         * <p> Construct from a message. </p>
+         *
+         * @param message A message representing specification about the Exception.
+         */
+        constructor(message: string);
+    }
+}
+declare namespace std {
+    /**
+     * <p> Function object class for equality comparison. </p>
+     *
+     * <p> Binary function object class whose call returns whether its two arguments compare <i>equal</i> (as returned by
+     * operator ==). </p>
+     *
+     * <p> Generically, function objects are instances of a class with member function {@link IComparable.equal_to equal_to}
+     * defined. This member function allows the object to be used with the same syntax as a function call. </p>
+     *
+     * @param x First element to compare.
+     * @param y Second element to compare.
+     *
+     * @return Whether the arguments are equal.
+     */
+    function equal_to<T>(x: T, y: T): boolean;
+    /**
+     * <p> Function object class for non-equality comparison. </p>
+     *
+     * <p> Binary function object class whose call returns whether its two arguments compare <i>not equal</i> (as returned
+     * by operator operator!=). </p>
+     *
+     * <p> Generically, function objects are instances of a class with member function {@link IComparable.equal_to equal_to}
+     * defined. This member function allows the object to be used with the same syntax as a function call. </p>
+     *
+     * @param x First element to compare.
+     * @param y Second element to compare.
+     *
+     * @return Whether the arguments are not equal.
+     */
+    function not_equal_to<T>(x: T, y: T): boolean;
+    /**
+     * <p> Function for less-than inequality comparison. </p>
+     *
+     * <p> Binary function returns whether the its first argument compares less than the second. </p>
+     *
+     * <p> Generically, function objects are instances of a class with member function {@link IComparable.less less}
+     * defined. If an object doesn't have the method, then its own uid will be used to compare insteadly.
+     * This member function allows the object to be used with the same syntax as a function call. </p>
+     *
+     * <p> Objects of this class can be used on standard algorithms such as {@link sort sort()}</code>,
+     * {@link merge merge()} or {@link TreeMap.lower_bound lower_bound()}. </p>
+     *
+     * @param <T> Type of arguments to compare by the function call. The type shall supporrt the operation
+     *			  <i>operator<()</i> or method {@link IComparable.less less}.
+     *
+     * @param x First element, the standard of comparison.
+     * @param y Second element compare with the first.
+     *
+     * @return Whether the first parameter is less than the second.
+     */
+    function less<T>(x: T, y: T): boolean;
+    /**
+     * <p> Function object class for less-than-or-equal-to comparison. </p>
+     *
+     * <p> Binary function object class whose call returns whether the its first argument compares {@link less less than} or
+     * {@link equal_to equal to} the second (as returned by operator <=). </p>
+     *
+     * <p> Generically, <i>function objects</i> are instances of a class with member function {@link IComparable.less less}
+     * and {@link IComparable.equal_to equal_to} defined. This member function allows the object to be used with the same
+     * syntax as a function call. </p>
+     *
+     * @param x First element, the standard of comparison.
+     * @param y Second element compare with the first.
+     *
+     * @return Whether the <i>x</i> is {@link less less than} or {@link equal_to equal to} the <i>y</i>.
+     */
+    function less_equal<T>(x: T, y: T): boolean;
+    /**
+     * <p> Function for greater-than inequality comparison. </p>
+     *
+     * <p> Binary function returns whether the its first argument compares greater than the second. </p>
+     *
+     * <p> Generically, function objects are instances of a class with member function {@link less} and
+     * {@link equal_to equal_to()} defined. If an object doesn't have those methods, then its own uid will be used
+     * to compare insteadly. This member function allows the object to be used with the same syntax as a function
+     * call. </p>
+     *
+     * <p> Objects of this class can be used on standard algorithms such as {@link sort sort()},
+     * {@link merge merge()} or {@link TreeMap.lower_bound lower_bound()}. </p>
+     *
+     * @param <T> Type of arguments to compare by the function call. The type shall supporrt the operation
+     *			  <i>operator>()</i> or method {@link IComparable.greater greater}.
+     *
+     * @return Whether the <i>x</i> is greater than the <i>y</i>.
+     */
+    function greater<T>(x: T, y: T): boolean;
+    /**
+     * <p> Function object class for greater-than-or-equal-to comparison. </p>
+     *
+     * <p> Binary function object class whose call returns whether the its first argument compares
+     * {@link greater greater than} or {@link equal_to equal to} the second (as returned by operator >=). </p>
+     *
+     * <p> Generically, function objects are instances of a class with member function {@link IComparable.less less}
+     * defined. If an object doesn't have the method, then its own uid will be used to compare insteadly.
+     * This member function allows the object to be used with the same syntax as a function call. </p>
+     *
+     * @param x First element, the standard of comparison.
+     * @param y Second element compare with the first.
+     *
+     * @return Whether the <i>x</i> is {@link greater greater than} or {@link equal_to equal to} the <i>y</i>.
+     */
+    function greater_equal<T>(x: T, y: T): boolean;
+    /**
+     * <p> Logical AND function object class. </p>
+     *
+     * <p> Binary function object class whose call returns the result of the <i>logical "and"</i> operation between its two
+     * arguments (as returned by operator &&). </p>
+     *
+     * <p> Generically, function objects are instances of a class with member function operator() defined. This member
+     * function allows the object to be used with the same syntax as a function call. </p>
+     *
+     * @param x First element.
+     * @param y Second element.
+     *
+     * @return Result of logical AND operation.
+     */
+    function logical_and<T>(x: T, y: T): boolean;
+    /**
+     * <p> Logical OR function object class. </p>
+     *
+     * <p> Binary function object class whose call returns the result of the <i>logical "or"</i> operation between its two
+     * arguments (as returned by operator ||). </p>
+     *
+     * <p> Generically, function objects are instances of a class with member function operator() defined. This member
+     * function allows the object to be used with the same syntax as a function call. </p>
+     *
+     * @param x First element.
+     * @param y Second element.
+     *
+     * @return Result of logical OR operation.
+     */
+    function logical_or<T>(x: T, y: T): boolean;
+    /**
+     * <p> Logical NOT function object class. </p>
+     *
+     * <p> Unary function object class whose call returns the result of the <i>logical "not"</i> operation on its argument
+     * (as returned by operator !). </p>
+     *
+     * <p> Generically, function objects are instances of a class with member function operator() defined. This member
+     * function allows the object to be used with the same syntax as a function call. </p>
+     *
+     * @param x Target element.
+     *
+     * @return Result of logical NOT operation.
+     */
+    function logical_not<T>(x: T): boolean;
+    /**
+     * <p> Bitwise AND function object class. </p>
+     *
+     * <p> Binary function object class whose call returns the result of applying the <i>bitwise "and"</i> operation between
+     * its two arguments (as returned by operator &). </p>
+     *
+     * @param x First element.
+     * @param y Second element.
+     *
+     * @return Result of bitwise AND operation.
+     */
+    function bit_and(x: number, y: number): number;
+    /**
+     * <p> Bitwise OR function object class. </p>
+     *
+     * <p> Binary function object class whose call returns the result of applying the <i>bitwise "and"</i> operation between
+     * its two arguments (as returned by operator &). </p>
+     *
+     * @param x First element.
+     * @param y Second element.
+     *
+     * @return Result of bitwise OR operation.
+     */
+    function bit_or(x: number, y: number): number;
+    /**
+     * <p> Bitwise XOR function object class. </p>
+     *
+     * <p> Binary function object class whose call returns the result of applying the <i>bitwise "exclusive or"</i>
+     * operation between its two arguments (as returned by operator ^). </p>
+     *
+     * @param x First element.
+     * @param y Second element.
+     *
+     * @return Result of bitwise XOR operation.
+     */
+    function bit_xor(x: number, y: number): number;
+    /**
+     * <p> Comparable instance. </p>
+     *
+     * <p> {@link IComparable} is a common interface for objects who can compare each other. </p>
+     *
+     * @reference https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    interface IComparable<T> extends Object {
+        /**
+         * <p> Indicates whether some other object is &quot;equal to&quot; this one. </p>
+         *
+         * <p> The {@link equal_to} method implements an equivalence relation on non-null object references: </p>
+         *
+         * <ul>
+         *	<li>
+         *		It is <b>reflexive</b>: for any non-null reference value <code>x</code>, <code>x.equal_to(x)</code>
+         *		should return <code>true</code>.
+         *	</li>
+         *	<li>
+         *		It is <b>symmetric</b>: for any non-null reference values <code>x</code> and <code>y</code>,
+         *		<code>x.equal_to(y)</code> should return <code>true</code> if and only if <code>y.equal_to(x)</code>
+         *		returns <code>true</code>. </li>
+         *	<li>
+         *		It is <b>transitive</b>: for any non-null reference values <code>x</code>, <code>y</code>, and
+         *		<code>z</code>, if <code>x.equal_to(y)</code> returns <code>true</code> and <code>y.equal_to(z)</code>
+         *		returns <code>true</code>, then <code>x.equal_to(z)</code> should return <code>true</code>.
+         *	</li>
+         *	<li>
+         *		It is <b>consistent</b>: for any non-null reference values <code>x</code> and <code>y</code>, multiple
+         *		invocations of <code>x.equal_to(y)</code> consistently return <code>true</code> or consistently return
+         *		<code>false</code>, provided no information used in equal_to comparisons on the objects is modified.
+         *	</li>
+         *	<li>
+         *		For any non-null reference value <code>x</code>, <code>x.equal_to(null)</code> should return
+         *		<code>false</code>.
+         *	</li>
+         * </ul>
+         *
+         * <p> The {@link equal_to} method for interface {@link IComparable} implements the most discriminating possible
+         * equivalence relation on objects; that is, for any non-null reference values <code>x</code> and
+         * <code>y</code>, this method returns <code>true</code> if and only if <code>x</code> and <code>y</code>
+         * refer to the same object (<code>x == y</code> has the value <code>true</code>). </p>
+         *
+         * <p> Note that it is generally necessary to override the {@link hash_code} method whenever this method is
+         * overridden, so as to maintain the general contract for the {@link hash_code} method, which states that
+         * equal objects must have equal hash codes. </p>
+         *
+         * <ul>
+         *	<li> {@link IComparable.equal_to} is called by {@link std.equal_to}. </li>
+         * </ul>
+         *
+         * @param obj the reference object with which to compare.
+         *
+         * @return <code>true</code> if this object is the same as the obj argument; <code>false</code> otherwise.
+         */
+        equal_to(obj: T): boolean;
+        /**
+         * <p> Less-than inequality comparison. </p>
+         *
+         * <p> Binary method returns whether the the instance compares less than the <i>obj</i>. </p>
+         *
+         * <ul>
+         *	<li>
+         *		{@link IComparable.less} is called by {@link std.less}. Also, this method can be used on standard
+         *		algorithms such as {@link sort sort()}</code>, {@link merge merge()} or
+         *		{@link TreeMap.lower_bound lower_bound()}.
+         *	</li>
+         * </ul>
+         *
+         * @param obj the reference object with which to compare.
+         *
+         * @return Whether the first parameter is less than the second.
+         */
+        less(obj: T): boolean;
+        /**
+         * <p> Issue a hash code. </p>
+         *
+         * <p> Returns a hash code value for the object. This method is supported for the benefit of hash tables such
+         * as those provided by hash containers; {@link HashSet}, {@link HashMap}, {@link MultiHashSet} and
+         * {@link MultiHashMap}. </p>
+         *
+         * <p> As much as is reasonably practical, the {@link hash_code} method defined by interface
+         * {@link IComparable} does return distinct integers for distinct objects. (This is typically implemented by
+         * converting the internal address of the object into an integer, but this implementation technique is not
+         * required by the JavaScript programming language.) </p>
+         *
+         * <ul>
+         *	<li>
+         *		{@link IComparable.hash_code} is called by {@link std.hash_code}. If you want to keep basically
+         *		provided hash function, then returns {@link std.Hash.code}; <code>return std.Hash.code(this);</code>
+         *	</li>
+         * </ul>
+         *
+         * @return An hash code who represents the object.
+         */
+        hash(): number;
+    }
+    /**
+     * <p> Default hash function for number. </p>
+     *
+     * <p> Unary function that defines the default hash function used by the standard library. </p>
+     *
+     * <p> The functional call returns a hash value of its argument: A hash value is a value that depends solely on
+     * its argument, returning always the same value for the same argument (for a given execution of a program). The
+     * value returned shall have a small likelihood of being the same as the one returned for a different argument.
+     * </p>
+     *
+     * @param val Value to be hashed.
+     *
+     * @return Returns a hash value for its argument, as a value of type number. The number is an unsigned integer.
+     */
+    function hash(val: number): number;
+    /**
+     * <p> Default hash function for string. </p>
+     *
+     * <p> Unary function that defines the default hash function used by the standard library. </p>
+     *
+     * <p> The functional call returns a hash value of its argument: A hash value is a value that depends solely on
+     * its argument, returning always the same value for the same argument (for a given execution of a program). The
+     * value returned shall have a small likelihood of being the same as the one returned for a different argument.
+     * </p>
+     *
+     * @param str A string to be hashed.
+     *
+     * @return Returns a hash value for its argument, as a value of type number. The number is an unsigned integer.
+     */
+    function hash(str: string): number;
+    /**
+     * <p> Default hash function for Object. </p>
+     *
+     * <p> Unary function that defines the default hash function used by the standard library. </p>
+     *
+     * <p> The functional call returns a hash value of its argument: A hash value is a value that depends solely on
+     * its argument, returning always the same value for the same argument (for a given execution of a program). The
+     * value returned shall have a small likelihood of being the same as the one returned for a different argument.
+     * </p>
+     *
+     * <p> The default {@link hash} function of Object returns a value returned from {@link hash hash(number)} with
+     * an <b>unique id</b> of each Object. If you want to specify {@link hash} function of a specific class, then
+     * define a member function <code>public hash(): number</code> in the class. </p>
+     *
+     * @param obj Object to be hashed.
+     *
+     * @return Returns a hash value for its argument, as a value of type number. The number is an unsigned integer.
+     */
+    function hash(obj: Object): number;
+    /**
+     * <p> Exchange contents of {@link IContainers containers}. </p>
+     *
+     * <p> The contents of container <i>left</i> are exchanged with those of <i>right</i>. Both container objects must have
+     * same type of elements (same template parameters), although sizes may differ. </p>
+     *
+     * <p> After the call to this member function, the elements in <i>left</i> are those which were in <i>right</i> before
+     * the call, and the elements of <i>right</i> are those which were in <i>left</i>. All iterators, references and
+     * pointers remain valid for the swapped objects. </p>
+     *
+     * <p> This is an overload of the generic algorithm swap that improves its performance by mutually transferring
+     * ownership over their assets to the other container (i.e., the containers exchange references to their data, without
+     * actually performing any element copy or movement): It behaves as if <i>left</i>.
+     * {@link IContainer.swap swap}(<i>right</i>) was called. </p>
+     *
+     * @param left A {@link IContainer container} to swap its contents.
+     * @param right A {@link IContainer container} to swap its contents.
+     */
+    function swap<T>(left: base.IContainer<T>, right: base.IContainer<T>): void;
+    /**
+     * <p> Exchange contents of queues. </p>
+     *
+     * <p> Exchanges the contents of <i>left</i> and <i>right</i>. </p>
+     *
+     * @param left A {@link Queue} container of the same type. Size may differ.
+     * @param right A {@link Queue} container of the same type. Size may differ.
+     */
+    function swap<T>(left: Queue<T>, right: Queue<T>): void;
+    /**
+     * <p> Exchange contents of {@link PriorityQueue PriorityQueues}. </p>
+     *
+     * <p> Exchanges the contents of <i>left</i> and <i>right</i>. </p>
+     *
+     * @param left A {@link PriorityQueue} container of the same type. Size may differ.
+     * @param right A {@link PriorityQueue} container of the same type. Size may differ.
+     */
+    function swap<T>(left: PriorityQueue<T>, right: PriorityQueue<T>): void;
+    /**
+     * <p> Exchange contents of {@link Stack Stacks}. </p>
+     *
+     * <p> Exchanges the contents of <i>left</i> and <i>right</i>. </p>
+     *
+     * @param left A {@link Stack} container of the same type. Size may differ.
+     * @param right A {@link Stack} container of the same type. Size may differ.
+     */
+    function swap<T>(left: Stack<T>, right: Stack<T>): void;
+    /**
+     * <p> Exchanges the contents of two {@link UniqueMap unique maps}. </p>
+     *
+     * <p> The contents of container <i>left</i> are exchanged with those of <i>right</i>. Both container objects must
+     * be of the same type (same template parameters), although sizes may differ. </p>
+     *
+     * <p> After the call to this member function, the elements in <i>left</i> are those which were in <i>right</i>
+     * before the call, and the elements of <i>right</i> are those which were in <i>left</i>. All iterators, references
+     * and pointers remain valid for the swapped objects. </p>
+     *
+     * <p> This is an overload of the generic algorithm swap that improves its performance by mutually transferring
+     * ownership over their assets to the other container (i.e., the containers exchange references to their data,
+     * without actually performing any element copy or movement): It behaves as if
+     * <i>left</i>.{@link UniqueMap.swap swap}(<i>right</i>) was called. </p>
+     *
+     * @param left An {@link UniqueMap unique map} to swap its conents.
+     * @param right An {@link UniqueMap unique map} to swap its conents.
+     */
+    function swap<Key, T>(left: base.UniqueMap<Key, T>, right: base.UniqueMap<Key, T>): void;
+    /**
+     * <p> Exchanges the contents of two {@link MultiMap multi maps}. </p>
+     *
+     * <p> The contents of container <i>left</i> are exchanged with those of <i>right</i>. Both container objects must
+     * be of the same type (same template parameters), although sizes may differ. </p>
+     *
+     * <p> After the call to this member function, the elements in <i>left</i> are those which were in <i>right</i>
+     * before the call, and the elements of <i>right</i> are those which were in <i>left</i>. All iterators, references
+     * and pointers remain valid for the swapped objects. </p>
+     *
+     * <p> This is an overload of the generic algorithm swap that improves its performance by mutually transferring
+     * ownership over their assets to the other container (i.e., the containers exchange references to their data,
+     * without actually performing any element copy or movement): It behaves as if
+     * <i>left</i>.{@link MultiMap.swap swap}(<i>right</i>) was called. </p>
+     *
+     * @param left A {@link MultiMap multi map} to swap its conents.
+     * @param right A {@link MultiMap multi map} to swap its conents.
+     */
+    function swap<Key, T>(left: base.MultiMap<Key, T>, right: base.MultiMap<Key, T>): void;
+}
+declare namespace std {
+    /**
+     * <p> Bind function arguments. </p>
+     *
+     * <p> Returns a function object based on <i>fn</i>, but with its arguments bound to <i>args</i>. </p>
+     *
+     * <p> Each argument may either be bound to a value or be a {@link placeholders placeholder}: </p>
+     * <ul>
+     *	<li> If bound to a value, calling the returned function object will always use that value as argument. </li>
+     *	<li>
+     *		If a {@link placeholders placeholder}, calling the returned function object forwards an argument passed to the
+     *		call (the one whose order number is specified by the placeholder).
+     *	</li>
+     * </ul>
+     *
+     * <p> Calling the returned object returns the same type as fn. </p>
+     *
+     * @param fn A function object, pointer to function or pointer to member.
+     * @param args List of arguments to bind: either values, or {@link placeholders}.
+     *
+     * @return A function object that, when called, calls <i>fn</i> with its arguments bound to <i>args</i>. If <i>fn</i> is
+     *		   a pointer to member, the first argument expected by the returned function is an object of the class <i>fn</i>
+     *		   is a member.
+     */
+    function bind<Ret>(fn: (...args: any[]) => Ret, ...args: any[]): (...args: any[]) => Ret;
+    /**
+     * <p> Bind function arguments. </p>
+     *
+     * <p> Returns a function object based on <i>fn</i>, but with its arguments bound to <i>args</i>. </p>
+     *
+     * <p> Each argument may either be bound to a value or be a {@link placeholders placeholder}: </p>
+     * <ul>
+     *	<li> If bound to a value, calling the returned function object will always use that value as argument. </li>
+     *	<li>
+     *		If a {@link placeholders placeholder}, calling the returned function object forwards an argument passed to the
+     *		call (the one whose order number is specified by the placeholder).
+     *	</li>
+     * </ul>
+     *
+     * <p> Calling the returned object returns the same type as fn. </p>
+     *
+     * @param fn A function object, pointer to function or pointer to member.
+     * @param thisArg This argument, owner object of the member method <i>fn</i>.
+     * @param args List of arguments to bind: either values, or {@link placeholders}.
+     *
+     * @return A function object that, when called, calls <i>fn</i> with its arguments bound to <i>args</i>. If <i>fn</i> is
+     *		   a pointer to member, the first argument expected by the returned function is an object of the class <i>fn</i>
+     *		   is a member.
+     */
+    function bind<Ret, T>(fn: (...args: any[]) => Ret, thisArg: T, ...args: any[]): (...args: any[]) => Ret;
+}
+/**
+ * <p> Bind argument placeholders. </p>
+ *
+ * <p> This namespace declares an unspecified number of objects: <i>_1</i>, <i>_2</i>, <i>_3</i>, ...</i>, which are
+ * used to specify placeholders in calls to function {@link std.bind}. </p>
+ *
+ * <p> When the function object returned by bind is called, an argument with placeholder {@link _1} is replaced by the
+ * first argument in the call, {@link _2} is replaced by the second argument in the call, and so on... For example: </p>
+ *
+ * <code>
+ * let vec: Vector<number> = new Vector<number>();
+ *
+ * let bind = std.bind(Vector.insert, _1, vec.end(), _2, _3);
+ * bind.apply(vec, 5, 1); // vec.insert(vec.end(), 5, 1);
+ * // [1, 1, 1, 1, 1]
+ * </code>
+ *
+ * <p> When a call to {@link bind} is used as a subexpression in another call to <i>bind</i>, the {@link placeholders}
+ * are relative to the outermost {@link bind} expression. </p>
+ *
+ * @reference http://www.cplusplus.com/reference/functional/placeholders/
+ * @author Jeongho Nam <http://samchon.org>
+ */
+declare namespace std.placeholders {
+    /**
+     * @hidden
+     */
+    class PlaceHolder {
+        private index_;
+        constructor(index: number);
+        readonly index: number;
+    }
+    /**
+     * Replaced by the first argument in the function call.
+     */
+    const _1: PlaceHolder;
+    /**
+     * Replaced by the second argument in the function call.
+     */
+    const _2: PlaceHolder;
+    /**
+     * Replaced by the third argument in the function call.
+     */
+    const _3: PlaceHolder;
+    const _4: PlaceHolder;
+    const _5: PlaceHolder;
+    const _6: PlaceHolder;
+    const _7: PlaceHolder;
+    const _8: PlaceHolder;
+    const _9: PlaceHolder;
+    const _10: PlaceHolder;
+    const _11: PlaceHolder;
+    const _12: PlaceHolder;
+    const _13: PlaceHolder;
+    const _14: PlaceHolder;
+    const _15: PlaceHolder;
+    const _16: PlaceHolder;
+    const _17: PlaceHolder;
+    const _18: PlaceHolder;
+    const _19: PlaceHolder;
+    const _20: PlaceHolder;
+}
+declare namespace std.HashMap {
+    type iterator<Key, T> = std.MapIterator<Key, T>;
+    type reverse_iterator<Key, T> = std.MapReverseIterator<Key, T>;
+}
+declare namespace std {
+    /**
+     * <p> Hashed, unordered map. </p>
+     *
+     * <p> {@link HashMap}s are associative containers that store elements formed by the combination of a <i>key value</i>
+     * and a <i>mapped value</i>, and which allows for fast retrieval of individual elements based on their <i>keys</i>.
+     * </p>
+     *
+     * <p> In an {@link HashMap}, the <i>key value</i> is generally used to uniquely identify the element, while the
+     * <i>mapped value</i> is an object with the content associated to this <i>key</i>. Types of <i>key</i> and
+     * <i>mapped value</i> may differ. </p>
+     *
+     * <p> Internally, the elements in the {@link HashMap} are not sorted in any particular order with respect to either
+     * their <i>key</i> or <i>mapped values</i>, but organized into <i>buckets</i> depending on their hash values to allow
+     * for fast access to individual elements directly by their <i>key values</i> (with a constant average time complexity
+     * on average). </p>
+     *
+     * <p> {@link HashMap} containers are faster than {@link TreeMap} containers to access individual elements by their
+     * <i>key</i>, although they are generally less efficient for range iteration through a subset of their elements. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a>
+     * </p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     * 	<dt> Associative </dt>
+     * 	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		 position in the container. </dd>
+     *
+     * 	<dt> Hashed </dt>
+     * 	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
+     *		 by their <i>key</i>. </dd>
+     *
+     * 	<dt> Map </dt>
+     * 	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
+     *
+     * 	<dt> Unique keys </dt>
+     * 	<dd> No two elements in the container can have equivalent keys. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the key values.
+     *				Each element in an {@link HashMap} is uniquely identified by its key value.
+     * @param <T> Type of the mapped value.
+     *			  Each element in an {@link HashMap} is used to store some data as its mapped value.
+     *
+     * @reference http://www.cplusplus.com/reference/unordered_map/unordered_map
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class HashMap<Key, T> extends base.UniqueMap<Key, T> implements base.IHashMap<Key, T> {
+        /**
+         * @hidden
+         */
+        private hash_buckets_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from elements.
+         */
+        constructor(items: Pair<Key, T>[]);
+        /**
+         * Contruct from tuples.
+         *
+         * @param array Tuples to be contained.
+         */
+        constructor(array: [Key, T][]);
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: HashMap<Key, T>);
+        /**
+         * Construct from range iterators.
+         */
+        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        begin(): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        begin(index: number): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        end(): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        end(index: number): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(index: number): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rend(index: number): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        bucket_count(): number;
+        /**
+         * @inheritdoc
+         */
+        bucket_size(index: number): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(z: number): void;
+        /**
+         * @inheritdoc
+         */
+        bucket(key: Key): number;
+        /**
+         * @inheritdoc
+         */
+        reserve(n: number): void;
+        /**
+         * @inheritdoc
+         */
+        rehash(n: number): void;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_pair(pair: Pair<Key, T>): any;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * <p> Swap content. </p>
+         *
+         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link HashMap map} of the same type. Sizes abd container type may differ. </p>
+         *
+         * <p> After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects. </p>
+         *
+         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function. </p>
+         *
+         * @param obj Another {@link HashMap map container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link HashMap container}.
+         */
+        swap(obj: HashMap<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.IContainer<Pair<Key, T>>): void;
+    }
+}
+declare namespace std.HashMultiMap {
+    type iterator<Key, T> = std.MapIterator<Key, T>;
+    type reverse_iterator<Key, T> = std.MapReverseIterator<Key, T>;
+}
+declare namespace std {
+    /**
+     * <p> Hashed, unordered Multimap. </p>
+     *
+     * <p> {@link HashMultiMap}s are associative containers that store elements formed by the combination of
+     * a <i>key value</i> and a <i>mapped value</i>, much like {@link HashMultiMap} containers, but allowing
+     * different elements to have equivalent <i>keys</i>. </p>
+     *
+     * <p> In an {@link HashMultiMap}, the <i>key value</i> is generally used to uniquely identify the
+     * element, while the <i>mapped value</i> is an object with the content associated to this <i>key</i>.
+     * Types of <i>key</i> and <i>mapped value</i> may differ. </p>
+     *
+     * <p> Internally, the elements in the {@link HashMultiMap} are not sorted in any particular order with
+     * respect to either their <i>key</i> or <i>mapped values</i>, but organized into <i>buckets</i> depending on
+     * their hash values to allow for fast access to individual elements directly by their <i>key values</i>
+     * (with a constant average time complexity on average). </p>
+     *
+     * <p> Elements with equivalent <i>keys</i> are grouped together in the same bucket and in such a way that
+     * an iterator can iterate through all of them. Iterators in the container are doubly linked iterators. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a>
+     * </p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Hashed </dt>
+     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
+     *		 by their <i>key</i>. </dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> The container can hold multiple elements with equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the key values.
+     *				Each element in an {@link HashMultiMap} is identified by a key value.
+     * @param <T> Type of the mapped value.
+     *			  Each element in an {@link HashMultiMap} is used to store some data as its mapped value.
+     *
+     * @reference http://www.cplusplus.com/reference/unordered_map/unordered_multimap
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class HashMultiMap<Key, T> extends base.MultiMap<Key, T> {
+        /**
+         * @hidden
+         */
+        private hash_buckets_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from elements.
+         */
+        constructor(items: Pair<Key, T>[]);
+        /**
+         * Contruct from tuples.
+         *
+         * @param array Tuples to be contained.
+         */
+        constructor(array: [Key, T][]);
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: HashMultiMap<Key, T>);
+        /**
+         * Construct from range iterators.
+         */
+        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        count(key: Key): number;
+        /**
+         * @inheritdoc
+         */
+        begin(): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        begin(index: number): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        end(): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        end(index: number): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(index: number): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        rend(index: number): MapReverseIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        bucket_count(): number;
+        /**
+         * @inheritdoc
+         */
+        bucket_size(n: number): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(z: number): void;
+        /**
+         * @inheritdoc
+         */
+        bucket(key: Key): number;
+        /**
+         * @inheritdoc
+         */
+        reserve(n: number): void;
+        /**
+         * @inheritdoc
+         */
+        rehash(n: number): void;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_pair(pair: Pair<Key, T>): any;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * <p> Swap content. </p>
+         *
+         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link HashMultiMap map} of the same type. Sizes abd container type may differ. </p>
+         *
+         * <p> After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects. </p>
+         *
+         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function. </p>
+         *
+         * @param obj Another {@link HashMultiMap map container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link HashMultiMap container}.
+         */
+        swap(obj: HashMultiMap<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.IContainer<Pair<Key, T>>): void;
+    }
+}
+declare namespace std.HashMultiSet {
+    type iterator<T> = std.SetIterator<T>;
+    type reverse_iterator<T> = std.SetReverseIterator<T>;
+}
+declare namespace std {
+    /**
+     * <p> Hashed, unordered Multiset. </p>
+     *
+     * <p> {@link HashMultiSet HashMultiSets} are containers that store elements in no particular order, allowing fast
+     * retrieval of individual elements based on their value, much like {@link HashMultiSet} containers,
+     * but allowing different elements to have equivalent values. </p>
+     *
+     * <p> In an {@link HashMultiSet}, the value of an element is at the same time its <i>key</i>, used to
+     * identify it. <i>Keys</i> are immutable, therefore, the elements in an {@link HashMultiSet} cannot be
+     * modified once in the container - they can be inserted and removed, though. </p>
+     *
+     * <p> Internally, the elements in the {@link HashMultiSet} are not sorted in any particular, but
+     * organized into <i>buckets</i> depending on their hash values to allow for fast access to individual
+     * elements directly by their <i>values</i> (with a constant average time complexity on average). </p>
+     *
+     * <p> Elements with equivalent values are grouped together in the same bucket and in such a way that an
+     * iterator can iterate through all of them. Iterators in the container are doubly linked iterators. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Hashed </dt>
+     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
+     *		 by their <i>key</i>. </dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> The container can hold multiple elements with equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *		   Each element in an {@link UnorderedMultiSet} is also identified by this value..
+     *
+     * @reference http://www.cplusplus.com/reference/unordered_set/unordered_multiset
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class HashMultiSet<T> extends base.MultiSet<T> {
+        /**
+         * @hidden
+         */
+        private hash_buckets_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from elements.
+         */
+        constructor(items: T[]);
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: HashMultiSet<T>);
+        /**
+         * Construct from range iterators.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(key: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        count(key: T): number;
+        /**
+         * @inheritdoc
+         */
+        begin(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        begin(index: number): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(index: number): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(index: number): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(index: number): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        bucket_count(): number;
+        /**
+         * @inheritdoc
+         */
+        bucket_size(n: number): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(z: number): void;
+        /**
+         * @inheritdoc
+         */
+        bucket(key: T): number;
+        /**
+         * @inheritdoc
+         */
+        reserve(n: number): void;
+        /**
+         * @inheritdoc
+         */
+        rehash(n: number): void;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_val(val: T): any;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * <p> Swap content. </p>
+         *
+         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link HashMultiSet set} of the same type. Sizes abd container type may differ. </p>
+         *
+         * <p> After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects. </p>
+         *
+         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function. </p>
+         *
+         * @param obj Another {@link HashMultiSet set container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link HashMultiSet container}.
+         */
+        swap(obj: HashMultiSet<T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.IContainer<T>): void;
+    }
+}
+declare namespace std.HashSet {
+    type iterator<T> = std.SetIterator<T>;
+    type reverse_iterator<T> = std.SetReverseIterator<T>;
+}
+declare namespace std {
+    /**
+     * <p> Hashed, unordered set. </p>
+     *
+     * <p> {@link HashSet}s are containers that store unique elements in no particular order, and which
+     * allow for fast retrieval of individual elements based on their value. </p>
+     *
+     * <p> In an {@link HashSet}, the value of an element is at the same time its <i>key</i>, that
+     * identifies it uniquely. Keys are immutable, therefore, the elements in an {@link HashSet} cannot be
+     * modified once in the container - they can be inserted and removed, though. </p>
+     *
+     * <p> Internally, the elements in the {@link HashSet} are not sorted in any particular order, but
+     * organized into buckets depending on their hash values to allow for fast access to individual elements
+     * directly by their <i>values</i> (with a constant average time complexity on average). </p>
+     *
+     * <p> {@link HashSet} containers are faster than {@link TreeSet} containers to access individual
+     * elements by their <i>key</i>, although they are generally less efficient for range iteration through a
+     * subset of their elements. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /></a> </p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Hashed </dt>
+     *	<dd> Hashed containers organize their elements using hash tables that allow for fast access to elements
+     *		 by their <i>key</i>. </dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     *
+     *	<dt> Unique keys </dt>
+     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *			  Each element in an {@link HashSet} is also uniquely identified by this value.
+     *
+     * @reference http://www.cplusplus.com/reference/unordered_set/unordered_set
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class HashSet<T> extends base.UniqueSet<T> implements base.IHashSet<T> {
+        /**
+         * @hidden
+         */
+        private hash_buckets_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from elements.
+         */
+        constructor(items: T[]);
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: HashSet<T>);
+        /**
+         * Construct from range iterators.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(key: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        begin(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        begin(index: number): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(index: number): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(index: number): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(index: number): SetReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        bucket_count(): number;
+        /**
+         * @inheritdoc
+         */
+        bucket_size(n: number): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(): number;
+        /**
+         * @inheritdoc
+         */
+        max_load_factor(z: number): void;
+        /**
+         * @inheritdoc
+         */
+        bucket(key: T): number;
+        /**
+         * @inheritdoc
+         */
+        reserve(n: number): void;
+        /**
+         * @inheritdoc
+         */
+        rehash(n: number): void;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_val(val: T): any;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * <p> Swap content. </p>
+         *
+         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link HashSet set} of the same type. Sizes abd container type may differ. </p>
+         *
+         * <p> After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects. </p>
+         *
+         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function. </p>
+         *
+         * @param obj Another {@link HashSet set container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link HashSet container}.
+         */
+        swap(obj: HashSet<T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.IContainer<T>): void;
+    }
+}
+declare namespace std.List {
+    type iterator<T> = std.ListIterator<T>;
+    type reverse_iterator<T> = std.ListReverseIterator<T>;
+}
+declare namespace std {
+    /**
+     * <p> Doubly linked list. </p>
+     *
+     * <p> {@link List}s are sequence containers that allow constant time insert and erase operations anywhere within the
+     * sequence, and iteration in both directions. </p>
+     *
+     * <p> List containers are implemented as doubly-linked lists; Doubly linked lists can store each of the elements they
+     * contain in different and unrelated storage locations. The ordering is kept internally by the association to each
+     * element of a link to the element preceding it and a link to the element following it. </p>
+     *
+     * <p> They are very similar to forward_list: The main difference being that forward_list objects are single-linked
+     * lists, and thus they can only be iterated forwards, in exchange for being somewhat smaller and more efficient. </p>
+     *
+     * <p> Compared to other base standard sequence containers (array, vector and deque), lists perform generally better
+     * in inserting, extracting and moving elements in any position within the container for which an iterator has already
+     * been obtained, and therefore also in algorithms that make intensive use of these, like sorting algorithms. </p>
+     *
+     * <p> The main drawback of lists and forward_lists compared to these other sequence containers is that they lack
+     * direct access to the elements by their position; For example, to access the sixth element in a list, one has to
+     * iterate from a known position (like the beginning or the end) to that position, which takes linear time in the
+     * distance between these. They also consume some extra memory to keep the linking information associated to each
+     * element (which may be an important factor for large lists of small-sized elements). </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
+     * </p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     * 	<dt> Sequence </dt>
+     * 	<dd> Elements in sequence containers are ordered in a strict linear sequence. Individual elements are accessed by
+     *		 their position in this sequence. </dd>
+     *
+     * 	<dt> Doubly-linked list </dt>
+     *	<dd> Each element keeps information on how to locate the next and the previous elements, allowing constant time
+     *		 insert and erase operations before or after a specific element (even of entire ranges), but no direct random
+     *		 access. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @reference http://www.cplusplus.com/reference/list/list/
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class List<T> extends base.Container<T> implements base.IDequeContainer<T> {
+        /**
+         * @hidden
+         */
+        private begin_;
+        /**
+         * @hidden
+         */
+        private end_;
+        /**
+         * @hidden
+         */
+        private size_;
+        /**
+         * <p> Default Constructor. </p>
+         *
+         * <p> Constructs an empty container, with no elements. </p>
+         */
+        constructor();
+        /**
+         * <p> Initializer list Constructor. </p>
+         *
+         * <p> Constructs a container with a copy of each of the elements in <i>array</i>, in the same order. </p>
+         *
+         * @param array An array containing elements to be copied and contained.
+         */
+        constructor(items: Array<T>);
+        /**
+         * <p> Fill Constructor. </p>
+         *
+         * <p> Constructs a container with <i>n</i> elements. Each element is a copy of <i>val</i> (if provided). </p>
+         *
+         * @param n Initial container size (i.e., the number of elements in the container at construction).
+         * @param val Value to fill the container with. Each of the <i>n</i> elements in the container is
+         *			  initialized to a copy of this value.
+         */
+        constructor(size: number, val: T);
+        /**
+         * <p> Copy Constructor. </p>
+         *
+         * <p> Constructs a container with a copy of each of the elements in <i>container</i>, in the same order. </p>
+         *
+         * @param container Another container object of the same type (with the same class template
+         *					arguments <i>T</i>), whose contents are either copied or acquired.
+         */
+        constructor(container: List<T>);
+        /**
+         * <p> Range Constructor. </p>
+         *
+         * <p> Constructs a container with as many elements as the range (<i>begin</i>, <i>end<i>), with each
+         * element emplace-constructed from its corresponding element in that range, in the same order. </p>
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * @inheritdoc
+         */
+        assign(n: number, val: T): void;
+        /**
+         * @inheritdoc
+         */
+        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        begin(): ListIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(): ListIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): ListReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): ListReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        size(): number;
+        /**
+         * @inheritdoc
+         */
+        front(): T;
+        /**
+         * @inheritdoc
+         */
+        back(): T;
+        /**
+         * @inheritdoc
+         */
+        push(...items: T[]): number;
+        /**
+         * @inheritdoc
+         */
+        push_front(val: T): void;
+        /**
+         * @inheritdoc
+         */
+        push_back(val: T): void;
+        /**
+         * @inheritdoc
+         */
+        pop_front(): void;
+        /**
+         * @inheritdoc
+         */
+        pop_back(): void;
+        /**
+         * <p> Insert an element. </p>
+         *
+         * <p> The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted. </p>
+         *
+         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence. </p>
+         *
+         * @param position Position in the container where the new element is inserted.
+         *				   {@link iterator}> is a member type, defined as a
+         *				   {@link ListIterator bidirectional iterator} type that points to elements.
+         * @param val Value to be inserted as an element.
+         *
+         * @return An iterator that points to the newly inserted element; <i>val</i>.
+         */
+        insert(position: ListIterator<T>, val: T): ListIterator<T>;
+        /**
+         * <p> Insert elements by repeated filling. </p>
+         *
+         * <p> The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted. </p>
+         *
+         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence. </p>
+         *
+         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
+         *				   member type, defined as a {@link ListIterator bidirectional iterator} type that points to
+         *				   elements.
+         * @param size Number of elements to insert.
+         * @param val Value to be inserted as an element.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert(position: ListIterator<T>, size: number, val: T): ListIterator<T>;
+        /**
+         * <p> Insert elements by range iterators. </p>
+         *
+         * <p> The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted. </p>
+         *
+         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence. </p>
+         *
+         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
+         *				   member type, defined as a {@link ListIterator bidirectional iterator} type that points to
+         *				   elements.
+         * @param begin An iterator specifying range of the begining element.
+         * @param end An iterator specifying range of the ending element.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(position: ListIterator<T>, begin: InputIterator, end: InputIterator): ListIterator<T>;
+        /**
+         * <p> Insert an element. </p>
+         *
+         * <p> The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted. </p>
+         *
+         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence. </p>
+         *
+         * @param position Position in the container where the new element is inserted.
+         *				   {@link iterator}> is a member type, defined as a
+         *				   {@link ListReverseIterator bidirectional iterator} type that points to elements.
+         * @param val Value to be inserted as an element.
+         *
+         * @return An iterator that points to the newly inserted element; <i>val</i>.
+         */
+        insert(position: ListReverseIterator<T>, val: T): ListReverseIterator<T>;
+        /**
+         * <p> Insert elements by repeated filling. </p>
+         *
+         * <p> The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted. </p>
+         *
+         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence. </p>
+         *
+         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
+         *				   member type, defined as a {@link ListReverseIterator bidirectional iterator} type that points to
+         *				   elements.
+         * @param size Number of elements to insert.
+         * @param val Value to be inserted as an element.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert(position: ListReverseIterator<T>, size: number, val: T): ListReverseIterator<T>;
+        /**
+         * <p> Insert elements by range iterators. </p>
+         *
+         * <p> The container is extended by inserting a new element before the element at the specified
+         * <i>position</i>. This effectively increases the {@link List.size List size} by the amount of elements
+         * inserted. </p>
+         *
+         * <p> Unlike other standard sequence containers, {@link List} is specifically designed to be efficient
+         * inserting and removing elements in any position, even in the middle of the sequence. </p>
+         *
+         * @param position Position in the container where the new elements are inserted. The {@link iterator} is a
+         *				   member type, defined as a {@link ListReverseIterator bidirectional iterator} type that points to
+         *				   elements.
+         * @param begin An iterator specifying range of the begining element.
+         * @param end An iterator specifying range of the ending element.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(position: ListReverseIterator<T>, begin: InputIterator, end: InputIterator): ListReverseIterator<T>;
+        /**
+         * @hidden
+         */
+        private insert_by_val(position, val);
+        /**
+         * @hidden
+         */
+        protected _Insert_by_repeating_val(position: ListIterator<T>, size: number, val: T): ListIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(position: ListIterator<T>, begin: InputIterator, end: InputIterator): ListIterator<T>;
+        /**
+         * <p> Erase an element. </p>
+         *
+         * <p> Removes from the {@link List} either a single element; <i>position</i>. </p>
+         *
+         * <p> This effectively reduces the container size by the number of element removed. </p>
+         *
+         * <p> Unlike other standard sequence containers, {@link List} objects are specifically designed to be
+         * efficient inserting and removing elements in any position, even in the middle of the sequence. </p>
+         *
+         * @param position Iterator pointing to a single element to be removed from the {@link List}.
+         *
+         * @return An iterator pointing to the element that followed the last element erased by the function call.
+         *		   This is the {@link end end()} if the operation erased the last element in the sequence.
+         */
+        erase(position: ListIterator<T>): ListIterator<T>;
+        /**
+         * <p> Erase elements. </p>
+         *
+         * <p> Removes from the {@link List} container a range of elements. </p>
+         *
+         * <p> This effectively reduces the container {@link size} by the number of elements removed. </p>
+         *
+         * <p> Unlike other standard sequence containers, {@link List} objects are specifically designed to be
+         * efficient inserting and removing elements in any position, even in the middle of the sequence. </p>
+         *
+         * @param begin An iterator specifying a range of beginning to erase.
+         * @param end An iterator specifying a range of end to erase.
+         *
+         * @return An iterator pointing to the element that followed the last element erased by the function call.
+         *		   This is the {@link end end()} if the operation erased the last element in the sequence.
+         */
+        erase(begin: ListIterator<T>, end: ListIterator<T>): ListIterator<T>;
+        /**
+         * <p> Erase an element. </p>
+         *
+         * <p> Removes from the {@link List} either a single element; <i>position</i>. </p>
+         *
+         * <p> This effectively reduces the container size by the number of element removed. </p>
+         *
+         * <p> Unlike other standard sequence containers, {@link List} objects are specifically designed to be
+         * efficient inserting and removing elements in any position, even in the middle of the sequence. </p>
+         *
+         * @param position Iterator pointing to a single element to be removed from the {@link List}.
+         *
+         * @return An iterator pointing to the element that followed the last element erased by the function call.
+         *		   This is the {@link rend rend()} if the operation erased the last element in the sequence.
+         */
+        erase(position: ListReverseIterator<T>): ListReverseIterator<T>;
+        /**
+         * <p> Erase elements. </p>
+         *
+         * <p> Removes from the {@link List} container a range of elements. </p>
+         *
+         * <p> This effectively reduces the container {@link size} by the number of elements removed. </p>
+         *
+         * <p> Unlike other standard sequence containers, {@link List} objects are specifically designed to be
+         * efficient inserting and removing elements in any position, even in the middle of the sequence. </p>
+         *
+         * @param begin An iterator specifying a range of beginning to erase.
+         * @param end An iterator specifying a range of end to erase.
+         *
+         * @return An iterator pointing to the element that followed the last element erased by the function call.
+         *		   This is the {@link rend rend()} if the operation erased the last element in the sequence.
+         */
+        erase(begin: ListReverseIterator<T>, end: ListReverseIterator<T>): ListReverseIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Erase_by_range(first: ListIterator<T>, last: ListIterator<T>): ListIterator<T>;
+        /**
+         * <p> Remove duplicate values. </p>
+         *
+         * <p> Removes all but the first element from every consecutive group of equal elements in the  </p>
+         *
+         * <p> Notice that an element is only removed from the {@link List} container if it compares equal to the
+         * element immediately preceding it. Thus, this function is especially useful for sorted lists. </p>
+         */
+        unique(): void;
+        /**
+         * <p> Remove duplicate values. </p>
+         *
+         * <p> Removes all but the first element from every consecutive group of equal elements in the  </p>
+         *
+         * <p> The argument <i>binary_pred</i> is a specific comparison function that determine the <u>uniqueness</u>
+         * of an element. In fact, any behavior can be implemented (and not only an equality comparison), but notice
+         * that the function will call <code>binary_pred(it.value, it.prev().value)</code> for all pairs of elements
+         * (where <code>it</code> is an iterator to an element, starting from the second) and remove <code>it</code>
+         * from the {@link List} if the predicate returns <code>true</code>.
+         *
+         * <p> Notice that an element is only removed from the {@link List} container if it compares equal to the
+         * element immediately preceding it. Thus, this function is especially useful for sorted lists. </p>
+         *
+         * @param binary_pred Binary predicate that, taking two values of the same type than those contained in the
+         *					  {@link List}, returns <code>true</code> to remove the element passed as first argument
+         *					  from the container, and <code>false</code> otherwise. This shall be a function pointer
+         *					  or a function object.
+         */
+        unique(binary_pred: (left: T, right: T) => boolean): void;
+        /**
+         * <p> Remove elements with specific value. </p>
+         *
+         * <p> Removes from the container all the elements that compare equal to <i>val</i>. This calls the
+         * destructor of these objects and reduces the container {@link size} by the number of elements removed. </p>
+         *
+         * <p> Unlike member function {@link List.erase}, which erases elements by their position (using an
+         * iterator), this function ({@link List.remove}) removes elements by their value. </p>
+         *
+         * <p> A similar function, {@link List.remove_if}, exists, which allows for a condition other than an
+         * equality comparison to determine whether an element is removed. </p>
+         *
+         * @param val Value of the elements to be removed.
+         */
+        remove(val: T): void;
+        /**
+         * <p> Remove elements fulfilling condition. </p>
+         *
+         * <p> Removes from the container all the elements for which <i>pred</i> returns <code>true</code>. This
+         * calls the destructor of these objects and reduces the container {@link size} by the number of elements
+         * removed. </p>
+         *
+         * <p> The function calls <code>pred(it.value)</code> for each element (where <code>it</code> is an iterator
+         * to that element). Any of the elements in the list for which this returns <code>true</code>, are removed
+         * from the  </p>
+         *
+         * @param pred Unary predicate that, taking a value of the same type as those contained in the forward_list
+         *			   object, returns <code>true</code> for those values to be removed from the container, and
+         *			   <code>false</code> for those remaining. This can either be a function pointer or a function
+         *			   object.
+         */
+        remove_if(pred: (val: T) => boolean): void;
+        /**
+         * <p> Merge sorted {@link List Lists}. </p>
+         *
+         * <p> Merges <i>obj</i> into the {@link List} by transferring all of its elements at their respective
+         * ordered positions into the container (<font color='red'>both containers shall already be ordered</font>).
+         * </p>
+         *
+         * <p> This effectively removes all the elements in <i>obj</i> (which becomes {@link empty}), and inserts
+         * them into their ordered position within container (which expands in {@link size} by the number of elements
+         * transferred). The operation is performed without constructing nor destroying any element: they are
+         * transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the value_type supports
+         * move-construction or not. </p>
+         *
+         * <p> This function requires that the {@link List} containers have their elements already ordered by value
+         * ({@link less}) before the call. For an alternative on unordered {@link List Lists}, see
+         * {@link List.splice}. </p>
+         *
+         * <p> Assuming such ordering, each element of <i>obj</i> is inserted at the position that corresponds to its
+         * value according to the strict weak ordering defined by {@link less}. The resulting order of equivalent
+         * elements is stable (i.e., equivalent elements preserve the relative order they had before the call, and
+         * existing elements precede those equivalent inserted from <i>obj</i>). </p>
+         *
+         * The function does nothing if <code>this == obj</code>.
+         *
+         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
+         * 			  Note that this function modifies <i>obj</i> no matter whether an lvalue or rvalue reference is
+         *			  passed.
+         */
+        merge<U extends T>(obj: List<U>): void;
+        /**
+         * <p> Merge sorted {@link List Lists}. </p>
+         *
+         * <p> Merges <i>obj</i> into the {@link List} by transferring all of its elements at their respective
+         * ordered positions into the container (<font color='red'>both containers shall already be ordered</font>).
+         * </p>
+         *
+         * <p> This effectively removes all the elements in <i>obj</i> (which becomes {@link empty}), and inserts
+         * them into their ordered position within container (which expands in {@link size} by the number of elements
+         * transferred). The operation is performed without constructing nor destroying any element: they are
+         * transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the value_type supports
+         * move-construction or not. </p>
+         *
+         * <p> The argument <i>compare</i> is a specific predicate to perform the comparison operation between
+         * elements. This comparison shall produce a strict weak ordering of the elements (i.e., a consistent
+         * transitive comparison, without considering its reflexiveness).
+         *
+         * <p> This function requires that the {@link List} containers have their elements already ordered by
+         * <i>compare</i> before the call. For an alternative on unordered {@link List Lists}, see
+         * {@link List.splice}. </p>
+         *
+         * <p> Assuming such ordering, each element of <i>obj</i> is inserted at the position that corresponds to its
+         * value according to the strict weak ordering defined by <i>compare</i>. The resulting order of equivalent
+         * elements is stable (i.e., equivalent elements preserve the relative order they had before the call, and
+         * existing elements precede those equivalent inserted from <i>obj</i>). </p>
+         *
+         * The function does nothing if <code>this == obj</code>.
+         *
+         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
+         * 			  Note that this function modifies <i>obj</i> no matter whether an lvalue or rvalue reference is
+         *			  passed.
+         * @param compare Binary predicate that, taking two values of the same type than those contained in the
+         *				  {@link list}, returns <code>true</code> if the first argument is considered to go before
+         *				  the second in the strict weak ordering it defines, and <code>false</code> otherwise.
+         *				  This shall be a function pointer or a function object.
+         */
+        merge<U extends T>(obj: List<U>, compare: (left: T, right: T) => boolean): void;
+        /**
+         * <p> Transfer elements from {@link List} to {@link List}. </p>
+         *
+         * <p> Transfers elements from <i>obj</i> into the container, inserting them at <i>position</i>. </p>
+         *
+         * <p> This effectively inserts all elements into the container and removes them from <i>obj</i>, altering
+         * the sizes of both containers. The operation does not involve the construction or destruction of any
+         * element. They are transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the
+         * value_type supports move-construction or not. </p>
+         *
+         * <p> This first version (1) transfers all the elements of <i>obj</i> into the  </p>
+         *
+         * @param position Position within the container where the elements of <i>obj</i> are inserted.
+         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
+         */
+        splice<U extends T>(position: ListIterator<T>, obj: List<U>): void;
+        /**
+         * <p> Transfer an element from {@link List} to {@link List}. </p>
+         *
+         * <p> Transfers an element from <i>obj</i>, which is pointed by an {@link ListIterator iterator} <i>it</i>,
+         * into the container, inserting the element at specified <i>position</i>. </p>
+         *
+         * <p> This effectively inserts an element into the container and removes it from <i>obj</i>, altering the
+         * sizes of both containers. The operation does not involve the construction or destruction of any element.
+         * They are transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the value_type
+         * supports move-construction or not. </p>
+         *
+         * <p> This second version (2) transfers only the element pointed by <i>it</i> from <i>obj</i> into the
+         *  </p>
+         *
+         * @param position Position within the container where the element of <i>obj</i> is inserted.
+         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
+         *			  This parameter may be <code>this</code> if <i>position</i> points to an element not actually
+         *			  being spliced.
+         * @param it {@link ListIterator Iterator} to an element in <i>obj</i>. Only this single element is
+         *			 transferred.
+         */
+        splice<U extends T>(position: ListIterator<T>, obj: List<U>, it: ListIterator<U>): void;
+        /**
+         * <p> Transfer elements from {@link List} to {@link List}. </p>
+         *
+         * <p> Transfers elements from <i>obj</i> into the container, inserting them at <i>position</i>. </p>
+         *
+         * <p> This effectively inserts those elements into the container and removes them from <i>obj</i>, altering
+         * the sizes of both containers. The operation does not involve the construction or destruction of any
+         * element. They are transferred, no matter whether <i>obj</i> is an lvalue or an rvalue, or whether the
+         * value_type supports move-construction or not. </p>
+         *
+         * <p> This third version (3) transfers the range [<i>begin</i>, <i>end</i>) from <i>obj</i> into the
+         *  </p>
+         *
+         * @param position Position within the container where the elements of <i>obj</i> are inserted.
+         * @param obj A {@link List} object of the same type (i.e., with the same template parameters, <b>T</b>).
+         *			  This parameter may be <code>this</code> if <i>position</i> points to an element not actually
+         *			  being spliced.
+         * @param begin {@link ListIterator An Iterator} specifying initial position of a range of elements in
+         *				<i>obj</i>. Transfers the elements in the range [<b><i>begin</i></b>, <i>end</i>) to
+         *				<i>position</i>.
+         * @param end {@link ListIterator An Iterator} specifying final position of a range of elements in
+         *			  <i>obj</i>. Transfers the elements in the range [<i>begin</i>, <b><i>end</i></b>) to
+         *			  <i>position</i>. Notice that the range includes all the elements between <i>begin<i/> and
+         *			  <i>end</i>, including the element pointed by <i>begin</i> but not the one pointed by <i>end</i>.
+         */
+        splice<U extends T>(position: ListIterator<T>, obj: List<U>, begin: ListIterator<U>, end: ListIterator<U>): void;
+        /**
+         * <p> Sort elements in  </p>
+         *
+         * <p> Sorts the elements in the {@link List}, altering their position within the  </p>
+         *
+         * <p> The sorting is performed by applying an algorithm that uses {@link less}. This comparison shall
+         * produce a strict weak ordering of the elements (i.e., a consistent transitive comparison, without
+         * considering its reflexiveness). </p>
+         *
+         * <p> The resulting order of equivalent elements is stable: i.e., equivalent elements preserve the relative
+         * order they had before the call. </p>
+         *
+         * <p> The entire operation does not involve the construction, destruction or copy of any element object.
+         * Elements are moved within the  </p>
+         */
+        sort(): void;
+        /**
+         * <p> Sort elements in  </p>
+         *
+         * <p> Sorts the elements in the {@link List}, altering their position within the  </p>
+         *
+         * <p> The sorting is performed by applying an algorithm that uses <i>compare</i>. This comparison shall
+         * produce a strict weak ordering of the elements (i.e., a consistent transitive comparison, without
+         * considering its reflexiveness). </p>
+         *
+         * <p> The resulting order of equivalent elements is stable: i.e., equivalent elements preserve the relative
+         * order they had before the call. </p>
+         *
+         * <p> The entire operation does not involve the construction, destruction or copy of any element object.
+         * Elements are moved within the  </p>
+         *
+         * @param compare Binary predicate that, taking two values of the same type of those contained in the
+         *				  {@link List}, returns <code>true</code> if the first argument goes before the second
+         *				  argument in the strict weak ordering it defines, and <code>false</code> otherwise. This
+         *				  shall be a function pointer or a function object.
+         */
+        sort(compare: (left: T, right: T) => boolean): void;
+        /**
+         * @hidden
+         */
+        private qsort(first, last, compare);
+        /**
+         * @hidden
+         */
+        private partition(first, last, compare);
+        /**
+         * <p> Swap content. </p>
+         *
+         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link List container} object with same type of elements. Sizes and container type may differ. </p>
+         *
+         * <p> After the call to this member function, the elements in this container are those which were in <i>obj</i>
+         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
+         * pointers remain valid for the swapped objects. </p>
+         *
+         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function. </p>
+         *
+         * @param obj Another {@link List container} of the same type of elements (i.e., instantiated
+         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
+         *			  {@link container List}.
+         */
+        swap(obj: List<T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.IContainer<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * <p> An iterator, node of a List. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
+     * </p>
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class ListIterator<T> extends Iterator<T> {
+        /**
+         * @hidden
+         */
+        private prev_;
+        /**
+         * @hidden
+         */
+        private next_;
+        /**
+         * @hidden
+         */
+        private value_;
+        /**
+         * <p> Construct from the source {@link List container}. </p>
+         *
+         * <h4> Note </h4>
+         * <p> Do not create the iterator directly, by yourself. </p>
+         * <p> Use {@link List.begin begin()}, {@link List.end end()} in {@link List container} instead. </p>
+         *
+         * @param source The source {@link List container} to reference.
+         * @param prev A refenrece of previous node ({@link ListIterator iterator}).
+         * @param next A refenrece of next node ({@link ListIterator iterator}).
+         * @param value Value to be stored in the node (iterator).
+         */
+        constructor(source: List<T>, prev: ListIterator<T>, next: ListIterator<T>, value: T);
+        private list();
+        /**
+         * @inheritdoc
+         */
+        prev(): ListIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        next(): ListIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        advance(step: number): ListIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        /**
+         * Set value of the iterator is pointing to.
+         *
+         * @param val Value to set.
+         */
+        value: T;
+        /**
+         * @inheritdoc
+         */
+        equal_to(obj: ListIterator<T>): boolean;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: ListIterator<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * <p> A reverse-iterator of List. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
+     * </p>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class ListReverseIterator<T> extends ReverseIterator<T, ListIterator<T>, ListReverseIterator<T>> implements base.ILinearIterator<T> {
+        /**
+         * Construct from base iterator.
+         *
+         * @param base A reference of the base iterator, which iterates in the opposite direction.
+         */
+        constructor(base: ListIterator<T>);
+        /**
+         * @hidden
+         */
+        protected create_neighbor(base: ListIterator<T>): ListReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        /**
+         * Set value of the iterator is pointing to.
+         *
+         * @param val Value to set.
+         */
+        value: T;
+    }
+}
+declare namespace std.Vector {
+    type iterator<T> = std.VectorIterator<T>;
+    type reverse_iterator<T> = std.VectorReverseIterator<T>;
+}
+declare namespace std {
+    /**
+     * <p> Vector, the dynamic array. </p>
+     *
+     * <p> {@link Vector}s are sequence containers representing arrays that can change in size. </p>
+     *
+     * <p> Just like arrays, {@link Vector}s use contiguous storage locations for their elements, which means that
+     * their elements can also be accessed using offsets on regular pointers to its elements, and just as efficiently
+     * as in arrays. But unlike arrays, their size can change dynamically, with their storage being handled
+     * automatically by the container. </p>
+     *
+     * <p> Internally, {@link Vector}s use a dynamically allocated array to store their elements. This array may need
+     * to be reallocated in order to grow in size when new elements are inserted, which implies allocating a new
+     * array and moving all elements to it. This is a relatively expensive task in terms of processing time, and
+     * thus, {@link Vector}s do not reallocate each time an element is added to the container. </p>
+     *
+     * <p> Instead, {@link Vector} containers may allocate some extra storage to accommodate for possible growth, and
+     * thus the container may have an actual {@link capacity} greater than the storage strictly needed to contain its
+     * elements (i.e., its {@link size}). Libraries can implement different strategies for growth to balance between
+     * memory usage and reallocations, but in any case, reallocations should only happen at logarithmically growing
+     * intervals of {@link size} so that the insertion of individual elements at the end of the {@link Vector} can be
+     * provided with amortized constant time complexity (see {@link push_back push_back()}). </p>
+     *
+     * <p> Therefore, compared to arrays, {@link Vector}s consume more memory in exchange for the ability to manage
+     * storage and grow dynamically in an efficient way. </p>
+     *
+     * <p> Compared to the other dynamic sequence containers ({@link Deque}s, {@link List}s), {@link Vector Vectors}
+     * are very efficient accessing its elements (just like arrays) and relatively efficient adding or removing
+     * elements from its end. For operations that involve inserting or removing elements at positions other than the
+     * end, they perform worse than the others, and have less consistent iterators and references than {@link List}s.
+     * </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
+     * </a> </p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Sequence </dt>
+     *	<dd>
+     *		Elements in sequence containers are ordered in a strict linear sequence. Individual elements are
+     *		accessed by their position in this sequence.
+     *	</dd>
+     *
+     *	<dt> Dynamic array </dt>
+     *	<dd>
+     *		Allows direct access to any element in the sequence, even through pointer arithmetics, and provides
+     *		relatively fast addition/removal of elements at the end of the sequence.
+     *	</dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @reference http://www.cplusplus.com/reference/vector/vector
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class Vector<T> extends Array<T> implements base.IContainer<T>, base.IArrayContainer<T> {
+        /**
+         * <p> Default Constructor. </p>
+         *
+         * <p> Constructs an empty container, with no elements. </p>
+         */
+        constructor();
+        /**
+         * @inheritdoc
+         */
+        constructor(array: Array<T>);
+        /**
+         * <p> Initializer list Constructor. </p>
+         *
+         * <p> Constructs a container with a copy of each of the elements in <i>array</i>, in the same order. </p>
+         *
+         * @param array An array containing elements to be copied and contained.
+         */
+        constructor(n: number);
+        /**
+         * <p> Fill Constructor. </p>
+         *
+         * <p> Constructs a container with <i>n</i> elements. Each element is a copy of <i>val</i> (if provided). </p>
+         *
+         * @param n Initial container size (i.e., the number of elements in the container at construction).
+         * @param val Value to fill the container with. Each of the <i>n</i> elements in the container is
+         *			  initialized to a copy of this value.
+         */
+        constructor(n: number, val: T);
+        /**
+         * <p> Copy Constructor. </p>
+         *
+         * <p> Constructs a container with a copy of each of the elements in <i>container</i>, in the same order. </p>
+         *
+         * @param container Another container object of the same type (with the same class template
+         *					arguments <i>T</i>), whose contents are either copied or acquired.
+         */
+        constructor(container: Vector<T>);
+        /**
+         * <p> Range Constructor. </p>
+         *
+         * <p> Constructs a container with as many elements as the range (<i>begin</i>, <i>end<i>), with each
+         * element emplace-constructed from its corresponding element in that range, in the same order. </p>
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * @inheritdoc
+         */
+        assign<U extends T, InputIterator extends Iterator<U>>(begin: InputIterator, end: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        assign(n: number, val: T): void;
+        /**
+         * @inheritdoc
+         */
+        reserve(size: number): void;
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        begin(): VectorIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        end(): VectorIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rbegin(): VectorReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        rend(): VectorReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        size(): number;
+        /**
+         * @inheritdoc
+         */
+        capacity(): number;
+        /**
+         * @inheritdoc
+         */
+        empty(): boolean;
+        /**
+         * @inheritdoc
+         */
+        at(index: number): T;
+        /**
+         * @inheritdoc
+         */
+        set(index: number, val: T): T;
+        /**
+         * @inheritdoc
+         */
+        front(): T;
+        /**
+         * @inheritdoc
+         */
+        back(): T;
+        /**
+         * @inheritdoc
+         */
+        push_back(val: T): void;
+        /**
+         * <p> Insert an element. </p>
+         *
+         * <p> The {@link Vector} is extended by inserting new element before the element at the specified
+         * <i>position</i>, effectively increasing the container size by one. </p>
+         *
+         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
+         * {@link size} surpasses the current {@link capacity}. </p>
+         *
+         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting element in
+         * positions other than the {@link end end()} causes the container to relocate all the elements that were
+         * after <i>position</i> to its new position. This is generally an inefficient operation compared to the one
+         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
+         *
+         * @param position Position in the {@link Vector} where the new element is inserted.
+         *				   {@link iterator} is a member type, defined as a
+         *				   {@link VectorIterator random access iterator} type that points to elements.
+         * @param val Value to be copied to the inserted element.
+         *
+         * @return An iterator that points to the newly inserted element.
+         */
+        insert(position: VectorIterator<T>, val: T): VectorIterator<T>;
+        /**
+         * <p> Insert elements by repeated filling. </p>
+         *
+         * <p> The {@link Vector} is extended by inserting new elements before the element at the specified
+         * <i>position</i>, effectively increasing the container size by the number of elements inserted. </p>
+         *
+         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
+         * {@link size} surpasses the current {@link capacity}. </p>
+         *
+         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
+         * positions other than the {@link end end()} causes the container to relocate all the elements that were
+         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
+         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
+         *
+         * @param position Position in the {@link Vector} where the new elements are inserted.
+         *				   {@link iterator} is a member type, defined as a
+         *				   {@link VectorIterator random access iterator} type that points to elements.
+         * @param n Number of elements to insert. Each element is initialized to a copy of <i>val</i>.
+         * @param val Value to be copied (or moved) to the inserted elements.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert(position: VectorIterator<T>, n: number, val: T): VectorIterator<T>;
+        /**
+         * <p> Insert elements by range iterators. </p>
+         *
+         * <p> The {@link Vector} is extended by inserting new elements before the element at the specified
+         * <i>position</i>, effectively increasing the container size by the number of elements inserted by range
+         * iterators. </p>
+         *
+         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
+         * {@link size} surpasses the current {@link capacity}. </p>
+         *
+         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
+         * positions other than the {@link end end()} causes the container to relocate all the elements that were
+         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
+         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
+         *
+         * @param position Position in the {@link Vector} where the new elements are inserted.
+         *				   {@link iterator} is a member type, defined as a
+         *				   {@link VectorIterator random access iterator} type that points to elements.
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(position: VectorIterator<T>, begin: InputIterator, end: InputIterator): VectorIterator<T>;
+        /**
+         * <p> Insert an element. </p>
+         *
+         * <p> The {@link Vector} is extended by inserting new element before the element at the specified
+         * <i>position</i>, effectively increasing the container size by one. </p>
+         *
+         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
+         * {@link size} surpasses the current {@link capacity}. </p>
+         *
+         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting element in
+         * positions other than the {@link end end()} causes the container to relocate all the elements that were
+         * after <i>position</i> to its new position. This is generally an inefficient operation compared to the one
+         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
+         *
+         * @param position Position in the {@link Vector} where the new element is inserted.
+         *				   {@link iterator} is a member type, defined as a
+         *				   {@link VectorIterator random access iterator} type that points to elements.
+         * @param val Value to be copied to the inserted element.
+         *
+         * @return An iterator that points to the newly inserted element.
+         */
+        insert(position: VectorReverseIterator<T>, val: T): VectorReverseIterator<T>;
+        /**
+         * <p> Insert elements by repeated filling. </p>
+         *
+         * <p> The {@link Vector} is extended by inserting new elements before the element at the specified
+         * <i>position</i>, effectively increasing the container size by the number of elements inserted. </p>
+         *
+         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
+         * {@link size} surpasses the current {@link capacity}. </p>
+         *
+         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
+         * positions other than the {@link end end()} causes the container to relocate all the elements that were
+         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
+         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
+         *
+         * @param position Position in the {@link Vector} where the new elements are inserted.
+         *				   {@link iterator} is a member type, defined as a
+         *				   {@link VectorIterator random access iterator} type that points to elements.
+         * @param n Number of elements to insert. Each element is initialized to a copy of <i>val</i>.
+         * @param val Value to be copied (or moved) to the inserted elements.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert(position: VectorReverseIterator<T>, n: number, val: T): VectorReverseIterator<T>;
+        /**
+         * <p> Insert elements by range iterators. </p>
+         *
+         * <p> The {@link Vector} is extended by inserting new elements before the element at the specified
+         * <i>position</i>, effectively increasing the container size by the number of elements inserted by range
+         * iterators. </p>
+         *
+         * <p> This causes an automatic reallocation of the allocated storage space if -and only if- the new
+         * {@link size} surpasses the current {@link capacity}. </p>
+         *
+         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, inserting elements in
+         * positions other than the {@link end end()} causes the container to relocate all the elements that were
+         * after <i>position</i> to their new positions. This is generally an inefficient operation compared to the
+         * one performed for the same operation by other kinds of sequence containers (such as {@link List}).
+         *
+         * @param position Position in the {@link Vector} where the new elements are inserted.
+         *				   {@link iterator} is a member type, defined as a
+         *				   {@link VectorIterator random access iterator} type that points to elements.
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         *
+         * @return An iterator that points to the first of the newly inserted elements.
+         */
+        insert<U extends T, InputIterator extends Iterator<U>>(position: VectorReverseIterator<T>, begin: InputIterator, end: InputIterator): VectorReverseIterator<T>;
+        /**
+         * @hidden
+         */
+        private insert_by_val(position, val);
+        /**
+         * @hidden
+         */
+        protected _Insert_by_repeating_val(position: VectorIterator<T>, n: number, val: T): VectorIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<InputIterator extends Iterator<T>>(position: VectorIterator<T>, first: InputIterator, last: InputIterator): VectorIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        pop_back(): void;
+        /**
+         * <p> Erase element. </p>
+         *
+         * <p> Removes from the {@link Vector} either a single element; <i>position</i>. </p>
+         *
+         * <p> This effectively reduces the container size by the number of element removed. </p>
+         *
+         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing an element in
+         * position other than the {@link end end()} causes the container to relocate all the elements after the
+         * segment erased to their new positions. This is generally an inefficient operation compared to the one
+         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
+         *
+         * @param position Iterator pointing to a single element to be removed from the {@link Vector}.
+         *
+         * @return An iterator pointing to the new location of the element that followed the last element erased by
+         *		   the function call. This is the {@link end end()} if the operation erased the last element in the
+         *		   sequence.
+         */
+        erase(position: VectorIterator<T>): VectorIterator<T>;
+        /**
+         * <p> Erase element. </p>
+         *
+         * <p> Removes from the <ode>Vector</code> either a single element; <i>position</i>. </p>
+         *
+         * <p> This effectively reduces the container size by the number of elements removed. </p>
+         *
+         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing elements in
+         * position other than the {@link end end()} causes the container to relocate all the elements after the
+         * segment erased to their new positions. This is generally an inefficient operation compared to the one
+         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
+         *
+         * @param begin An iterator specifying a range of beginning to erase.
+         * @param end An iterator specifying a range of end to erase.
+         *
+         * @return An iterator pointing to the new location of the element that followed the last element erased by
+         *		   the function call. This is the {@link rend rend()} if the operation erased the last element in the
+         *		   sequence.
+         */
+        erase(first: VectorIterator<T>, last: VectorIterator<T>): VectorIterator<T>;
+        /**
+         * <p> Erase element. </p>
+         *
+         * <p> Removes from the {@link Vector} either a single element; <i>position</i>. </p>
+         *
+         * <p> This effectively reduces the container size by the number of element removed. </p>
+         *
+         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing an element in
+         * position other than the {@link end end()} causes the container to relocate all the elements after the
+         * segment erased to their new positions. This is generally an inefficient operation compared to the one
+         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
+         *
+         * @param position Iterator pointing to a single element to be removed from the {@link Vector}.
+         *
+         * @return An iterator pointing to the new location of the element that followed the last element erased by
+         *		   the function call. This is the {@link rend rend()} if the operation erased the last element in the
+         *		   sequence.
+         */
+        erase(position: VectorReverseIterator<T>): VectorReverseIterator<T>;
+        /**
+         * <p> Erase element. </p>
+         *
+         * <p> Removes from the <ode>Vector</code> either a single element; <i>position</i>. </p>
+         *
+         * <p> This effectively reduces the container size by the number of elements removed. </p>
+         *
+         * <p> Because {@link Vector}s use an <code>Array</code> as their underlying storage, erasing elements in
+         * position other than the {@link end end()} causes the container to relocate all the elements after the
+         * segment erased to their new positions. This is generally an inefficient operation compared to the one
+         * performed for the same operation by other kinds of sequence containers (such as {@link List}). </p>
+         *
+         * @param begin An iterator specifying a range of beginning to erase.
+         * @param end An iterator specifying a range of end to erase.
+         *
+         * @return An iterator pointing to the new location of the element that followed the last element erased by
+         *		   the function call. This is the {@link end end()} if the operation erased the last element in the
+         *		   sequence.
+         */
+        erase(first: VectorReverseIterator<T>, last: VectorReverseIterator<T>): VectorReverseIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Erase_by_range(first: VectorIterator<T>, last: VectorIterator<T>): VectorIterator<T>;
+        /**
+         * <p> Swap content. </p>
+         *
+         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link Vector container} object with same type of elements. Sizes and container type may differ. </p>
+         *
+         * <p> After the call to this member function, the elements in this container are those which were in <i>obj</i>
+         * before the call, and the elements of <i>obj</i> are those which were in this. All iterators, references and
+         * pointers remain valid for the swapped objects. </p>
+         *
+         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function. </p>
+         *
+         * @param obj Another {@link Vector container} of the same type of elements (i.e., instantiated
+         *			  with the same template parameter, <b>T</b>) whose content is swapped with that of this
+         *			  {@link container Vector}.
+         */
+        swap(obj: Vector<T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.IContainer<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * <p> An iterator of Vector. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
+     * </p>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class VectorIterator<T> extends Iterator<T> implements base.IArrayIterator<T> {
+        /**
+         * Sequence number of iterator in the source {@link Vector}.
+         */
+        private index_;
+        /**
+         * <p> Construct from the source {@link Vector container}. </p>
+         *
+         * <h4> Note </h4>
+         * <p> Do not create the iterator directly, by yourself. </p>
+         * <p> Use {@link Vector.begin begin()}, {@link Vector.end end()} in {@link Vector container} instead. </p>
+         *
+         * @param source The source {@link Vector container} to reference.
+         * @param index Sequence number of the element in the source {@link Vector}.
+         */
+        constructor(source: Vector<T>, index: number);
+        /**
+         * @hidden
+         */
+        private readonly vector;
+        /**
+         * @inheritdoc
+         */
+        /**
+         * Set value of the iterator is pointing to.
+         *
+         * @param val Value to set.
+         */
+        value: T;
+        /**
+         * Get index.
+         */
+        readonly index: number;
+        /**
+         * @inheritdoc
+         */
+        prev(): VectorIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        next(): VectorIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        advance(n: number): VectorIterator<T>;
+        /**
+         * <p> Whether an iterator is equal with the iterator. </p>
+         *
+         * <p> Compare two iterators and returns whether they are equal or not. </p>
+         *
+         * <h4> Note </h4>
+         * <p> Iterator's equal_to() only compare souce container and index number. </p>
+         *
+         * <p> Although elements in a pair, key and value are equal_to, if the source map or
+         * index number is different, then the {@link equal_to equal_to()} will return false. If you want to
+         * compare the elements of a pair, compare them directly by yourself. </p>
+         *
+         * @param obj An iterator to compare
+         * @return Indicates whether equal or not.
+         */
+        equal_to<U extends T>(obj: VectorIterator<U>): boolean;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: VectorIterator<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * <p> A reverse-iterator of Vector. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/linear_containers.png" style="max-width: 100%" />
+     * </p>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class VectorReverseIterator<T> extends ReverseIterator<T, VectorIterator<T>, VectorReverseIterator<T>> implements base.IArrayIterator<T> {
+        /**
+         * Construct from base iterator.
+         *
+         * @param base A reference of the base iterator, which iterates in the opposite direction.
+         */
+        constructor(base: VectorIterator<T>);
+        /**
+         * @hidden
+         */
+        protected create_neighbor(base: VectorIterator<T>): VectorReverseIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        /**
+         * Set value of the iterator is pointing to.
+         *
+         * @param val Value to set.
+         */
+        value: T;
+        /**
+         * Get index.
+         */
+        readonly index: number;
+    }
+}
+declare namespace std {
+    /**
+     * <p> FIFO queue. </p>
+     *
+     * <p> {@link Queue}s are a type of container adaptor, specifically designed to operate in a FIFO context
+     * (first-in first-out), where elements are inserted into one end of the container and extracted from the other.
+     * </p>
+     *
+     * <p> {@link Queue}s are implemented as containers adaptors, which are classes that use an encapsulated object of
+     * a specific container class as its underlying container, providing a specific set of member functions to access
+     * its elements. Elements are pushed into the {@link IDeque.back back()} of the specific container and popped from
+     * its {@link IDeque.front front()}. </p>
+     *
+     * <p> {@link container_ The underlying container} may be one of the standard container class template or some
+     * other specifically designed container class. This underlying container shall support at least the following
+     * operations: </p>
+     *
+     * <ul>
+     *	<li> empty </li>
+     *	<li> size </li>
+     *	<li> front </li>
+     *	<li> back </li>
+     *	<li> push_back </li>
+     *	<li> pop_front </li>
+     * </ul>
+     *
+     * <p> The standard container classes {@link Deque} and {@link List} fulfill these requirements.
+     * By default, if no container class is specified for a particular {@link Queue} class instantiation, the standard
+     * container {@link List} is used. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
+     * </p>
+     *
+     * @param <T> Type of elements.
+     *
+     * @reference http://www.cplusplus.com/reference/queue/queue
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class Queue<T> {
+        /**
+         * The <i>underlying object</i> for implementing the <i>FIFO</i>
+         */
+        private container_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: Queue<T>);
+        /**
+         * <p> Return size. </p>
+         * <p> Returns the number of elements in the {@link Queue}. </p>
+         *
+         * <p> This member function effectively calls member {@link IDeque.size size()} of the
+         * {@link container_ underlying container} object. </p>
+         *
+         * @return The number of elements in the {@link container_ underlying container}.
+         */
+        size(): number;
+        /**
+         * <p> Test whether container is empty. </p>
+         * <p> returns whether the {@link Queue} is empty: i.e. whether its <i>size</i> is zero. </p>
+         *
+         * <p> This member function efeectively calls member {@link IDeque.empty empty()} of the
+         * {@link container_ underlying container} object. </p>
+         *
+         * @return <code>true</code> if the {@link container_ underlying container}'s size is 0,
+         *		   <code>false</code> otherwise. </p>
+         */
+        empty(): boolean;
+        /**
+         * <p> Access next element. </p>
+         * <p> Returns a value of the next element in the {@link Queue}. </p>
+         *
+         * <p> The next element is the "oldest" element in the {@link Queue} and the same element that is popped out
+         * from the queue when {@link pop Queue.pop()} is called. </p>
+         *
+         * <p> This member function effectively calls member {@link IDeque.front front()} of the
+         * {@link container_ underlying container} object. </p>
+         *
+         * @return A value of the next element in the {@link Queue}.
+         */
+        front(): T;
+        /**
+         * <p> Access last element. </p>
+         *
+         * <p> Returns a vaue of the last element in the queue. This is the "newest" element in the queue (i.e. the
+         * last element pushed into the queue). </p>
+         *
+         * <p> This member function effectively calls the member function {@link IDeque.back back()} of the
+         * {@link container_ underlying container} object. </p>
+         *
+         * @return A value of the last element in the {@link Queue}.
+         */
+        back(): T;
+        /**
+         * <p> Insert element. </p>
+         *
+         * <p> Inserts a new element at the end of the {@link Queue}, after its current last element.
+         * The content of this new element is initialized to <i>val</i>. </p>
+         *
+         * <p> This member function effectively calls the member function {@link IDeque.push_back push_back()} of the
+         * {@link container_ underlying container} object. </p>
+         *
+         * @param val Value to which the inserted element is initialized.
+         */
+        push(val: T): void;
+        /**
+         * <p> Remove next element. </p>
+         *
+         * <p> Removes the next element in the {@link Queue}, effectively reducing its size by one. </p>
+         *
+         * <p> The element removed is the "oldest" element in the {@link Queue} whose value can be retrieved by calling
+         * member {@link front Queue.front()} </p>.
+         *
+         * <p> This member function effectively calls the member function {@link IDeque.pop_front pop_front()} of the
+         * {@link container_ underlying container} object. </p>
+         */
+        pop(): void;
+        /**
+         * <p> Swap contents. </p>
+         *
+         * <p> Exchanges the contents of the container adaptor (<i>this</i>) by those of <i>obj</i>. </p>
+         *
+         * <p> This member function calls the non-member function {@link IContainer.swap swap} (unqualified) to swap
+         * the {@link container_ underlying containers}. </p>
+         *
+         * @param obj Another {@link Queue} container adaptor of the same type (i.e., instantiated with the same
+         *			  template parameter, <b>T</b>). Sizes may differ. </p>
+         */
+        swap(obj: Queue<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * <p> Priority queue. </p>
+     *
+     * <p> {@link PriorityQueue Priority queues} are a type of container adaptors, specifically designed such that its
+     * first element is always the greatest of the elements it contains, according to some <i>strict weak ordering</i>
+     * criterion. </p>
+     *
+     * <p> This context is similar to a <i>heap</i>, where elements can be inserted at any moment, and only the
+     * <i>max heap</i> element can be retrieved (the one at the top in the {@link PriorityQueue priority queue}). </p>
+     *
+     * <p> {@link PriorityQueue Priority queues} are implemented as <i>container adaptors</i>, which are classes that
+     * use an encapsulated object of a specific container class as its {@link container_ underlying container},
+     * providing a specific set of member functions to access its elements. Elements are popped from the <i>"back"</i>
+     * of the specific container, which is known as the <i>top</i> of the {@link PriorityQueue Priority queue}. </p>
+     *
+     * <p> The {@link container_ underlying container} may be any of the standard container class templates or some
+     * other specifically designed container class. The container shall be accessible through
+     * {@link IArrayIterator random access iterators} and support the following operations: </p>
+     *
+     * <ul>
+     *	<li> empty() </li>
+     *	<li> size() </li>
+     *	<li> front() </li>
+     *	<li> push_back() </li>
+     *	<li> pop_back() </li>
+     * </ul>
+     *
+     * <p> The standard container classes {@link Vector} and {@link Deque} fulfill these requirements. By default, if
+     * no container class is specified for a particular {@link PriorityQueue} class instantiation, the standard
+     * container {@link Vector} is used. </p>
+     *
+     * <p> Support of {@link IArrayIterator random access iterators} is required to keep a heap structure internally
+     * at all times. This is done automatically by the container adaptor by automatically calling the algorithm
+     * functions <i>make_heap</i>, <i>push_heap</i> and <i>pop_heap</i> when needed. </p>
+     *
+     * @param <T> Type of the elements.
+     *
+     * @reference http://www.cplusplus.com/reference/queue/priority_queue/
+     * @author Jeongho Nam
+     */
+    class PriorityQueue<T> {
+        /**
+         * <p> The <i>underlying container</i> for implementing the <i>priority queue</i>. </p>
+         *
+         * <p> Following standard definition from the C++ committee, the <i>underlying container</i> should be one of
+         * {@link Vector} or {@link Deque}, however, I've adopted {@link TreeMultiSet} instead of them. Of course,
+         * there are proper reasons for adapting the {@link TreeMultiSet} even violating standard advice. </p>
+         *
+         * <p> <i>Underlying container</i> of {@link PriorityQueue} must keep a condition; the highest (or lowest)
+         * element must be placed on the terminal node for fast retrieval and deletion. To keep the condition with
+         * {@link Vector} or {@link Deque}, lots of times will only be spent for re-arranging elements. It calls
+         * rearrangement functions like <i>make_heap</i>, <i>push_heap</i> and <i>pop_head</i> for rearrangement. </p>
+         *
+         * <p> However, the {@link TreeMultiSet} container always keeps arrangment automatically without additional
+         * operations and it even meets full criteria of {@link PriorityQueue}. Those are the reason why I've adopted
+         * {@link TreeMultiSet} as the <i>underlying container</i> of {@link PriorityQueue}. </p>
+         */
+        private container_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from compare.
+         *
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(compare: (left: T, right: T) => boolean);
+        /**
+         * Contruct from elements.
+         *
+         * @param array Elements to be contained.
+         */
+        constructor(array: Array<T>);
+        /**
+         * Contruct from elements with compare.
+         *
+         * @param array Elements to be contained.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(array: Array<T>, compare: (left: T, right: T) => boolean);
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: base.IContainer<T>);
+        /**
+         * Copy Constructor with compare.
+         *
+         * @param container A container to be copied.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(container: base.IContainer<T>, compare: (left: T, right: T) => boolean);
+        /**
+         * Range Constructor.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * Range Constructor with compare.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>, compare: (left: T, right: T) => boolean);
+        /**
+         * <p> Return size. </p>
+         *
+         * <p> Returns the number of elements in the {@link PriorityQueue}. </p>
+         *
+         * <p> This member function effectively calls member {@link IArray.size size} of the
+         * {@link container_ underlying container} object. </p>
+         *
+         * @return The number of elements in the underlying
+         */
+        size(): number;
+        /**
+         * <p> Test whether container is empty. </p>
+         *
+         * <p> Returns whether the {@link PriorityQueue} is empty: i.e. whether its {@link size} is zero. </p>
+         *
+         * <p> This member function effectively calls member {@link IARray.empty empty} of the
+         * {@link container_ underlying container} object. </p>
+         */
+        empty(): boolean;
+        /**
+         * <p> Access top element. </p>
+         *
+         * <p> Returns a constant reference to the top element in the {@link PriorityQueue}. </p>
+         *
+         * <p> The top element is the element that compares higher in the {@link PriorityQueue}, and the next that is
+         * removed from the container when {@link PriorityQueue.pop} is called. </p>
+         *
+         * <p> This member function effectively calls member {@link IArray.front front} of the
+         * {@link container_ underlying container} object. </p>
+         *
+         * @return A reference to the top element in the {@link PriorityQueue}.
+         */
+        top(): T;
+        /**
+         * <p> Insert element. </p>
+         *
+         * <p> Inserts a new element in the {@link PriorityQueue}. The content of this new element is initialized to
+         * <i>val</i>.
+         *
+         * <p> This member function effectively calls the member function {@link IArray.push_back push_back} of the
+         * {@link container_ underlying container} object, and then reorders it to its location in the heap by calling
+         * the <i>push_heap</i> algorithm on the range that includes all the elements of the  </p>
+         *
+         * @param val Value to which the inserted element is initialized.
+         */
+        push(val: T): void;
+        /**
+         * <p> Remove top element. </p>
+         *
+         * <p> Removes the element on top of the {@link PriorityQueue}, effectively reducing its {@link size} by one.
+         * The element removed is the one with the highest (or lowest) value. </p>
+         *
+         * <p> The value of this element can be retrieved before being popped by calling member
+         * {@link PriorityQueue.top}. </p>
+         *
+         * <p> This member function effectively calls the <i>pop_heap</i> algorithm to keep the heap property of
+         * {@link PriorityQueue PriorityQueues} and then calls the member function {@link IArray.pop_back pop_back} of
+         * the {@link container_ underlying container} object to remove the element. </p>
+         */
+        pop(): void;
+        /**
+         * <p> Swap contents. </p>
+         *
+         * <p> Exchanges the contents of the container adaptor by those of <i>obj</i>, swapping both the
+         * {@link container_ underlying container} value and their comparison function using the corresponding
+         * {@link std.swap swap} non-member functions (unqualified). </p>
+         *
+         * <p> This member function has a <i>noexcept</i> specifier that matches the combined <i>noexcept</i> of the
+         * {@link IArray.swap swap} operations on the {@link container_ underlying container} and the comparison
+         * functions. </p>
+         *
+         * @param obj {@link PriorityQueue} container adaptor of the same type (i.e., instantiated with the same
+         *			  template parameters, <b>T</b>). Sizes may differ.
+         */
+        swap(obj: PriorityQueue<T>): void;
+    }
+}
+declare namespace std {
+    /**
+     * <p> LIFO stack. </p>
+     *
+     * <p> {@link Stack}s are a type of container adaptor, specifically designed to operate in a LIFO context
+     * (last-in first-out), where elements are inserted and extracted only from one end of the  </p>
+     *
+     * <p> {@link Stack}s are implemented as containers adaptors, which are classes that use an encapsulated object of
+     * a specific container class as its <i>underlying container</i>, providing a specific set of member functions to
+     * access its elements. Elements are pushed/popped from the {@link ILinearContainer.back back()} of the
+     * {@link ILinearContainer specific container}, which is known as the top of the {@link Stack}. </p>
+     *
+     * <p> {@link container_ The underlying container} may be any of the standard container class templates or some
+     * other specifically designed container class. The container shall support the following operations: </p>
+     *
+     * <ul>
+     *	<li> empty </li>
+     *	<li> size </li>
+     *	<li> front </li>
+     *	<li> back </li>
+     *	<li> push_back </li>
+     *	<li> pop_back </li>
+     * </ul>
+     *
+     * <p> The standard container classes {@link Vector}, {@link Deque} and {@link List} fulfill these requirements.
+     * By default, if no container class is specified for a particular {@link Stack} class instantiation, the standard
+     * container {@link List} is used. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/class_diagram/linear_containers.png" style="max-width: 100%" /></a>
+     * </p>
+     *
+     * @param <T> Type of elements.
+     *
+     * @reference http://www.cplusplus.com/reference/stack/stack
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class Stack<T> {
+        /**
+         * The <i>underlying object</i> for implementing the <i>LIFO</i>
+         */
+        private container_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Copy Constructor.
+         */
+        constructor(stack: Stack<T>);
+        /**
+         * <p> Return size. </p>
+         *
+         * <p> Returns the number of elements in the {@link Stack}. </p>
+         *
+         * <p> This member function effectively calls member {@link ILinearContainer.size size()} of the
+         * {@link container_ underlying container} object. </p>
+         *
+         * @return The number of elements in the {@link container_ underlying container}.
+         */
+        size(): number;
+        /**
+         * <p> Test whether container is empty. </p>
+         *
+         * <p> returns whether the {@link Stack} is empty: i.e. whether its <i>size</i> is zero. </p>
+         *
+         * <p> This member function effectively calls member {@link ILinearContainer.empty empty()} of the
+         * {@link container_ underlying container} object. </p>
+         *
+         * @return <code>true</code> if the <i>underlying container</i>'s size is 0,
+         *		   <code>false</code> otherwise. </p>
+         */
+        empty(): boolean;
+        /**
+         * <p> Access next element. </p>
+         *
+         * <p> Returns a value of the top element in the {@link Stack} </p>.
+         *
+         * <p> Since {@link Stack}s are last-in first-out containers, the top element is the last element inserted into
+         * the {@link Stack}. </p>
+         *
+         * <p> This member function effectively calls member {@link ILinearContainer.back back()} of the
+         * {@link container_ underlying container} object. </p>
+         *
+         * @return A value of the top element in the {@link Stack}.
+         */
+        top(): T;
+        /**
+         * <p> Insert element. </p>
+         *
+         * <p> Inserts a new element at the top of the {@link Stack}, above its current top element. </p>
+         *
+         * <p> This member function effectively calls the member function
+         * {@link ILinearContainer.push_back push_back()} of the {@link container_ underlying container} object. </p>
+         *
+         * @param val Value to which the inserted element is initialized.
+         */
+        push(val: T): void;
+        /**
+         * <p> Remove top element. </p>
+         *
+         * <p> Removes the element on top of the {@link Stack}, effectively reducing its size by one. </p>
+         *
+         * <p> The element removed is the latest element inserted into the {@link Stack}, whose value can be retrieved
+         * by calling member {@link top Stack.top()} </p>.
+         *
+         * <p> This member function effectively calls the member function {@link ILinearContainer.pop_back pop_back()}
+         * of the {@link container_ underlying container} object. </p>
+         */
+        pop(): void;
+        /**
+         * <p> Swap contents. </p>
+         *
+         * <p> Exchanges the contents of the container adaptor (<i>this</i>) by those of <i>obj</i>. </p>
+         *
+         * <p> This member function calls the non-member function {@link IContainer.swap swap} (unqualified) to swap
+         * the {@link container_ underlying containers}. </p>
+         *
+         * @param obj Another {@link Stack} container adaptor of the same type (i.e., instantiated with the same
+         *			  template parameter, <b>T</b>). Sizes may differ. </p>
+         */
+        swap(obj: Stack<T>): void;
+    }
+}
+declare namespace std.TreeSet {
+    type iterator<T> = std.SetIterator<T>;
+    type reverse_iterator<T> = std.SetReverseIterator<T>;
+}
+declare namespace std {
+    /**
+     * <p> Tree-structured set, <code>std::set</code> of STL. </p>
+     *
+     * <p> {@link TreeSet}s are containers that store unique elements following a specific order. </p>
+     *
+     * <p> In a {@link TreeSet}, the value of an element also identifies it (the value is itself the
+     * <i>key</i>, of type <i>T</i>), and each value must be unique. The value of the elements in a
+     * {@link TreeSet} cannot be modified once in the container (the elements are always const), but they
+     * can be inserted or removed from the container. </p>
+     *
+     * <p> Internally, the elements in a {@link TreeSet} are always sorted following a specific strict weak
+     * ordering criterion indicated by its internal comparison method (of {@link less}). </p>
+     *
+     * <p> {@link TreeSet} containers are generally slower than {@link HashSet} containers to access
+     * individual elements by their <i>key</i>, but they allow the direct iteration on subsets based on their
+     * order. </p>
+     *
+     * <p> {@link TreeSet}s are typically implemented as binary search trees. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /> </a></p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Ordered </dt>
+     *	<dd>
+     *		The elements in the container follow a strict order at all times. All inserted elements are
+     *		given a position in this order.
+     *	</dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     *
+     *	<dt> Unique keys </dt>
+     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements.
+     *			  Each element in an {@link TreeSet} is also uniquely identified by this value.
+     *
+     * @reference http://www.cplusplus.com/reference/set/set
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class TreeSet<T> extends base.UniqueSet<T> implements base.ITreeSet<T> {
+        /**
+         * @hidden
+         */
+        private tree_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from compare.
+         *
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(compare: (x: T, y: T) => boolean);
+        /**
+         * Contruct from elements.
+         *
+         * @param array Elements to be contained.
+         */
+        constructor(array: Array<T>);
+        /**
+         * Contruct from elements with compare.
+         *
+         * @param array Elements to be contained.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(array: Array<T>, compare: (x: T, y: T) => boolean);
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: TreeMultiSet<T>);
+        /**
+         * Copy Constructor with compare.
+         *
+         * @param container A container to be copied.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(container: TreeMultiSet<T>, compare: (x: T, y: T) => boolean);
+        /**
+         * Range Constructor.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * Construct from range and compare.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>, compare: (x: T, y: T) => boolean);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        key_comp(): (x: T, y: T) => boolean;
+        /**
+         * @inheritdoc
+         */
+        value_comp(): (x: T, y: T) => boolean;
+        /**
+         * @inheritdoc
+         */
+        lower_bound(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        upper_bound(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        equal_range(val: T): Pair<SetIterator<T>, SetIterator<T>>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_val(val: T): any;
+        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * <p> Swap content. </p>
+         *
+         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link TreeSet set} of the same type. Sizes abd container type may differ. </p>
+         *
+         * <p> After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects. </p>
+         *
+         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function. </p>
+         *
+         * @param obj Another {@link TreeSet set container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link TreeSet container}.
+         */
+        swap(obj: TreeSet<T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.IContainer<T>): void;
+    }
+}
+declare namespace std.TreeMap {
+    type iterator<Key, T> = std.MapIterator<Key, T>;
+    type reverse_iterator<Key, T> = std.MapReverseIterator<Key, T>;
+}
+declare namespace std {
+    /**
+     * <p> Tree-structured map, <code>std::map</code> of STL. </p>
+     *
+     * <p> {@link TreeMap TreeMaps} are associative containers that store elements formed by a combination of a
+     * <i>key value</i> (<i>Key</i>) and a <i>mapped value</i> (<i>T</i>), following order. </p>
+     *
+     * <p> In a {@link TreeMap}, the <i>key values</i> are generally used to sort and uniquely identify the elements,
+     * while the <i>mapped values</i> store the content associated to this key. The types of <i>key</i> and
+     * <i>mapped value</i> may differ, and are grouped together in member type <i>value_type</i>, which is a {@link Pair}
+     * type combining both: </p>
+     *
+     * <p> <code>typedef Pair<Key, T> value_type;</code> </p>
+     *
+     * <p> Internally, the elements in a {@link TreeMap} are always sorted by its <i>key</i> following a
+     * <i>strict weak ordering</i> criterion indicated by its internal comparison method {@link less}.
+     *
+     * <p> {@link TreeMap} containers are generally slower than {@link HashMap HashMap} containers to access individual
+     * elements by their <i>key</i>, but they allow the direct iteration on subsets based on their order. </p>
+     *
+     * <p> {@link TreeMap}s are typically implemented as binary search trees. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a></p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd> Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		 position in the container. </dd>
+     *
+     *	<dt> Ordered </dt>
+     *	<dd> The elements in the container follow a strict order at all times. All inserted elements are
+     *		 given a position in this order. </dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd> Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		 <i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>. </dd>
+     *
+     *	<dt> Unique keys </dt>
+     *	<dd> No two elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
+     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
+     *
+     * @reference http://www.cplusplus.com/reference/map/map
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class TreeMap<Key, T> extends base.UniqueMap<Key, T> implements base.ITreeMap<Key, T> {
+        /**
+         * @hidden
+         */
+        private tree_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from compare.
+         *
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(compare: (x: Key, y: Key) => boolean);
+        /**
+         * Contruct from elements.
+         *
+         * @param array Elements to be contained.
+         */
+        constructor(array: Array<Pair<Key, T>>);
+        /**
+         * Contruct from elements.
+         *
+         * @param array Elements to be contained.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(array: Array<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * Contruct from tuples.
+         *
+         * @param array Tuples to be contained.
+         */
+        constructor(array: Array<[Key, T]>);
+        /**
+         * Contruct from tuples.
+         *
+         * @param array Tuples to be contained.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(array: Array<[Key, T]>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * Copy Constructor.
+         *
+         * @param container Another map to copy.
+         */
+        constructor(container: TreeMap<Key, T>);
+        /**
+         * Copy Constructor.
+         *
+         * @param container Another map to copy.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(container: TreeMap<Key, T>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * Range Constructor.
+         *
+         * @param begin nput interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
+        /**
+         * Range Constructor.
+         *
+         * @param begin nput interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        key_comp(): (x: Key, y: Key) => boolean;
+        /**
+         * @inheritdoc
+         */
+        value_comp(): (x: Pair<Key, T>, y: Pair<Key, T>) => boolean;
+        /**
+         * @inheritdoc
+         */
+        lower_bound(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        upper_bound(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        equal_range(key: Key): Pair<MapIterator<Key, T>, MapIterator<Key, T>>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_pair(pair: Pair<Key, T>): any;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * <p> Swap content. </p>
+         *
+         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link TreeMap map} of the same type. Sizes abd container type may differ. </p>
+         *
+         * <p> After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects. </p>
+         *
+         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function. </p>
+         *
+         * @param obj Another {@link TreeMap map container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link TreeMap container}.
+         */
+        swap(obj: TreeMap<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.IContainer<Pair<Key, T>>): void;
+    }
+}
+declare namespace std.TreeMultiSet {
+    type iterator<T> = std.SetIterator<T>;
+    type reverse_iterator<T> = std.SetReverseIterator<T>;
+}
+declare namespace std {
+    /**
+     * <p> Tree-structured multiple-key set. </p>
+     *
+     * <p> {@link TreeMultiSet TreeMultiSets} are containers that store elements following a specific order, and
+     * where multiple elements can have equivalent values. </p>
+     *
+     * <p> In a {@link TreeMultiSet}, the value of an element also identifies it (the value is itself
+     * the <i>key</i>, of type <i>T</i>). The value of the elements in a {@link TreeMultiSet} cannot
+     * be modified once in the container (the elements are always const), but they can be inserted or removed
+     * from the container. </p>
+     *
+     * <p> Internally, the elements in a {@link TreeMultiSet TreeMultiSets} are always sorted following a strict
+     * weak ordering criterion indicated by its internal comparison method (of {@link IComparable.less less}). </p>
+     *
+     * <p> {@link TreeMultiSet} containers are generally slower than {@link HashMultiSet} containers
+     * to access individual elements by their <i>key</i>, but they allow the direct iteration on subsets based on
+     * their order. </p>
+     *
+     * <p> {@link TreeMultiSet TreeMultiSets} are typically implemented as binary search trees. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/set_containers.png" style="max-width: 100%" /> </a></p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Ordered </dt>
+     *	<dd>
+     *		The elements in the container follow a strict order at all times. All inserted elements are
+     *		given a position in this order.
+     *	</dd>
+     *
+     *	<dt> Set </dt>
+     *	<dd> The value of an element is also the <i>key</i> used to identify it. </dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <T> Type of the elements. Each element in a {@link TreeMultiSet} container is also identified
+     *			  by this value (each value is itself also the element's <i>key</i>).
+     *
+     * @reference http://www.cplusplus.com/reference/set/multiset
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class TreeMultiSet<T> extends base.MultiSet<T> implements base.ITreeSet<T> {
+        /**
+         * @hidden
+         */
+        private tree_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from compare.
+         *
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(compare: (x: T, y: T) => boolean);
+        /**
+         * Contruct from elements.
+         *
+         * @param array Elements to be contained.
+         */
+        constructor(array: Array<T>);
+        /**
+         * Contruct from elements with compare.
+         *
+         * @param array Elements to be contained.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(array: Array<T>, compare: (x: T, y: T) => boolean);
+        /**
+         * Copy Constructor.
+         */
+        constructor(container: TreeMultiSet<T>);
+        /**
+         * Copy Constructor with compare.
+         *
+         * @param container A container to be copied.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(container: TreeMultiSet<T>, compare: (x: T, y: T) => boolean);
+        /**
+         * Range Constructor.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>);
+        /**
+         * Construct from range and compare.
+         *
+         * @param begin Input interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(begin: Iterator<T>, end: Iterator<T>, compare: (x: T, y: T) => boolean);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        count(val: T): number;
+        /**
+         * @inheritdoc
+         */
+        key_comp(): (x: T, y: T) => boolean;
+        /**
+         * @inheritdoc
+         */
+        value_comp(): (x: T, y: T) => boolean;
+        /**
+         * @inheritdoc
+         */
+        lower_bound(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        upper_bound(val: T): SetIterator<T>;
+        /**
+         * @inheritdoc
+         */
+        equal_range(val: T): Pair<SetIterator<T>, SetIterator<T>>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_val(val: T): any;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_hint(hint: SetIterator<T>, val: T): SetIterator<T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<U extends T, InputIterator extends Iterator<U>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_insert(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_erase(first: SetIterator<T>, last: SetIterator<T>): void;
+        /**
+         * <p> Swap content. </p>
+         *
+         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link TreeMultiSet set} of the same type. Sizes abd container type may differ. </p>
+         *
+         * <p> After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects. </p>
+         *
+         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function. </p>
+         *
+         * @param obj Another {@link TreeMultiSet set container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link TreeMultiSet container}.
+         */
+        swap(obj: TreeMultiSet<T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.IContainer<T>): void;
+    }
+}
+declare namespace std.TreeMultiMap {
+    type iterator<Key, T> = std.MapIterator<Key, T>;
+    type reverse_iterator<Key, T> = std.MapReverseIterator<Key, T>;
+}
+declare namespace std {
+    /**
+     * <p> Tree-structured multiple-key map. </p>
+     *
+     * <p> {@link TreeMultiMap TreeMultiMaps} are associative containers that store elements formed by a combination of
+     * a <i>key value</i> and a <i>mapped value</i>, following a specific order, and where multiple elements can
+     * have equivalent keys. </p>
+     *
+     * <p> In a {@link TreeMultiMap}, the <i>key values</i> are generally used to sort and uniquely identify
+     * the elements, while the <i>mapped values</i> store the content associated to this <i>key</i>. The types of
+     * <i>key</i> and <i>mapped value</i> may differ, and are grouped together in member type
+     * <code>value_type</code>, which is a {@link Pair} type combining both: </p>
+     *
+     * <p> <code>typedef Pair<const Key, T> value_type;</code> </p>
+     *
+     * <p> Internally, the elements in a {@link TreeMultiMap}are always sorted by its key following a
+     * strict weak ordering criterion indicated by its internal comparison method (of {@link less}). </p>
+     *
+     * <p> {@link TreeMultiMap}containers are generally slower than {@link HashMap} containers
+     * to access individual elements by their <i>key</i>, but they allow the direct iteration on subsets based
+     * on their order. </p>
+     *
+     * <p> {@link TreeMultiMap TreeMultiMaps} are typically implemented as binary search trees. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" target="_blank"> <
+     * img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/map_containers.png" style="max-width: 100%" /> </a></p>
+     *
+     * <h3> Container properties </h3>
+     * <dl>
+     *	<dt> Associative </dt>
+     *	<dd>
+     *		Elements in associative containers are referenced by their <i>key</i> and not by their absolute
+     *		position in the container.
+     *	</dd>
+     *
+     *	<dt> Ordered </dt>
+     *	<dd>
+     *		The elements in the container follow a strict order at all times. All inserted elements are
+     *		given a position in this order.
+     *	</dd>
+     *
+     *	<dt> Map </dt>
+     *	<dd>
+     *		Each element associates a <i>key</i> to a <i>mapped value</i>:
+     *		<i>Keys</i> are meant to identify the elements whose main content is the <i>mapped value</i>.
+     *	</dd>
+     *
+     *	<dt> Multiple equivalent keys </dt>
+     *	<dd> Multiple elements in the container can have equivalent <i>keys</i>. </dd>
+     * </dl>
+     *
+     * @param <Key> Type of the keys. Each element in a map is uniquely identified by its key value.
+     * @param <T> Type of the mapped value. Each element in a map stores some data as its mapped value.
+     *
+     * @reference http://www.cplusplus.com/reference/map/multimap
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class TreeMultiMap<Key, T> extends base.MultiMap<Key, T> implements base.ITreeMap<Key, T> {
+        /**
+         * @hidden
+         */
+        private tree_;
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from compare.
+         *
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(compare: (x: Key, y: Key) => boolean);
+        /**
+         * Contruct from elements.
+         *
+         * @param array Elements to be contained.
+         */
+        constructor(array: Array<Pair<Key, T>>);
+        /**
+         * Contruct from elements.
+         *
+         * @param array Elements to be contained.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(array: Array<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * Contruct from tuples.
+         *
+         * @param array Tuples to be contained.
+         */
+        constructor(array: Array<[Key, T]>);
+        /**
+         * Contruct from tuples.
+         *
+         * @param array Tuples to be contained.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(array: Array<[Key, T]>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * Copy Constructor.
+         *
+         * @param container Another map to copy.
+         */
+        constructor(container: TreeMultiMap<Key, T>);
+        /**
+         * Copy Constructor.
+         *
+         * @param container Another map to copy.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(container: TreeMultiMap<Key, T>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * Range Constructor.
+         *
+         * @param begin nput interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         */
+        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>);
+        /**
+         * Range Constructor.
+         *
+         * @param begin nput interator of the initial position in a sequence.
+         * @param end Input interator of the final position in a sequence.
+         * @param compare A binary predicate determines order of elements.
+         */
+        constructor(begin: Iterator<Pair<Key, T>>, end: Iterator<Pair<Key, T>>, compare: (x: Key, y: Key) => boolean);
+        /**
+         * @inheritdoc
+         */
+        clear(): void;
+        /**
+         * @inheritdoc
+         */
+        find(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        count(key: Key): number;
+        /**
+         * @inheritdoc
+         */
+        key_comp(): (x: Key, y: Key) => boolean;
+        /**
+         * @inheritdoc
+         */
+        value_comp(): (x: Pair<Key, T>, y: Pair<Key, T>) => boolean;
+        /**
+         * @inheritdoc
+         */
+        lower_bound(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        upper_bound(key: Key): MapIterator<Key, T>;
+        /**
+         * @inheritdoc
+         */
+        equal_range(key: Key): Pair<MapIterator<Key, T>, MapIterator<Key, T>>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_pair(pair: Pair<Key, T>): any;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_hint(hint: MapIterator<Key, T>, pair: Pair<Key, T>): MapIterator<Key, T>;
+        /**
+         * @hidden
+         */
+        protected _Insert_by_range<L extends Key, U extends T, InputIterator extends Iterator<Pair<L, U>>>(first: InputIterator, last: InputIterator): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_insert(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        protected _Handle_erase(first: MapIterator<Key, T>, last: MapIterator<Key, T>): void;
+        /**
+         * <p> Swap content. </p>
+         *
+         * <p> Exchanges the content of the container by the content of <i>obj</i>, which is another
+         * {@link TreeMapMulti map} of the same type. Sizes abd container type may differ. </p>
+         *
+         * <p> After the call to this member function, the elements in this container are those which were
+         * in <i>obj</i> before the call, and the elements of <i>obj</i> are those which were in this. All
+         * iterators, references and pointers remain valid for the swapped objects. </p>
+         *
+         * <p> Notice that a non-member function exists with the same name, {@link std.swap swap}, overloading that
+         * algorithm with an optimization that behaves like this member function. </p>
+         *
+         * @param obj Another {@link TreeMapMulti map container} of the same type of elements as this (i.e.,
+         *			  with the same template parameters, <b>Key</b> and <b>T</b>) whose content is swapped
+         *			  with that of this {@link TreeMapMulti container}.
+         */
+        swap(obj: TreeMultiMap<Key, T>): void;
+        /**
+         * @inheritdoc
+         */
+        swap(obj: base.IContainer<Pair<Key, T>>): void;
+    }
+}
+declare namespace std {
+    /**
+     * <p> System error exception. </p>
+     *
+     * <p> This class defines the type of objects thrown as exceptions to report conditions originating during
+     * runtime from the operating system or other low-level application program interfaces which have an
+     * associated {@link ErrorCode}. </p>
+     *
+     * <p> The class inherits from {@link RuntimeError}, to which it adds an {@link ErrorCode} as
+     * member code (and defines a specialized what member). </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
+     *
+     * @reference http://www.cplusplus.com/reference/system_error/system_error
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class SystemError extends RuntimeError {
+        /**
+         * @hidden
+         */
+        protected code_: ErrorCode;
+        /**
+         * Construct from an error code.
+         *
+         * @param code An {@link ErrorCode} object.
+         */
+        constructor(code: ErrorCode);
+        /**
+         * Construct from an error code and message.
+         *
+         * @param code An {@link ErrorCode} object.
+         * @param message A message incorporated in the string returned by member {@link what what()}.
+         */
+        constructor(code: ErrorCode, message: string);
+        /**
+         * Construct from a numeric value and error category.
+         *
+         * @param val A numerical value identifying an error code.
+         * @param category A reference to an {@link ErrorCode} object.
+         */
+        constructor(val: number, category: ErrorCategory);
+        /**
+         * Construct from a numeric value, error category and message.
+         *
+         * @param val A numerical value identifying an error code.
+         * @param category A reference to an {@link ErrorCode} object.
+         * @param message A message incorporated in the string returned by member {@link what what()}.
+         */
+        constructor(val: number, category: ErrorCategory, message: string);
+        /**
+         * <p> Get error code. </p>
+         *
+         * <p> Returns the {@link ErrorCode} object associated with the exception. </p>
+         *
+         * <p> This value is either the {@link ErrorCode} passed to the construction or its equivalent
+         * (if constructed with a value and a {@link category}. </p>
+         *
+         * @return The {@link ErrorCode} associated with the object.
+         */
+        code(): ErrorCode;
+    }
+}
+declare namespace std {
+    /**
+     * <p> Error category. </p>
+     *
+     * <p> This type serves as a base class for specific category types. </p>
+     *
+     * <p> Category types are used to identify the source of an error. They also define the relation between
+     * {@link ErrorCode} and {@link ErrorCondition}objects of its category, as well as the message set for {@link ErrorCode}
+     * objects.
+     *
+     * <p> Objects of these types have no distinct values and are not-copyable and not-assignable, and thus can only be
+     * passed by reference. As such, only one object of each of these types shall exist, each uniquely identifying its own
+     * category: all error codes and conditions of a same category shall return a reference to same object. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
+     *
+     * @reference http://www.cplusplus.com/reference/system_error/error_category
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    abstract class ErrorCategory {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * <p> Return category name. </p>
+         *
+         * <p> In derived classes, the function returns a string naming the category. </p>
+         *
+         * <p> In {@link ErrorCategory}, it is a pure virtual member function. </p>
+         *
+         * <ul>
+         *	<li> In the {@link GenericCategory} object, it returns <i>"generic"</i>. </li>
+         *	<li> In the {@link SystemCategory} object, it returns <i>"system"</i>. </li>
+         *	<li> In the {@link IOStreamCategory} object, it returns <i>"iostream"</i>. </li>
+         * </ul>
+         *
+         * @return The category name.
+         */
+        abstract name(): string;
+        /**
+         * <p> Error message. </p>
+         *
+         * <p> In derived classes, the function returns a string object with a message describing the error condition
+         * denoted by <i>val</i>. </p>
+         *
+         * <p> In {@link ErrorCategory}, it is a pure virtual member function. </p>
+         *
+         * <p> This function is called both by {@link ErrorCode.message ErrorCode.message()} and
+         * {@link ErrorCondition.message ErrorCondition.message()} to obtain the corresponding message in the
+         * {@link category}. Therefore, numerical values used by custom <i>error codes</i> and
+         * {@link ErrorCondition error conditions} should only match for a category if they describe the same error. </p>
+         *
+         * @param val A numerical value identifying an error condition.
+         *			  If the {@link ErrorCategory} object is the {@link GenericCategory}, this argument is equivalent to an
+         *			  {@link errno} value.
+         *
+         * @return A string object with the message.
+         */
+        abstract message(val: number): string;
+        /**
+         * <p> Default error condition. </p>
+         *
+         * <p> Returns the default {@link ErrorCondition}object of this category that is associated with the
+         * {@link ErrorCode} identified by a value of <i>val</i>. </p>
+         *
+         * <p> Its definition in the base class {@link ErrorCategory} returns the same as constructing an
+         * {@link ErrorCondition} object with:
+         *
+         * <p> <code>new ErrorCondition(val, *this);</code> </p>
+         *
+         * <p> As a virtual member function, this behavior can be overriden in derived classes. </p>
+         *
+         * <p> This function is called by the default definition of member {@link equivalent equivalent()}, which is used to
+         * compare {@link ErrorCondition error conditions} with error codes. </p>
+         *
+         * @param val A numerical value identifying an error condition.
+         *
+         * @return The default {@link ErrorCondition}object associated with condition value <i>val</i> for this category.
+         */
+        default_error_condition(val: number): ErrorCondition;
+        /**
+         * <p> Check error code equivalence. </p>
+         *
+         * <p> Checks whether, for the category, an {@link ErrorCode error code} is equivalent to an
+         * {@link ErrorCondition error condition. </p>
+         *
+         * <p> This function is called by the overloads of comparison operators when an {@link ErrorCondition} object is
+         * compared to an {@link ErrorCode} object to check for equality or inequality. If either one of those objects'
+         * {@link ErrorCategory categories} considers the other equivalent using this function, they are considered
+         * equivalent by the operator. </p>
+         *
+         * <p> As a virtual member function, this behavior can be overridden in derived classes to define a different
+         * correspondence mechanism for each {@link ErrorCategory} type. </p>
+         *
+         * @param val_code A numerical value identifying an error code.
+         * @param cond An object of an {@link ErrorCondition} type.
+         *
+         * @return <code>true</code> if the arguments are considered equivalent. <code>false</code> otherwise.
+         */
+        equivalent(val_code: number, cond: ErrorCondition): boolean;
+        /**
+         * <p> Check error code equivalence. </p>
+         *
+         * <p> Checks whether, for the category, an {@link ErrorCode error code} is equivalent to an
+         * {@link ErrorCondition error condition. </p>
+         *
+         * <p> This function is called by the overloads of comparison operators when an {@link ErrorCondition} object is
+         * compared to an {@link ErrorCode} object to check for equality or inequality. If either one of those objects'
+         * {@link ErrorCategory categories} considers the other equivalent using this function, they are considered
+         * equivalent by the operator. </p>
+         *
+         * <p> As a virtual member function, this behavior can be overridden in derived classes to define a different
+         * correspondence mechanism for each {@link ErrorCategory} type. </p>
+         *
+         * @param code An object of an {@link ErrorCode} type.
+         * @param val_cond A numerical value identifying an error code.
+         *
+         * @return <code>true</code> if the arguments are considered equivalent. <code>false</code> otherwise.
+         */
+        equivalent(code: ErrorCode, val_cond: number): boolean;
+    }
+}
+declare namespace std {
+    /**
+     * <p> Error condition. </p>
+     *
+     * <p> Objects of this type hold a condition {@link value} associated with a {@link category}. </p>
+     *
+     * <p> Objects of this type describe errors in a generic way so that they may be portable across different
+     * systems. This is in contrast with {@link ErrorCode} objects, that may contain system-specific
+     * information. </p>
+     *
+     * <p> Because {@link ErrorCondition}objects can be compared with error_code objects directly by using
+     * <code>relational operators</code>, {@link ErrorCondition}objects are generally used to check whether
+     * a particular {@link ErrorCode} obtained from the system matches a specific error condition no matter
+     * the system. </p>
+     *
+     * <p> The {@link ErrorCategory categories} associated with the {@link ErrorCondition} and the
+     * {@link ErrorCode} define the equivalences between them. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
+     *
+     * @reference http://www.cplusplus.com/reference/system_error/error_condition
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class ErrorCondition extends base.ErrorInstance {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from a numeric value and error category.
+         *
+         * @param val A numerical value identifying an error condition.
+         * @param category A reference to an {@link ErrorCategory} object.
+         */
+        constructor(val: number, category: ErrorCategory);
+    }
+}
+declare namespace std {
+    /**
+     * <p> Error code. </p>
+     *
+     * <p> Objects of this type hold an error code {@link value} associated with a {@link category}. </p>
+     *
+     * <p> The operating system and other low-level applications and libraries generate numerical error codes to
+     * represent possible results. These numerical values may carry essential information for a specific platform,
+     * but be non-portable from one platform to another. </p>
+     *
+     * <p> Objects of this class associate such numerical codes to {@link ErrorCategory error categories}, so that they
+     * can be interpreted when needed as more abstract (and portable) {@link ErrorCondition error conditions}. </p>
+     *
+     * <p> <a href="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" target="_blank">
+     * <img src="http://samchon.github.io/typescript-stl/images/design/class_diagram/exceptions.png" style="max-width: 100%" /> </a> </p>
+     *
+     * @reference http://www.cplusplus.com/reference/system_error/error_code
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class ErrorCode extends base.ErrorInstance {
+        /**
+         * Default Constructor.
+         */
+        constructor();
+        /**
+         * Construct from a numeric value and error category.
+         *
+         * @param val A numerical value identifying an error code.
+         * @param category A reference to an {@link ErrorCategory} object.
+         */
+        constructor(val: number, category: ErrorCategory);
+    }
+}
+declare namespace std {
+    /**
+     * <p> Running on Node. </p>
+     *
+     * <p> Test whether the JavaScript is running on Node. </p>
+     *
+     * @references http://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser
+     */
+    function is_node(): boolean;
+    /**
+     * <p> Pair of values. </p>
+     *
+     * <p> This class couples together a pair of values, which may be of different types (<i>T1</i> and
+     * <i>T2</i>). The individual values can be accessed through its public members {@link first} and
+     * {@link second}. </p>
+     *
+     * @param <T1> Type of member {@link first}.
+     * @param <T2> Type of member {@link second}.
+     *
+     * @reference http://www.cplusplus.com/reference/utility/pair
+     * @author Jeongho Nam <http://samchon.org>
+     */
+    class Pair<T1, T2> {
+        /**
+         * <p> A first value in the Pair. </p>
+         */
+        first: T1;
+        /**
+         * <p> A second value in the Pair. </p>
+         */
+        second: T2;
+        /**
+         * <p> Construct from pair values. </p>
+         *
+         * @param first The first value of the Pair
+         * @param second The second value of the Pair
+         */
+        constructor(first: T1, second: T2);
+        /**
+         * <p> Whether a Pair is equal with the Pair. <p>
+         * <p> Compare each first and second value of two Pair(s) and returns whether they are equal or not. </p>
+         *
+         * <p> If stored key and value in a Pair are not number or string but an object like a class or struct,
+         * the comparison will be executed by a member method (SomeObject)::equal_to(). If the object does not have
+         * the member method equal_to(), only address of pointer will be compared. </p>
+         *
+         * @param obj A Map to compare
+         * @return Indicates whether equal or not.
+         */
+        equal_to<U1 extends T1, U2 extends T2>(pair: Pair<U1, U2>): boolean;
+        less<U1 extends T1, U2 extends T2>(pair: Pair<U1, U2>): boolean;
+    }
+    /**
+     * <p> Construct {@link Pair} object. </p>
+     *
+     * <p> Constructs a {@link Pair} object with its {@link Pair.first first} element set to <i>x</i> and its
+     * {@link Pair.second second} element set to <i>y</i>. </p>
+     *
+     * <p> The template types can be implicitly deduced from the arguments passed to {@link make_pair}. </p>
+     *
+     * <p> {@link Pair} objects can be constructed from other {@link Pair} objects containing different types, if the
+     * respective types are implicitly convertible. </p>
+     *
+     * @param x Value for member {@link Pair.first first}.
+     * @param y Value for member {@link Pair.second second}.
+     *
+     * @return A {@link Pair} object whose elements {@link Pair.first first} and {@link Pair.second second} are set to
+     *		   <i>x</i> and <i>y</i> respectivelly.
+     */
+    function make_pair<T1, T2>(x: T1, y: T2): Pair<T1, T2>;
+}
+declare namespace std {
+    /**
+     * Type definition of {@link Vector} and it's the original name used in C++.
+     */
+    export import vector = Vector;
+    /**
+     * Type definition of {@link List} and it's the original name used in C++.
+     */
+    export import list = List;
+    /**
+     * Type definition of {@link Deque} and it's the original name used in C++.
+     */
+    export import deque = Deque;
+    /**
+     * Type definition of {@link Stack} and it's the original name used in C++.
+     */
+    type stack<T> = Stack<T>;
+    /**
+     * Type definition of {@link Queue} and it's the original name used in C++.
+     */
+    type queue<T> = Queue<T>;
+    /**
+     * Type definition of {@link PriorityQueue} and it's the original name used in C++.
+     */
+    type priority_queue<T> = PriorityQueue<T>;
+    var stack: typeof Stack;
+    var queue: typeof Queue;
+    var priority_queue: typeof PriorityQueue;
+    /**
+     * Type definition of {@link TreeSet} and it's the original name used in C++.
+     */
+    export import set = TreeSet;
+    /**
+     * Type definition of {@link TreeMultiSet} and it's the original name used in C++.
+     */
+    export import multiset = TreeMultiSet;
+    /**
+     * Type definition of {@link HashSet} and it's the original name used in C++.
+     */
+    export import unordered_set = HashSet;
+    /**
+     * Type definition of {@link HashMultiSet} and it's the original name used in C++.
+     */
+    export import unordered_multiset = HashMultiSet;
+    /**
+     * Type definition of {@link TreeMap} and it's the original name used in C++.
+     */
+    export import map = TreeMap;
+    /**
+     * Type definition of {@link TreeMultiMap} and it's the original name used in C++.
+     */
+    export import multimap = TreeMultiMap;
+    /**
+     * Type definition of {@link HashMap} and it's the original name used in C++.
+     */
+    export import unordered_map = HashMap;
+    /**
+     * Type definition of {@link HashMultiMap} and it's the original name used in C++.
+     */
+    export import unordered_multimap = HashMultiMap;
+    type exception = Exception;
+    type logic_error = LogicError;
+    type domain_error = DomainError;
+    type invalid_argument = InvalidArgument;
+    type length_error = LengthError;
+    type out_of_range = OutOfRange;
+    type runtime_error = RuntimeError;
+    type overflow_error = OverflowError;
+    type underflow_error = UnderflowError;
+    type range_error = RangeError;
+    type system_error = SystemError;
+    type error_category = ErrorCategory;
+    type error_condition = ErrorCondition;
+    type error_code = ErrorCode;
+    var exception: typeof Exception;
+    var logic_error: typeof LogicError;
+    var domain_error: typeof DomainError;
+    var invalid_argument: typeof InvalidArgument;
+    var length_error: typeof LengthError;
+    var out_of_range: typeof OutOfRange;
+    var runtime_error: typeof RuntimeError;
+    var overflow_error: typeof OverflowError;
+    var underflow_error: typeof UnderflowError;
+    var range_error: typeof RangeError;
+    var system_error: typeof SystemError;
+    var error_category: typeof ErrorCategory;
+    var error_condition: typeof ErrorCondition;
+    var error_code: typeof ErrorCode;
+}

From c4e76d4c4c598290f1d0d6666917ef0ebc3452cc Mon Sep 17 00:00:00 2001
From: Richard Natal <Bigous@users.noreply.github.com>
Date: Fri, 7 Oct 2016 16:47:19 -0300
Subject: [PATCH 12/24] feat(oracledb): Update definitions to match oracledb
 v1.11.0 (#11808)

Signed-off-by: Richard Natal <bigous@gmail.com>
---
 oracledb/index.d.ts | 1251 +++++++++++++++++++++++--------------------
 1 file changed, 673 insertions(+), 578 deletions(-)

diff --git a/oracledb/index.d.ts b/oracledb/index.d.ts
index a6449fff1e..17ade85591 100644
--- a/oracledb/index.d.ts
+++ b/oracledb/index.d.ts
@@ -1,589 +1,684 @@
-// Type definitions for oracledb v1.5.0
+// Type definitions for oracledb v1.11.0
 // Project: https://github.com/oracle/node-oracledb
 // Definitions by: Richard Natal <https://github.com/Bigous>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /// <reference types="node" />
 
+import * as stream from 'stream';
+import * as events from 'events';
 
-import * as stream from "stream";
+declare namespace oracledb {
 
-export type TRet<T> = T | IPromise<T>;
-export type TFunc<T, R> = (value: T) => TRet<R>;
+	type TRet<T> = T | IPromise<T>;
+	type TFunc<T, R> = (value: T) => TRet<R>;
 
-export interface IPromise<T> {
-    catch<R>(onReject: TFunc<any, R>) : IPromise<R>;
-    then<R>(onResolve?: TFunc<T, R>, onReject?: TFunc<any, R>) : IPromise<R>;
+	interface IPromise<T> {
+		catch<R>(onReject: TFunc<any, R>) : IPromise<R>;
+		then<R>(onResolve?: TFunc<T, R>, onReject?: TFunc<any, R>) : IPromise<R>;
+	}
+
+	interface ILob {
+		chunkSize: number;
+		length: number;
+		pieceSize: number;
+		offset?: number;
+		type: string;
+		/**
+		 * Release method on ILob class.
+		 * @remarks The cleanup() called by Release() only frees OCI error handle and Lob
+		 *          locator.  These calls acquire mutex on OCI environment handle very briefly.
+		 */
+		release?(): void;
+		/**
+		 * Read method on ILob class.
+		 * @param {(err : any, chunk: string | Buffer) => void} callback Callback to recive the data from lob.
+		 * @remarks CLobs send strings while BLobs send Buffer object.
+		 */
+		read?(callback: (err: any, chunk: string | Buffer) => void): void;
+		/**
+		 * Read method on ILob class.
+		 * @param {Buffer} data Data write into Lob.
+		 * @param {(err: any) => void} callback Callback executed when writ is finished or when some error occured.
+		 * @remarks CLobs send strings while BLobs send Buffer object.
+		 */
+		write?(data: Buffer, callback: (err: any) => void): void;
+	}
+
+	/* tslint:disable-next-line:interface-name */
+	interface Lob extends stream.Duplex {
+		iLob: ILob;
+		/** This corresponds to the size used by the Oracle LOB layer when accessing or modifying the LOB value. */
+		chunkSize: number;
+		/** Length of a queried LOB in bytes (for BLOBs) or characters (for CLOBs). */
+		length: number;
+		/**
+		 * he number of bytes (for BLOBs) or characters (for CLOBs) to read for each Stream 'data' event of a queried LOB.
+		 * The default value is chunkSize.
+		 * For efficiency, it is recommended that pieceSize be a multiple of chunkSize.
+		 * The maximum value for pieceSize is limited to the value of UINT_MAX.
+		 */
+		pieceSize: number;
+		/**
+		 * This read-only attribute shows the type of Lob being used. It will have the value of one of the constants Oracledb.BLOB or Oracledb.CLOB. The value is derived from the bind type when using LOB bind variables, or from the column type when a LOB is returned by a query.
+		 */
+		type: number;
+
+		/**
+		 * Do not call this... used internally by node-oracledb
+		 */
+		constructor(iLob: ILob, opts: stream.DuplexOptions): Lob;
+		constructor(iLob: ILob): Lob;
+
+		/**
+		 * Closes the current LOB.
+		 * @param  {(err: any) => void} callback? When passed, is called after the release.
+		 * @returns void
+		 */
+		close(callback: (err: any) => void): void;
+		close(): void;
+	}
+
+	interface IConnectionAttributes {
+		user?: string;
+		password?: string;
+		connectString: string;
+		stmtCacheSize?: number;
+		externalAuth?: boolean;
+		/** If not passed, "default" will be used. */
+		poolAlias?: string;
+	}
+
+	interface IPoolAttributes extends IConnectionAttributes {
+		poolMax?: number;
+		poolMin?: number;
+		poolIncrement?: number;
+		poolTimeout?: number;
+	}
+
+	interface IExecuteOptions {
+		/**
+		 * Transaction should auto commit after each statement?
+		 * Overrides Oracledb autoCommit.
+		 */
+		autoCommit?: boolean;
+		/**
+		 * Determines whether additional metadata is available for queries and for REF CURSORs returned from PL/SQL blocks.
+		 * Overrides Oracledb extendedMetaData.
+		 */
+		extendedMetaData?: boolean;
+		/**
+		 * Object defining how query column data should be represented in JavaScript.
+		 * The fetchInfo property can be used to indicate that number or date columns in a query should be returned as strings instead of their native format. The property can be used in conjunction with, or instead of, the global setting fetchAsString.
+		 * For example:
+		 *
+		 * fetchInfo:
+		 * {
+		 *   "HIRE_DATE":      { type : oracledb.STRING },  // return the date as a string
+		 *   "COMMISSION_PCT": { type : oracledb.DEFAULT }  // override Oracledb.fetchAsString
+		 * }
+		 *
+		 * Each column is specified by name, using Oracle's standard naming convention.
+		 * The valid values for type are STRING and DEFAULT. The former indicates that the given column should be returned as a string. The latter can be used to override any global mapping given by fetchAsString and allow the column data for this query to be returned in native format.
+		 * The maximum length of a string created by type mapping is 200 bytes. However, if a database column that is already of type STRING is specified in fetchInfo, then the actual database metadata will be used to determine the maximum length.
+		 * Columns fetched from REF CURSORS are not mapped by fetchInfo settings in the execute() call. Use the global fetchAsString instead.
+		 */
+		fetchInfo?: Object;
+		/**
+		 * Maximum number of rows that will be retrieved. Used when resultSet is false.
+		 * Overrides Oracledb maxRows.
+		 */
+		maxRows?: number;
+		/**
+		 * Result format - ARRAY o OBJECT
+		 * Overrides Oracledb outFormat.
+		 */
+		outFormat?: number;
+		/**
+		 * Number of rows to be fetched in advance.
+		 * Overrides Oracledb prefetchRows.
+		 */
+		prefetchRows?: number;
+		/**
+		 * Determines whether query results should be returned as a ResultSet object or directly. The default is false.
+		 */
+		resultSet?: boolean;
+	}
+
+	interface IExecuteReturn {
+		/** Metadata information - column names is always given. If the Oracledb extendedMetaData or execute() option extendedMetaData are true then additional information is included. */
+		metaData?: Array<IMetaData>;
+		/** This is either an array or an object containing OUT and IN OUT bind values. If bindParams is passed as an array, then outBinds is returned as an array. If bindParams is passed as an object, then outBinds is returned as an object. */
+		outBinds?: Array<any> | Object;
+		/** For SELECT statements when the resultSet option is true, use the resultSet object to fetch rows. See ResultSet Class. */
+		resultSet?: IResultSet;
+		/** For SELECT statements where the resultSet option is false or unspecified, rows contains an array of fetched rows. It will be NULL if there is an error or the SQL statement was not a SELECT statement. By default, the rows are in an array of column value arrays, but this can be changed to arrays of objects by setting outFormat to OBJECT. If a single row is fetched, then rows is an array that contains one single row. The number of rows returned is limited to the maxRows configuration property of the Oracledb object, although this may be overridden in any execute() call. */
+		rows?: Array<Array<any>> | Array<any>;
+		/** For DML statements (including SELECT FOR UPDATE) this contains the number of rows affected, for example the number of rows inserted. For non-DML statements such as queries, or if no rows are affected, then rowsAffected will be zero. */
+		rowsAffected?: number;
+	}
+
+	interface IMetaData {
+		/** The column name follows Oracle's standard name-casing rules. It will commonly be uppercase, since most applications create tables using unquoted, case-insensitive names. */
+		name: string;
+		/** one of the Node-oracledb Type Constant values. */
+		fetchType?: number;
+		/** one of the Node-oracledb Type Constant values. */
+		dbType?: number;
+		/** the database byte size. This is only set for DB_TYPE_VARCHAR, DB_TYPE_CHAR and DB_TYPE_RAW column types. */
+		byteSize?: number;
+		/** set only for DB_TYPE_NUMBER, DB_TYPE_TIMESTAMP, DB_TYPE_TIMESTAMP_TZ and DB_TYPE_TIMESTAMP_LTZ columns. */
+		precision?: number;
+		/** set only for DB_TYPE_NUMBER columns. */
+		scale: number;
+		/** indicates whether NULL values are permitted for this column. */
+		nullable?: boolean;
+	}
+
+	interface IResultSet {
+		/**
+		 * Contains an array of objects with metadata about the query or REF CURSOR columns.
+		 * Each column's name is always given. If the Oracledb extendedMetaData or execute() option extendedMetaData are true then additional information is included.
+		 */
+		metaData?: Array<IMetaData>;
+
+		/**
+		 * Closes a ResultSet. Applications should always call this at the end of fetch or when no more rows are needed.
+		 * @param  {(err:any)=>void} callback Callback called on finish or when some error occurs.
+		 * @returns void
+		 * @remarks Applications should always call this at the end of fetch or when no more rows are needed.
+		 */
+		close(callback: (err: any) => void): void;
+
+		/**
+		 * Closes a ResultSet. Applications should always call this at the end of fetch or when no more rows are needed.
+		 * @returns  A void Promise on finish or when some error occurs.
+		 * @remarks Applications should always call this at the end of fetch or when no more rows are needed.
+		 */
+		close(): IPromise<void>;
+
+		/**
+		 * This call fetches one row of the result set as an object or an array of column values, depending on the value of outFormat.
+		 * At the end of fetching, the ResultSet should be freed by calling close().
+		 * @param  {(err:any,row:Array<any>|Object)=>void} callback Callback called when the row is available or when some error occurs.
+		 * @returns void
+		 */
+		getRow(callback: (err: any, row: Array<any> | Object) => void): void;
+
+		/**
+		 * This call fetches one row of the result set as an object or an array of column values, depending on the value of outFormat.
+		 * At the end of fetching, the ResultSet should be freed by calling close().
+		 * @returns Promise when the row is available or when some error occurs.
+		 */
+		getRow(): IPromise<Array<any> | Object>;
+
+		/**
+		 * This synchronous method converts a ResultSet into a stream.
+		 * It can be used to make ResultSets from top-level queries or from REF CURSOR bind variables streamable. To make top-level queries streamable, the alternative connection.queryStream() method may be easier to use.
+		 * @returns synchronous stream of result set.
+		 */
+		toQueryStream(): stream.Readable;
+	}
+
+	/** Emits "_after_close" event */
+	interface IConnection extends events.EventEmitter {
+		/**
+		 * The action attribute for end-to-end application tracing.
+		 * This is a write-only property. Displaying a Connection object will show a value of null for this attribute. See End-to-end Tracing, Mid-tier Authentication, and Auditing.
+		 */
+		action: string;
+		/**
+		 * The client identifier for end-to-end application tracing, use with mid-tier authentication, and with Virtual Private Databases.
+		 * This is a write-only property. Displaying a Connection object will show a value of null for this attribute. See End-to-end Tracing, Mid-tier Authentication, and Auditing.
+		 */
+		clientId: string;
+		/**
+		 * The module attribute for end-to-end application tracing.
+		 * This is a write-only property. Displaying a Connection object will show a value of null for this attribute. See End-to-end Tracing, Mid-tier Authentication, and Auditing.
+		 */
+		module: string;
+		/**
+		 * This readonly property gives a numeric representation of the Oracle database version. For version a.b.c.d.e, this property gives the number: (100000000 * a) + (1000000 * b) + (10000 * c) + (100 * d) + e
+		 */
+		oracleServerVersion: number;
+		/**
+		 * The number of statements to be cached in the statement cache of the connection. The default value is the stmtCacheSize property in effect in the Pool object when the connection is created in the pool.
+		 */
+		stmtCacheSize: number;
+
+		/**
+		 * This call stops the currently running operation on the connection.
+		 * If there is no operation in progress or the operation has completed by the time the break is issued, the break() is effectively a no-op.
+		 * If the running asynchronous operation is interrupted, its callback will return an error.
+		 * @param	{(err: any) => void} callback Callback on break done.
+		 */
+		break(callback: (err: any) => void): void;
+
+		/**
+		 * This call stops the currently running operation on the connection.
+		 * If there is no operation in progress or the operation has completed by the time the break is issued, the break() is effectively a no-op.
+		 * If the running asynchronous operation is interrupted, its callback will return an error.
+		 * @returns	A void promise when break is done.
+		 */
+		break(): IPromise<void>;
+
+		/**
+		 * Releases a connection. If the connection was obtained from the pool, the connection is returned to the pool and is available for reuse.
+		 * Note: calling close() when connections are no longer required is strongly encouraged. Releasing helps avoid resource leakage and can improve system efficiency.
+		 * When a connection is released, any ongoing transaction on the connection is rolled back.
+		 * After releasing a connection to a pool, there is no guarantee a subsequent getConnection() call gets back the same database connection. The application must redo any ALTER SESSION statements on the new connection object, as required.
+		 * @param	{(err: any) => void} callback Callback on close done.
+		 */
+		close(callback: (err: any) => void): void;
+
+		/**
+		 * Releases a connection. If the connection was obtained from the pool, the connection is returned to the pool and is available for reuse.
+		 * Note: calling close() when connections are no longer required is strongly encouraged. Releasing helps avoid resource leakage and can improve system efficiency.
+		 * When a connection is released, any ongoing transaction on the connection is rolled back.
+		 * After releasing a connection to a pool, there is no guarantee a subsequent getConnection() call gets back the same database connection. The application must redo any ALTER SESSION statements on the new connection object, as required.
+		 * @returns	A void Promise on close done.
+		 */
+		close(): IPromise<void>;
+
+		/**
+		 * Send a commit requisition to the database.
+		 * @param	{(err: any) => void} callback Callback on commit done.
+		 */
+		commit(callback: (err: any) => void): void;
+
+		/**
+		 * Send a commit requisition to the database.
+		 * @returns	A void Promise on commit done.
+		 */
+		commit(): IPromise<void>;
+
+		/**
+		 * This call executes a SQL or PL/SQL statement. See SQL Execution for examples.
+		 * The statement to be executed may contain IN binds, OUT or IN OUT bind values or variables, which are bound using either an object or an array.
+		 * A callback function returns a result object, containing any fetched rows, the values of any OUT and IN OUT bind variables, and the number of rows affected by the execution of DML statements.
+		 * @param	{string} sql SQL Statement.
+		 * @param	{Object|Array<any>} bindParams Binds Object/Array
+		 * @param	{IExecuteOptions} options Options object
+		 * @param	{(err: any, value: IExecuteReturn) => void} callback Callback function to receive the result.
+		 */
+		execute(sql: string,
+			bindParams: Object | Array<any>,
+			options: IExecuteOptions,
+			callback: (err: any, value: IExecuteReturn) => void): void;
+
+		/**
+		 * This call executes a SQL or PL/SQL statement. See SQL Execution for examples.
+		 * The statement to be executed may contain IN binds, OUT or IN OUT bind values or variables, which are bound using either an object or an array.
+		 * A callback function returns a result object, containing any fetched rows, the values of any OUT and IN OUT bind variables, and the number of rows affected by the execution of DML statements.
+		 * @param	{string} sql SQL Statement.
+		 * @param	{Object|Array<any>} bindParams Binds Object/Array
+		 * @param	{(err: any, value: IExecuteReturn) => void} callback Callback function to receive the result.
+		 */
+		execute(sql: string,
+			bindParams: Object | Array<any>,
+			callback: (err: any, value: IExecuteReturn) => void): void;
+
+		/**
+		 * This call executes a SQL or PL/SQL statement. See SQL Execution for examples.
+		 * The statement to be executed may contain IN binds, OUT or IN OUT bind values or variables, which are bound using either an object or an array.
+		 * A callback function returns a result object, containing any fetched rows, the values of any OUT and IN OUT bind variables, and the number of rows affected by the execution of DML statements.
+		 * @param	{string} sql SQL Statement.
+		 * @param	{IExecuteOptions} options Options object
+		 * @param	{(err: any, value: IExecuteReturn) => void} callback Callback function to receive the result.
+		 */
+		execute(sql: string,
+			options: IExecuteOptions,
+			callback: (err: any, value: IExecuteReturn) => void): void;
+
+		/**
+		 * This call executes a SQL or PL/SQL statement. See SQL Execution for examples.
+		 * The statement to be executed may contain IN binds, OUT or IN OUT bind values or variables, which are bound using either an object or an array.
+		 * A callback function returns a result object, containing any fetched rows, the values of any OUT and IN OUT bind variables, and the number of rows affected by the execution of DML statements.
+		 * @param	{string} sql SQL Statement.
+		 * @param	{(err: any, value: IExecuteReturn) => void} callback Callback function to receive the result.
+		 */
+		execute(sql: string,
+			callback: (err: any, value: IExecuteReturn) => void): void;
+
+		/**
+		 * This call executes a SQL or PL/SQL statement. See SQL Execution for examples.
+		 * The statement to be executed may contain IN binds, OUT or IN OUT bind values or variables, which are bound using either an object or an array.
+		 * @param	{string} sql SQL Statement.
+		 * @param	{Object|Array<any>} bindParams Binds Object/Array
+		 * @param	{IExecuteOptions} options Options object
+		 * @returns	A Promise of a result object, containing any fetched rows, the values of any OUT and IN OUT bind variables, and the number of rows affected by the execution of DML statements.
+		 */
+		execute(sql: string,
+			bindParams?: Object | Array<any>,
+			options?: IExecuteOptions): IPromise<IExecuteReturn>;
+
+		/**
+		 * This function provides query streaming support. The parameters are the same as execute() except a callback is not used. Instead this function returns a stream used to fetch data.
+		 * Each row is returned as a data event. Query metadata is available via a metadata event. The end event indicates the end of the query results.
+		 * Query results must be fetched to completion to avoid resource leaks.
+		 * The connection must remain open until the stream is completely read.
+		 * For tuning purposes the oracledb.maxRows property can be used to size an internal buffer used by queryStream(). Note it does not limit the number of rows returned by the stream. The oracledb.prefetchRows value will also affect performance.
+		 * @param	{string} sql SQL Statement.
+		 * @param	{Object|Array<any>} bindParams Binds Object/Array
+		 * @param	{IExecuteOptions} options Options object
+		 * @returns Readable Stream for queries.
+		 */
+		queryStream(sql: string,
+			bindParams?: Object | Array<any>,
+			options?: IExecuteOptions): stream.Readable;
+
+		/**
+		 * An alias for Connection.close().
+		 * @param	{(err: any) => void} callback Callback on close done.
+		 */
+		release(callback: (err: any) => void): void;
+
+		/**
+		 * An alias for Connection.close().
+		 * @returns	A void Promise on close done.
+		 */
+		release(): IPromise<void>;
+
+		/**
+		 * Send a rollback requisition to database.
+		 * @param	{(err: any) => void} callback Callback on rollback done.
+		 */
+		rollback(callback: (err: any) => void): void;
+
+		/**
+		 * Send a rollback requisition to database.
+		 * @returns	A void Promise on rollback done.
+		 */
+		rollback(): IPromise<void>;
+	}
+
+	/** Emits "_after_close" event */
+	interface IConnectionPool extends events.EventEmitter {
+		/**
+		 * The number of currently active connections in the connection pool i.e. the number of connections currently checked-out using getConnection().
+		 */
+		connectionsInUse: number;
+		/**
+		 * The number of currently open connections in the underlying connection pool.
+		 */
+		connectionsOpen: number;
+		/**
+		 * The readonly alias of this pool in the connection pool cache. An alias cannot be changed once the pool has been created.
+		 */
+		poolAlias: string;
+		/**
+		 * The number of connections that are opened whenever a connection request exceeds the number of currently open connections.
+		 */
+		poolIncrement: number;
+		/**
+		 * The maximum number of connections that can be open in the connection pool.
+		 */
+		poolMax: number;
+		/**
+		 * The minimum number of connections a connection pool maintains, even when there is no activity to the target database.
+		 */
+		poolMin: number;
+		/**
+		 * The time (in seconds) after which the pool terminates idle connections (unused in the pool). The number of connections does not drop below poolMin.
+		 */
+		poolTimeout: number;
+		/**
+		 * Determines whether requests for connections from the pool are queued when the number of connections "checked out" from the pool has reached the maximum number specified by poolMax.
+		 */
+		queueRequests: number;
+		/**
+		 * The time (in milliseconds) that a connection request should wait in the queue before the request is terminated.
+		 */
+		queueTimeout: number;
+		/**
+		 * The number of statements to be cached in the statement cache of each connection.
+		 */
+		stmtCacheSize: number;
+
+		/**
+		 * Finalizes the connection pool.
+		 * @param  {(err:any)=>void} callback Callback called when the pool is terminated or when some error occurs
+		 * @returns void
+		 */
+		close(callback: (err: any) => void): void;
+
+		/**
+		 * Finalizes the connection pool.
+		 * @returns Promise to when the close finishes.
+		 */
+		close(): IPromise<void>;
+
+		/**
+		 * This method obtains a connection from the connection pool.
+		 * If a previously opened connection is available in the pool, that connection is returned. If all connections in the pool are in use, a new connection is created and returned to the caller, as long as the number of connections does not exceed the specified maximum for the pool. If the pool is at its maximum limit, the getConnection() call results in an error, such as ORA-24418: Cannot open further sessions.
+		 * @param  {(err:any,connection:IConnection)=>void} callback Callback called when the connection is available or when some error occurs.
+		 * @returns void
+		 * @see {@link https://jsao.io/2015/03/making-a-wrapper-module-for-the-node-js-driver-for-oracle-database/}
+		 * @see {@link https://github.com/OraOpenSource/orawrap}
+		 */
+		getConnection(callback: (err: any, connection: IConnection) => void): void;
+
+		/**
+		 * This method obtains a connection from the connection pool.
+		 * If a previously opened connection is available in the pool, that connection is returned. If all connections in the pool are in use, a new connection is created and returned to the caller, as long as the number of connections does not exceed the specified maximum for the pool. If the pool is at its maximum limit, the getConnection() call results in an error, such as ORA-24418: Cannot open further sessions.
+		 * @returns  An IConnection Promise to when the connection is available or when some error occurs.
+		 * @see {@link https://jsao.io/2015/03/making-a-wrapper-module-for-the-node-js-driver-for-oracle-database/}
+		 * @see {@link https://github.com/OraOpenSource/orawrap}
+		 */
+		getConnection(): IPromise<IConnection>;
+
+		/**
+		 * An alias for IConnectionPool.close().
+		 * @param  {(err:any)=>void} callback Callback called when the pool is terminated or when some error occurs
+		 * @returns void
+		 */
+		terminate(callback: (err: any) => void): void;
+
+		/**
+		 * An alias for IConnectionPool.close().
+		 * @returns Promise to when the close finishes.
+		 */
+		terminate(): IPromise<void>;
+	}
+
+	/* tslint:disable no-unused-variable */
+	const DEFAULT: number;
+	/** Metadata return type */
+	const DB_TYPE_VARCHAR: number;
+	/** Metadata return type */
+	const DB_TYPE_NUMBER: number;
+	/** Metadata return type */
+	const DB_TYPE_DATE: number;
+	/** Metadata return type */
+	const DB_TYPE_RAW: number;
+	/** Metadata return type */
+	const DB_TYPE_CHAR: number;
+	/** Metadata return type */
+	const DB_TYPE_BINARY_FLOAT: number;
+	/** Metadata return type */
+	const DB_TYPE_BINARY_DOUBLE: number;
+	/** Metadata return type */
+	const DB_TYPE_ROWID: number;
+	/** Metadata return type */
+	const DB_TYPE_CLOB: number;
+	/** Metadata return type */
+	const DB_TYPE_BLOB: number;
+	/** Metadata return type */
+	const DB_TYPE_TIMESTAMP: number;
+	/** Metadata return type */
+	const DB_TYPE_TIMESTAMP_TZ: number;
+	/** Metadata return type */
+	const DB_TYPE_TIMESTAMP_LTZ: number;
+	/** Data type */
+	const STRING: number;
+	/** Data type */
+	const NUMBER: number;
+	/** Data type */
+	const DATE: number;
+	/** Data type */
+	const CURSOR: number;
+	/** Data type */
+	const BUFFER: number;
+	/** Data type */
+	const CLOB: number;
+	/** Data type */
+	const BLOB: number;
+	/** Bind direction */
+	const BIND_IN: number;
+	/** Bind direction */
+	const BIND_INOUT: number;
+	/** Bind direction */
+	const BIND_OUT: number;
+	/** outFormat */
+	const ARRAY: number;
+	/** outFormat */
+	const OBJECT: number;
+
+	/**
+	 * Do not use this method - used internally by node-oracledb.
+	 */
+	function newLob(iLob: ILob): Lob;
+
+	/* tslint:disable no-var-keyword */
+	/** Default transaction behaviour of auto commit for each statement. */
+	var autoCommit: boolean;
+	/**
+	 * The user-chosen Connection class value defines a logical name for connections. Most single purpose applications should set connectionClass when using a connection pool or DRCP.
+	 * When a pooled session has a connection class, Oracle ensures that the session is not shared outside of that connection class.
+	 */
+	var connectionClass: string;
+	/**
+	 * Determines whether additional metadata is available for queries and for REF CURSORs returned from PL/SQL blocks.
+	 * The default value for extendedMetaData is false. With this value, the result.metaData result.resultSet.metaData objects only include column names.
+	 */
+	var extendedMetaData: boolean;
+	/** Default authentication/authorization method. When true, the SO trusted user will be used. */
+	var externalAuth: boolean;
+	/**
+	 * An array of node-oracledb types. When any column having the specified type is queried with execute(), the column data is returned as a string instead of the native representation. For column types not specified in fetchAsString, native types will be returned.
+	 * By default all columns are returned as native types.
+	 */
+	var fetchAsString: Array<number>;
+	/** Default size in bytes that the driver will fetch from LOBs in advance. */
+	var lobPrefetchSize: number;
+	/** Default maximum number of rows to be fetched in statements not using ResultSets */
+	var maxRows: number;
+	/** Version of OCI that is used. */
+	var oracleClientVersion: number;
+	/** Default format for returning rows. When ARRAY, it will return Array<Array<any>>. When OBJECT, it will return Array<Object>. */
+	var outFormat: number;
+	/** Default number of connections to increment when available connections reach 0 in created pools. poolMax will be respected. */
+	var poolIncrement: number;
+	/** Default maximum connections in created pools */
+	var poolMax: number;
+	/** Default minimum connections in created pools */
+	var poolMin: number;
+	/** Default timeout for unused connections in pool to be released. poolMin will be respected. */
+	var poolTimeout: number;
+	/** Default number of rows that the driver will fetch in each query. */
+	var prefetchRows: number;
+	/**
+	 * Readonly reference to the native oracledb.
+	 */
+	var Oracledb: any;
+	/**
+	 * Readonly reference to the native connection object.
+	 */
+	var Connection: any;
+	/**
+	 * Readonly reference to the native Lob object.
+	 */
+	var Lob: any;
+	/**
+	 * Reference to the native ResultSet object.
+	 */
+	var ResultSet: any;
+	/**
+	 * Node-oracledb supports Promises on all methods. The standard Promise library is used in Node 0.12 and greater.
+	 * Promise support is not enabled by default in Node 0.10.
+	 * You can change the Promisse library to any default ES6 compatible library (like bluebird).
+	 */
+	var Promise: any;
+	/**
+	 * If this property is true and the number of connections "checked out" from the pool has reached the number specified by poolMax, then new requests for connections are queued until in-use connections are released.
+	 * If this property is false and a request for a connection is made from a pool where the number of "checked out" connections has reached poolMax, then an ORA-24418 error indicating that further sessions cannot be opened will be returned.
+	 * The default value is true.
+	 */
+	var queueRequests: boolean;
+	/**
+	 * The number of milliseconds after which connection requests waiting in the connection request queue are terminated. If queueTimeout is 0, then queued connection requests are never terminated.
+	 * The default value is 60000.
+	 */
+	var queueTimeout: number;
+	/** Default size of statements cache. Used to speed up creating queries. */
+	var stmtCacheSize: number;
+	/** node-oracledb driver version. */
+	var version: number;
+
+	/**
+	 * Creates a database managed connection pool.
+	 * @param  {IPoolAttributes} poolAttributes Parameters to stablish the connection pool.
+	 * @param  {(err:any,connection:IConnectionPool)=>void} callback Callback to run when the connection pool gets created or when some error occurs.
+	 * @returns void
+	 */
+	function createPool(poolAttributes: IPoolAttributes, callback: (err: any, connection: IConnectionPool) => void): void;
+
+	/**
+	 * Creates a database managed connection pool.
+	 * @param  {IPoolAttributes} poolAttributes Parameters to stablish the connection pool.
+	 * @returns Promise {(connection:IConnectionPool)=>any} Promise with the connection pool.
+	 */
+	function createPool(poolAttributes: IPoolAttributes): IPromise< IConnectionPool >;
+
+	/**
+	 * Retrieves a connection pool from cache. If it does not exists, an error will be thrown.
+	 * @param {string} alias The index of the cache for the pool. If none is passed, it will use the default one.
+	 * @returns The connection pool or throws an error if it was not found.
+	 */
+	function getPool(poolAlias?: string): IConnectionPool;
+
+	/**
+	 * Creates a connection with the database - the pool alias will be "default".
+	 * @param  {(err:any,connection:IConnection)=>void} callback Callback to run when the connection gets stablished or when some error occurs.
+	 * @returns void
+	 */
+	function getConnection(callback: (err: any, connection: IConnection) => void): void;
+
+	/**
+	 * Creates a connection with the database.
+	 * @param  {string} poolAlias Poll from which the connection should be retrieved.
+	 * @param  {(err:any,connection:IConnection)=>void} callback Callback to run when the connection gets stablished or when some error occurs.
+	 * @returns void
+	 */
+	function getConnection(poolAlias: string, callback: (err: any, connection: IConnection) => void): void;
+
+	/**
+	 * Creates a connection with the database.
+	 * @param  {IConnectionAttributes} connectionAttributes Parameters to stablish the connection.
+	 * @param  {(err:any,connection:IConnection)=>void} callback Callback to run when the connection gets stablished or when some error occurs.
+	 * @returns void
+	 */
+	function getConnection(connectionAttributes: IConnectionAttributes, callback: (err: any, connection: IConnection) => void): void;
+
+	/**
+	 * Creates a connection with the database. The pool name will be "default".
+	 * @returns  {(connection:IConnection)=>any} Promise with the connection.
+	 */
+	function getConnection(): IPromise< IConnection >;
+
+	/**
+	 * Creates a connection with the database.
+	 * @param  {string} poolAlias Poll from which the connection should be retrieved.
+	 * @returns  {(connection:IConnection)=>any} Promise with the connection.
+	 */
+	function getConnection(poolAlias: string): IPromise< IConnection >;
+
+	/**
+	 * Creates a connection with the database.
+	 * @param  {IConnectionAttributes} connectionAttributes Parameters to stablish the connection.
+	 * @returns  {(connection:IConnection)=>any} Promise with the connection.
+	 */
+	function getConnection(connectionAttributes: IConnectionAttributes): IPromise< IConnection >;
 }
 
-export interface ILob {
-    chunkSize: number;
-    length: number;
-    pieceSize: number;
-    offset?: number;
-    type: string;
-    /**
-     * Release method on ILob class.
-     * @remarks The cleanup() called by Release() only frees OCI error handle and Lob
-     *          locator.  These calls acquire mutex on OCI environment handle very briefly.
-     */
-    release?(): void;
-    /**
-     * Read method on ILob class.
-     * @param {(err : any, chunk: string | Buffer) => void} callback Callback to recive the data from lob.
-     * @remarks CLobs send strings while BLobs send Buffer object.
-     */
-    read?(callback: (err: any, chunk: string | Buffer) => void): void;
-    /**
-     * Read method on ILob class.
-     * @param {Buffer} data Data write into Lob.
-     * @param {(err: any) => void} callback Callback executed when writ is finished or when some error occured.
-     * @remarks CLobs send strings while BLobs send Buffer object.
-     */
-    write?(data: Buffer, callback: (err: any) => void): void;
-}
-
-export interface Lob extends stream.Duplex {
-    iLob: ILob;
-    /** This corresponds to the size used by the Oracle LOB layer when accessing or modifying the LOB value. */
-    chunkSize: number;
-    /** Length of a queried LOB in bytes (for BLOBs) or characters (for CLOBs). */
-    length: number;
-    /**
-     * he number of bytes (for BLOBs) or characters (for CLOBs) to read for each Stream 'data' event of a queried LOB.
-     * The default value is chunkSize.
-     * For efficiency, it is recommended that pieceSize be a multiple of chunkSize.
-     * The maximum value for pieceSize is limited to the value of UINT_MAX.
-     */
-    pieceSize: number;
-    /**
-     * This read-only attribute shows the type of Lob being used. It will have the value of one of the constants Oracledb.BLOB or Oracledb.CLOB. The value is derived from the bind type when using LOB bind variables, or from the column type when a LOB is returned by a query.
-     */
-    type: number;
-
-    /**
-     * Do not call this... used internally by node-oracledb
-     */
-    constructor(iLob: ILob, opts: stream.DuplexOptions): Lob;
-    constructor(iLob: ILob): Lob;
-
-    /**
-     * Closes the current LOB.
-     * @param  {(err: any) => void} callback? When passed, is called after the release.
-     * @returns void
-     */
-    close(callback: (err: any) => void): void;
-    close(): void;
-}
-
-export interface IConnectionAttributes {
-    user?: string;
-    password?: string;
-    connectString: string;
-    stmtCacheSize?: number;
-    externalAuth?: boolean;
-}
-
-export interface IPoolAttributes extends IConnectionAttributes {
-    poolMax?: number;
-    poolMin?: number;
-    poolIncrement?: number;
-    poolTimeout?: number;
-}
-
-export interface IExecuteOptions {
-    /**
-     * Transaction should auto commit after each statement?
-     * Overrides Oracledb autoCommit.
-     */
-    autoCommit?: boolean;
-    /**
-     * Determines whether additional metadata is available for queries and for REF CURSORs returned from PL/SQL blocks.
-     * Overrides Oracledb extendedMetaData.
-     */
-    extendedMetaData?: boolean;
-    /**
-     * Object defining how query column data should be represented in JavaScript.
-     * The fetchInfo property can be used to indicate that number or date columns in a query should be returned as strings instead of their native format. The property can be used in conjunction with, or instead of, the global setting fetchAsString.
-     * For example:
-     *
-     * fetchInfo:
-     * {
-     *   "HIRE_DATE":      { type : oracledb.STRING },  // return the date as a string
-     *   "COMMISSION_PCT": { type : oracledb.DEFAULT }  // override Oracledb.fetchAsString
-     * }
-     *
-     * Each column is specified by name, using Oracle's standard naming convention.
-     * The valid values for type are STRING and DEFAULT. The former indicates that the given column should be returned as a string. The latter can be used to override any global mapping given by fetchAsString and allow the column data for this query to be returned in native format.
-     * The maximum length of a string created by type mapping is 200 bytes. However, if a database column that is already of type STRING is specified in fetchInfo, then the actual database metadata will be used to determine the maximum length.
-     * Columns fetched from REF CURSORS are not mapped by fetchInfo settings in the execute() call. Use the global fetchAsString instead.
-     */
-    fetchInfo?: Object;
-    /**
-     * Maximum number of rows that will be retrieved. Used when resultSet is false.
-     * Overrides Oracledb maxRows.
-     */
-    maxRows?: number;
-    /**
-     * Result format - ARRAY o OBJECT
-     * Overrides Oracledb outFormat.
-     */
-    outFormat?: number;
-    /**
-     * Number of rows to be fetched in advance.
-     * Overrides Oracledb prefetchRows.
-     */
-    prefetchRows?: number;
-    /**
-     * Determines whether query results should be returned as a ResultSet object or directly. The default is false.
-     */
-    resultSet?: boolean;
-}
-
-export interface IExecuteReturn {
-    /** Metadata information - column names is always given. If the Oracledb extendedMetaData or execute() option extendedMetaData are true then additional information is included. */
-    metaData?: Array<IMetaData>;
-    /** This is either an array or an object containing OUT and IN OUT bind values. If bindParams is passed as an array, then outBinds is returned as an array. If bindParams is passed as an object, then outBinds is returned as an object. */
-    outBinds?: Array<any> | Object;
-    /** For SELECT statements when the resultSet option is true, use the resultSet object to fetch rows. See ResultSet Class. */
-    resultSet?: IResultSet;
-    /** For SELECT statements where the resultSet option is false or unspecified, rows contains an array of fetched rows. It will be NULL if there is an error or the SQL statement was not a SELECT statement. By default, the rows are in an array of column value arrays, but this can be changed to arrays of objects by setting outFormat to OBJECT. If a single row is fetched, then rows is an array that contains one single row. The number of rows returned is limited to the maxRows configuration property of the Oracledb object, although this may be overridden in any execute() call. */
-    rows?: Array<Array<any>> | Array<any>;
-    /** For DML statements (including SELECT FOR UPDATE) this contains the number of rows affected, for example the number of rows inserted. For non-DML statements such as queries, or if no rows are affected, then rowsAffected will be zero. */
-    rowsAffected?: number;
-}
-
-export interface IMetaData {
-    /** The column name follows Oracle's standard name-casing rules. It will commonly be uppercase, since most applications create tables using unquoted, case-insensitive names. */
-    name: string;
-    /** one of the Node-oracledb Type Constant values. */
-    fetchType?: number;
-    /** one of the Node-oracledb Type Constant values. */
-    dbType?: number;
-    /** the database byte size. This is only set for DB_TYPE_VARCHAR, DB_TYPE_CHAR and DB_TYPE_RAW column types. */
-    byteSize?: number;
-    /** set only for DB_TYPE_NUMBER, DB_TYPE_TIMESTAMP, DB_TYPE_TIMESTAMP_TZ and DB_TYPE_TIMESTAMP_LTZ columns. */
-    precision?: number;
-    /** set only for DB_TYPE_NUMBER columns. */
-    scale: number;
-    /** indicates whether NULL values are permitted for this column. */
-    nullable?: boolean;
-}
-
-export interface IResultSet {
-    /**
-     * Contains an array of objects with metadata about the query or REF CURSOR columns.
-     * Each column's name is always given. If the Oracledb extendedMetaData or execute() option extendedMetaData are true then additional information is included.
-     */
-    metaData?: Array<IMetaData>;
-
-    /**
-     * Closes a ResultSet. Applications should always call this at the end of fetch or when no more rows are needed.
-     * @param  {(err:any)=>void} callback Callback called on finish or when some error occurs.
-     * @returns void
-     * @remarks Applications should always call this at the end of fetch or when no more rows are needed.
-     */
-    close(callback: (err: any) => void): void;
-
-    /**
-     * Closes a ResultSet. Applications should always call this at the end of fetch or when no more rows are needed.
-     * @returns  A void Promise on finish or when some error occurs.
-     * @remarks Applications should always call this at the end of fetch or when no more rows are needed.
-     */
-    close(): IPromise<void>;
-
-    /**
-     * This call fetches one row of the result set as an object or an array of column values, depending on the value of outFormat.
-     * At the end of fetching, the ResultSet should be freed by calling close().
-     * @param  {(err:any,row:Array<any>|Object)=>void} callback Callback called when the row is available or when some error occurs.
-     * @returns void
-     */
-    getRow(callback: (err: any, row: Array<any> | Object) => void): void;
-
-    /**
-     * This call fetches one row of the result set as an object or an array of column values, depending on the value of outFormat.
-     * At the end of fetching, the ResultSet should be freed by calling close().
-     * @returns Promise when the row is available or when some error occurs.
-     */
-    getRow(): IPromise<Array<any> | Object>;
-
-    /**
-     * This synchronous method converts a ResultSet into a stream.
-     * It can be used to make ResultSets from top-level queries or from REF CURSOR bind variables streamable. To make top-level queries streamable, the alternative connection.queryStream() method may be easier to use.
-     * @returns synchronous stream of result set.
-     */
-    toQueryStream(): stream.Readable;
-}
-
-export interface IConnection {
-    /**
-     * The action attribute for end-to-end application tracing.
-     * This is a write-only property. Displaying a Connection object will show a value of null for this attribute. See End-to-end Tracing, Mid-tier Authentication, and Auditing.
-     */
-    action: string;
-    /**
-     * The client identifier for end-to-end application tracing, use with mid-tier authentication, and with Virtual Private Databases.
-     * This is a write-only property. Displaying a Connection object will show a value of null for this attribute. See End-to-end Tracing, Mid-tier Authentication, and Auditing.
-     */
-    clientId: string;
-    /**
-     * The module attribute for end-to-end application tracing.
-     * This is a write-only property. Displaying a Connection object will show a value of null for this attribute. See End-to-end Tracing, Mid-tier Authentication, and Auditing.
-     */
-    module: string;
-    /**
-     * This readonly property gives a numeric representation of the Oracle database version. For version a.b.c.d.e, this property gives the number: (100000000 * a) + (1000000 * b) + (10000 * c) + (100 * d) + e
-     */
-    oracleServerVersion: number;
-    /**
-     * The number of statements to be cached in the statement cache of the connection. The default value is the stmtCacheSize property in effect in the Pool object when the connection is created in the pool.
-     */
-    stmtCacheSize: number;
-
-    /**
-     * This call stops the currently running operation on the connection.
-     * If there is no operation in progress or the operation has completed by the time the break is issued, the break() is effectively a no-op.
-     * If the running asynchronous operation is interrupted, its callback will return an error.
-     * @param	{(err: any) => void} callback Callback on break done.
-     */
-    break(callback: (err: any) => void): void;
-
-    /**
-     * This call stops the currently running operation on the connection.
-     * If there is no operation in progress or the operation has completed by the time the break is issued, the break() is effectively a no-op.
-     * If the running asynchronous operation is interrupted, its callback will return an error.
-     * @returns	A void promise when break is done.
-     */
-    break(): IPromise<void>;
-
-    /**
-     * Releases a connection. If the connection was obtained from the pool, the connection is returned to the pool and is available for reuse.
-     * Note: calling close() when connections are no longer required is strongly encouraged. Releasing helps avoid resource leakage and can improve system efficiency.
-     * When a connection is released, any ongoing transaction on the connection is rolled back.
-     * After releasing a connection to a pool, there is no guarantee a subsequent getConnection() call gets back the same database connection. The application must redo any ALTER SESSION statements on the new connection object, as required.
-     * @param	{(err: any) => void} callback Callback on close done.
-     */
-    close(callback: (err: any) => void): void;
-
-    /**
-     * Releases a connection. If the connection was obtained from the pool, the connection is returned to the pool and is available for reuse.
-     * Note: calling close() when connections are no longer required is strongly encouraged. Releasing helps avoid resource leakage and can improve system efficiency.
-     * When a connection is released, any ongoing transaction on the connection is rolled back.
-     * After releasing a connection to a pool, there is no guarantee a subsequent getConnection() call gets back the same database connection. The application must redo any ALTER SESSION statements on the new connection object, as required.
-     * @returns	A void Promise on close done.
-     */
-    close(): IPromise<void>;
-
-    /**
-     * Send a commit requisition to the database.
-     * @param	{(err: any) => void} callback Callback on commit done.
-     */
-    commit(callback: (err: any) => void): void;
-
-    /**
-     * Send a commit requisition to the database.
-     * @returns	A void Promise on commit done.
-     */
-    commit(): IPromise<void>;
-
-    /**
-     * This call executes a SQL or PL/SQL statement. See SQL Execution for examples.
-     * The statement to be executed may contain IN binds, OUT or IN OUT bind values or variables, which are bound using either an object or an array.
-     * A callback function returns a result object, containing any fetched rows, the values of any OUT and IN OUT bind variables, and the number of rows affected by the execution of DML statements.
-     * @param	{string} sql SQL Statement.
-     * @param	{Object|Array<any>} bindParams Binds Object/Array
-     * @param	{IExecuteOptions} options Options object
-     * @param	{(err: any, value: IExecuteReturn) => void} callback Callback function to receive the result.
-     */
-    execute(sql: string,
-        bindParams: Object | Array<any>,
-        options: IExecuteOptions,
-        callback: (err: any, value: IExecuteReturn) => void): void;
-
-    /**
-     * This call executes a SQL or PL/SQL statement. See SQL Execution for examples.
-     * The statement to be executed may contain IN binds, OUT or IN OUT bind values or variables, which are bound using either an object or an array.
-     * A callback function returns a result object, containing any fetched rows, the values of any OUT and IN OUT bind variables, and the number of rows affected by the execution of DML statements.
-     * @param	{string} sql SQL Statement.
-     * @param	{Object|Array<any>} bindParams Binds Object/Array
-     * @param	{(err: any, value: IExecuteReturn) => void} callback Callback function to receive the result.
-     */
-    execute(sql: string,
-        bindParams: Object | Array<any>,
-        callback: (err: any, value: IExecuteReturn) => void): void;
-
-    /**
-     * This call executes a SQL or PL/SQL statement. See SQL Execution for examples.
-     * The statement to be executed may contain IN binds, OUT or IN OUT bind values or variables, which are bound using either an object or an array.
-     * A callback function returns a result object, containing any fetched rows, the values of any OUT and IN OUT bind variables, and the number of rows affected by the execution of DML statements.
-     * @param	{string} sql SQL Statement.
-     * @param	{IExecuteOptions} options Options object
-     * @param	{(err: any, value: IExecuteReturn) => void} callback Callback function to receive the result.
-     */
-    execute(sql: string,
-        options: IExecuteOptions,
-        callback: (err: any, value: IExecuteReturn) => void): void;
-
-    /**
-     * This call executes a SQL or PL/SQL statement. See SQL Execution for examples.
-     * The statement to be executed may contain IN binds, OUT or IN OUT bind values or variables, which are bound using either an object or an array.
-     * A callback function returns a result object, containing any fetched rows, the values of any OUT and IN OUT bind variables, and the number of rows affected by the execution of DML statements.
-     * @param	{string} sql SQL Statement.
-     * @param	{(err: any, value: IExecuteReturn) => void} callback Callback function to receive the result.
-     */
-    execute(sql: string,
-        callback: (err: any, value: IExecuteReturn) => void): void;
-
-    /**
-     * This call executes a SQL or PL/SQL statement. See SQL Execution for examples.
-     * The statement to be executed may contain IN binds, OUT or IN OUT bind values or variables, which are bound using either an object or an array.
-     * @param	{string} sql SQL Statement.
-     * @param	{Object|Array<any>} bindParams Binds Object/Array
-     * @param	{IExecuteOptions} options Options object
-     * @returns	A Promise of a result object, containing any fetched rows, the values of any OUT and IN OUT bind variables, and the number of rows affected by the execution of DML statements.
-     */
-    execute(sql: string,
-        bindParams?: Object | Array<any>,
-        options?: IExecuteOptions): IPromise<IExecuteReturn>;
-
-    /**
-     * This function provides query streaming support. The parameters are the same as execute() except a callback is not used. Instead this function returns a stream used to fetch data.
-     * Each row is returned as a data event. Query metadata is available via a metadata event. The end event indicates the end of the query results.
-     * Query results must be fetched to completion to avoid resource leaks.
-     * The connection must remain open until the stream is completely read.
-     * For tuning purposes the oracledb.maxRows property can be used to size an internal buffer used by queryStream(). Note it does not limit the number of rows returned by the stream. The oracledb.prefetchRows value will also affect performance.
-     * @param	{string} sql SQL Statement.
-     * @param	{Object|Array<any>} bindParams Binds Object/Array
-     * @param	{IExecuteOptions} options Options object
-     * @returns Readable Stream for queries.
-     */
-    queryStream(sql: string,
-        bindParams?: Object | Array<any>,
-        options?: IExecuteOptions): stream.Readable;
-
-    /**
-     * An alias for Connection.close().
-     * @param	{(err: any) => void} callback Callback on close done.
-     */
-    release(callback: (err: any) => void): void;
-
-    /**
-     * An alias for Connection.close().
-     * @returns	A void Promise on close done.
-     */
-    release(): IPromise<void>;
-
-    /**
-     * Send a rollback requisition to database.
-     * @param	{(err: any) => void} callback Callback on rollback done.
-     */
-    rollback(callback: (err: any) => void): void;
-
-    /**
-     * Send a rollback requisition to database.
-     * @returns	A void Promise on rollback done.
-     */
-    rollback(): IPromise<void>
-}
-
-export interface IConnectionPool {
-    /**
-     * The number of currently active connections in the connection pool i.e. the number of connections currently checked-out using getConnection().
-     */
-    connectionsInUse: number;
-    /**
-     * The number of currently open connections in the underlying connection pool.
-     */
-    connectionsOpen: number;
-    /**
-     * The number of connections that are opened whenever a connection request exceeds the number of currently open connections.
-     */
-    poolIncrement: number;
-    /**
-     * The maximum number of connections that can be open in the connection pool.
-     */
-    poolMax: number;
-    /**
-     * The minimum number of connections a connection pool maintains, even when there is no activity to the target database.
-     */
-    poolMin: number;
-    /**
-     * The time (in seconds) after which the pool terminates idle connections (unused in the pool). The number of connections does not drop below poolMin.
-     */
-    poolTimeout: number;
-    /**
-     * Determines whether requests for connections from the pool are queued when the number of connections "checked out" from the pool has reached the maximum number specified by poolMax.
-     */
-    queueRequests: number;
-    /**
-     * The time (in milliseconds) that a connection request should wait in the queue before the request is terminated.
-     */
-    queueTimeout: number;
-    /**
-     * The number of statements to be cached in the statement cache of each connection.
-     */
-    stmtCacheSize: number;
-
-    /**
-     * Finalizes the connection pool.
-     * @param  {(err:any)=>void} callback Callback called when the pool is terminated or when some error occurs
-     * @returns void
-     */
-    close(callback: (err: any) => void): void;
-
-    /**
-     * Finalizes the connection pool.
-     * @returns Promise to when the close finishes.
-     */
-    close(): IPromise<void>;
-
-    /**
-     * This method obtains a connection from the connection pool.
-     * If a previously opened connection is available in the pool, that connection is returned. If all connections in the pool are in use, a new connection is created and returned to the caller, as long as the number of connections does not exceed the specified maximum for the pool. If the pool is at its maximum limit, the getConnection() call results in an error, such as ORA-24418: Cannot open further sessions.
-     * @param  {(err:any,connection:IConnection)=>void} callback Callback called when the connection is available or when some error occurs.
-     * @returns void
-     * @see {@link https://jsao.io/2015/03/making-a-wrapper-module-for-the-node-js-driver-for-oracle-database/}
-     * @see {@link https://github.com/OraOpenSource/orawrap}
-     */
-    getConnection(callback: (err: any, connection: IConnection) => void): void;
-
-    /**
-     * This method obtains a connection from the connection pool.
-     * If a previously opened connection is available in the pool, that connection is returned. If all connections in the pool are in use, a new connection is created and returned to the caller, as long as the number of connections does not exceed the specified maximum for the pool. If the pool is at its maximum limit, the getConnection() call results in an error, such as ORA-24418: Cannot open further sessions.
-     * @returns  An IConnection Promise to when the connection is available or when some error occurs.
-     * @see {@link https://jsao.io/2015/03/making-a-wrapper-module-for-the-node-js-driver-for-oracle-database/}
-     * @see {@link https://github.com/OraOpenSource/orawrap}
-     */
-    getConnection(): IPromise<IConnection>;
-
-    /**
-     * An alias for IConnectionPool.close().
-     * @param  {(err:any)=>void} callback Callback called when the pool is terminated or when some error occurs
-     * @returns void
-     */
-    terminate(callback: (err: any) => void): void;
-
-    /**
-     * An alias for IConnectionPool.close().
-     * @returns Promise to when the close finishes.
-     */
-    terminate(): IPromise<void>;
-}
-
-export declare const DEFAULT: number;
-/** Data type */
-export declare const STRING: number;
-/** Data type */
-export declare const NUMBER: number;
-/** Data type */
-export declare const DATE: number;
-/** Data type */
-export declare const CURSOR: number;
-/** Data type */
-export declare const BUFFER: number;
-/** Data type */
-export declare const CLOB: number;
-/** Data type */
-export declare const BLOB: number;
-/** Bind direction */
-export declare const BIND_IN: number;
-/** Bind direction */
-export declare const BIND_INOUT: number;
-/** Bind direction */
-export declare const BIND_OUT: number;
-/** outFormat */
-export declare const ARRAY: number;
-/** outFormat */
-export declare const OBJECT: number;
-
-/**
- * Do not use this method - used internally by node-oracledb.
- */
-export declare function newLob(iLob: ILob): Lob;
-
-/** Default transaction behaviour of auto commit for each statement. */
-export var autoCommit: boolean;
-/**
- * The user-chosen Connection class value defines a logical name for connections. Most single purpose applications should set connectionClass when using a connection pool or DRCP.
- * When a pooled session has a connection class, Oracle ensures that the session is not shared outside of that connection class.
- */
-export var connectionClass: string;
-/**
- * Determines whether additional metadata is available for queries and for REF CURSORs returned from PL/SQL blocks.
- * The default value for extendedMetaData is false. With this value, the result.metaData result.resultSet.metaData objects only include column names.
- */
-export var extendedMetaData: boolean;
-/** Default authentication/authorization method. When true, the SO trusted user will be used. */
-export var externalAuth: boolean;
-/**
- * An array of node-oracledb types. When any column having the specified type is queried with execute(), the column data is returned as a string instead of the native representation. For column types not specified in fetchAsString, native types will be returned.
- * By default all columns are returned as native types.
- */
-export var fetchAsString: Array<number>;
-/** Default size in bytes that the driver will fetch from LOBs in advance. */
-export var lobPrefetchSize: number;
-/** Default maximum number of rows to be fetched in statements not using ResultSets */
-export var maxRows: number;
-/** Version of OCI that is used. */
-export var oracleClientVersion: number;
-/** Default format for returning rows. When ARRAY, it will return Array<Array<any>>. When OBJECT, it will return Array<Object>. */
-export var outFormat: number;
-/** Default number of connections to increment when available connections reach 0 in created pools. poolMax will be respected.*/
-export var poolIncrement: number;
-/** Default maximum connections in created pools */
-export var poolMax: number;
-/** Default minimum connections in created pools */
-export var poolMin: number;
-/** Default timeout for unused connections in pool to be released. poolMin will be respected.*/
-export var poolTimeout: number;
-/** Default number of rows that the driver will fetch in each query.*/
-export var prefetchRows: number;
-/**
- * Node-oracledb supports Promises on all methods. The standard Promise library is used in Node 0.12 and greater. Promise support is not enabled by default in Node 0.10.
- */
-export var Promise: any;
-/**
- * If this property is true and the number of connections "checked out" from the pool has reached the number specified by poolMax, then new requests for connections are queued until in-use connections are released.
- * If this property is false and a request for a connection is made from a pool where the number of "checked out" connections has reached poolMax, then an ORA-24418 error indicating that further sessions cannot be opened will be returned.
- * The default value is true.
- */
-export var queueRequests: boolean;
-/**
- * The number of milliseconds after which connection requests waiting in the connection request queue are terminated. If queueTimeout is 0, then queued connection requests are never terminated.
- * The default value is 60000.
- */
-export var queueTimeout: number;
-/** Default size of statements cache. Used to speed up creating queries.*/
-export var stmtCacheSize: number;
-/** node-oracledb driver version. */
-export var version: number;
-
-/**
- * Creates a database managed connection pool.
- * @param  {IPoolAttributes} poolAttributes Parameters to stablish the connection pool.
- * @param  {(err:any,connection:IConnectionPool)=>void} callback Callback to run when the connection pool gets created or when some error occurs.
- * @returns void
- */
-export function createPool(poolAttributes: IPoolAttributes, callback: (err: any, connection: IConnectionPool) => void): void;
-
-/**
- * Creates a database managed connection pool.
- * @param  {IPoolAttributes} poolAttributes Parameters to stablish the connection pool.
- * @returns Promise {(connection:IConnectionPool)=>any} Promise with the connection pool.
- */
-export function createPool(poolAttributes: IPoolAttributes): IPromise< IConnectionPool >;
-
-/**
- * Creates a connection with the database.
- * @param  {IConnectionAttributes} connectionAttributes Parameters to stablish the connection.
- * @param  {(err:any,connection:IConnection)=>void} callback Callback to run when the connection gets stablished or when some error occurs.
- * @returns void
- */
-export function getConnection(connectionAttributes: IConnectionAttributes, callback: (err: any, connection: IConnection) => void): void;
-
-/**
- * Creates a connection with the database.
- * @param  {IConnectionAttributes} connectionAttributes Parameters to stablish the connection.
- * @returns  {(connection:IConnection)=>any} Promise with the connection.
- */
-export function getConnection(connectionAttributes: IConnectionAttributes): IPromise< IConnection >;
\ No newline at end of file
+export = oracledb;
\ No newline at end of file

From 13dec92fd9925db2735664e380bfa5902359ae02 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Fri, 7 Oct 2016 14:41:25 -0700
Subject: [PATCH 13/24] Fix failing tests after
 https://github.com/Microsoft/TypeScript/pull/11263 (#11835)

* Fix fialing tests after https://github.com/Microsoft/TypeScript/pull/11263

* Fix more failures
---
 async/async-tests.ts                          |   8 +-
 jasmine-ajax/jasmine-ajax-tests.ts            |   8 +-
 jquery.bbq/jquery.bbq-tests.ts                | 510 +++++++++---------
 jqueryui/jqueryui-tests.ts                    |   6 +-
 .../knockout-templatingBehaviors-tests.ts     |   2 +-
 knockout/tests/knockout-tests.ts              |  10 +-
 kolite/kolite-tests.ts                        |   8 +-
 physijs/tests/body.ts                         |  32 +-
 physijs/tests/collisions.ts                   |  32 +-
 physijs/tests/compound.ts                     |  28 +-
 physijs/tests/constraints_car.ts              |  24 +-
 physijs/tests/heightfield.ts                  |  26 +-
 physijs/tests/jenga.ts                        |  42 +-
 physijs/tests/memorytest-compound.ts          |  30 +-
 physijs/tests/memorytest-convex.ts            |  28 +-
 physijs/tests/memorytest.ts                   |  28 +-
 physijs/tests/shapes.ts                       |  26 +-
 physijs/tests/vehicle.ts                      |  28 +-
 .../canvas/canvas_camera_orthographic.ts      |   6 +-
 three/tests/canvas/canvas_geometry_cube.ts    |   6 +-
 .../canvas/canvas_interactive_cubes_tween.ts  |   6 +-
 three/tests/canvas/canvas_materials.ts        |   6 +-
 three/tests/canvas/canvas_particles_floor.ts  |   6 +-
 three/tests/webgl/webgl_animation_cloth.ts    |  27 +-
 .../webgl/webgl_animation_skinning_morph.ts   |  22 +-
 three/tests/webgl/webgl_buffergeometry.ts     |  17 +-
 three/tests/webgl/webgl_camera.ts             |  11 +-
 three/tests/webgl/webgl_custom_attributes.ts  |  16 +-
 three/tests/webgl/webgl_geometries.ts         |   6 +-
 three/tests/webgl/webgl_interactive_cubes.ts  |   8 +-
 .../webgl_interactive_raycasting_points.ts    |   6 +-
 three/tests/webgl/webgl_lensflares.ts         |   2 +-
 three/tests/webgl/webgl_lights_hemisphere.ts  |   2 +-
 three/tests/webgl/webgl_lines_colors.ts       |   9 +-
 three/tests/webgl/webgl_loader_awd.ts         |   6 +-
 three/tests/webgl/webgl_materials.ts          |   6 +-
 three/tests/webgl/webgl_points_billboards.ts  |   6 +-
 three/tests/webgl/webgl_shader.ts             |   6 +-
 38 files changed, 533 insertions(+), 523 deletions(-)

diff --git a/async/async-tests.ts b/async/async-tests.ts
index de5fbb387f..b724582368 100644
--- a/async/async-tests.ts
+++ b/async/async-tests.ts
@@ -1,8 +1,12 @@
+/// <reference types="node" />
 
+import fs = require("fs");
 
-var fs, path;
+var path: {
+    exists: (path: string, callback?: (err: string, exists: boolean) => any) => void;
+};
 
-function callback() {}
+function callback() { }
 
 async.map(['file1', 'file2', 'file3'], fs.stat, function (err, results) { });
 async.mapSeries(['file1', 'file2', 'file3'], fs.stat, function (err, results) { });
diff --git a/jasmine-ajax/jasmine-ajax-tests.ts b/jasmine-ajax/jasmine-ajax-tests.ts
index 8cea33e453..890a724420 100644
--- a/jasmine-ajax/jasmine-ajax-tests.ts
+++ b/jasmine-ajax/jasmine-ajax-tests.ts
@@ -889,7 +889,7 @@ describe("Jasmine Mock Ajax (for toplevel)", function() {
 				client.send();
 
 				request = mockAjax.requests.mostRecent();
-				response = { status: 200, statusText: "OK", contentType: "text/html", responseText: "OK!" };
+				response = { status: 200, statusText: "OK", contentType: "text/html", responseText: "OK!", responseType: "json" };
 				request.respondWith(response);
 
 				sharedContext.responseCallback = success;
@@ -1102,7 +1102,7 @@ describe("Jasmine Mock Ajax (for toplevel)", function() {
 				client.send();
 
 				request = mockAjax.requests.mostRecent();
-				response = { status: 0, statusText: "ABORT", responseText: '{"foo": "whoops!"}' };
+				response = { status: 0, statusText: "ABORT", responseText: '{"foo": "whoops!"}', responseType: "json"};
 				request.respondWith(response);
 
 				sharedContext.responseCallback = error;
@@ -1138,7 +1138,7 @@ describe("Jasmine Mock Ajax (for toplevel)", function() {
 			client.send();
 
 			request = mockAjax.requests.mostRecent();
-			response = { status: 500, statusText: "SERVER ERROR", contentType: "text/html", responseText: "(._){" };
+			response = { status: 500, statusText: "SERVER ERROR", contentType: "text/html", responseText: "(._){",responseType: "json"};
 			request.respondWith(response);
 
 			sharedContext.responseCallback = error;
@@ -1175,7 +1175,7 @@ describe("Jasmine Mock Ajax (for toplevel)", function() {
 			client.send();
 
 			request = mockAjax.requests.mostRecent();
-			response = { contentType: "text/html", response: "(._){response", responseText: "(._){", responseType: "text" };
+			response = { contentType: "text/html", response: "(._){response", responseText: "(._){", responseType: "text",  status: 200, statusText: 'OK' };
 			request.responseTimeout(response);
 
 			sharedContext.responseCallback = error;
diff --git a/jquery.bbq/jquery.bbq-tests.ts b/jquery.bbq/jquery.bbq-tests.ts
index fd49051ed3..baa6c7f42f 100644
--- a/jquery.bbq/jquery.bbq-tests.ts
+++ b/jquery.bbq/jquery.bbq-tests.ts
@@ -15,7 +15,7 @@ var recursiveEncoded = $.param(myObject);
 var recursiveDecoded = decodeURIComponent($.param(myObject));
 var shallowEncoded = $.param(myObject, true);
 var shallowDecoded = decodeURIComponent(shallowEncoded);
- 
+
 var params = { width:1680, height:1050 };
 var str = jQuery.param(params);
 $("#results").text(str);
@@ -24,7 +24,7 @@ $("#results").text(str);
 $.param({ a: [2,3,4] }) // "a=2&a=3&a=4"
 // >=1.4:
 $.param({ a: [2,3,4] }) // "a[]=2&a[]=3&a[]=4"
- 
+
 // <=1.3.2:
 $.param({ a: { b:1,c:2 }, d: [3,4,<any>{ e:5 }] }) // "a=[object+Object]&d=3&d=4&d=[object+Object]"
 // >=1.4:
@@ -67,7 +67,7 @@ function run_many_tests(...args: any[]) {
     func_each = $.isFunction( tests[0] ) && tests.shift(),
     func_done = $.isFunction( tests[0] ) && tests.shift(),
     result;
-  
+
   function set_result( i, test ) {
     result = $.isArray( test )
       ? func_each.apply( this, test )
@@ -75,10 +75,10 @@ function run_many_tests(...args: any[]) {
         ? test( result )
         : '';
   };
-  
+
   if ( delay ) {
     stop();
-    
+
     (function loopy(){
       //test && test.func && test.func( result );
       if ( tests.length ) {
@@ -89,7 +89,7 @@ function run_many_tests(...args: any[]) {
         start();
       }
     })();
-    
+
   } else {
     $.each( tests, set_result );
     func_done && func_done();
@@ -105,7 +105,7 @@ var params_obj = { a:['4','5','6'], b:{x:['7'], y:'8', z:['9','0','true','false'
   params_obj_coerce = { a:[4,5,6] },//, b:{x:[7], y:8, z:[9,0,true,false,undefined,'']}, c:1 },
   params_str = params_init,
   params_str_old = 'a=4&a=5&a=6&b=[object+Object]&c=1',
-  
+
   // If a params fragment starts with ! and BBQ is not in ajaxCrawlable mode,
   // things can get very ugly, very quickly.
   params_obj_bang = { "!a":['4'], a:['5','6'], b:{x:['7'], y:'8', z:['9','0','true','false','undefined','']}, c:'1' },
@@ -136,7 +136,7 @@ test( 'jQuery.param.sorted', function() {
       expected_old: 'a=4,5,6&a=7,8,9' // obviously not great, but that's the way jQuery used to roll
     }
   ];
-  
+
   if ( $.fn.jquery != '1.4.1' ) {
     // this explodes in jQuery 1.4.1
     tests.push({
@@ -146,36 +146,36 @@ test( 'jQuery.param.sorted', function() {
       expected: 'a[]=3&a[]=2&a[]=1&b[]=6&b[]=5&b[]=4&x=2&z=1'
     });
   }
-  
+
   expect( tests.length * 2 + 6 );
-  
+
   $.each( tests, function(i,test: any){
     var unsorted = $.param( test.obj, test.traditional ),
       sorted = $.param.sorted( test.obj, test.traditional );
-    
+
     equal( decodeURIComponent( sorted ), old_jquery && test.expected_old || test.expected, 'params should be sorted' );
     deepEqual( $.deparam( unsorted, true ), $.deparam( sorted, true ), 'sorted params should deparam the same as unsorted params' )
   });
-  
+
   equal( $.param.fragment( 'foo', '#b=2&a=1' ), 'foo#a=1&b=2', 'params should be sorted' );
   equal( $.param.fragment( 'foo', '#b=2&a=1', 1 ), 'foo#a=1&b=2', 'params should be sorted' );
   equal( $.param.fragment( 'foo', '#b=2&a=1', 2 ), 'foo#b=2&a=1', 'params should NOT be sorted' );
   equal( $.param.fragment( 'foo#c=3&a=4', '#b=2&a=1' ), 'foo#a=1&b=2&c=3', 'params should be sorted' );
   equal( $.param.fragment( 'foo#c=3&a=4', '#b=2&a=1', 1 ), 'foo#a=4&b=2&c=3', 'params should be sorted' );
   equal( $.param.fragment( 'foo#c=3&a=4', '#b=2&a=1', 2 ), 'foo#b=2&a=1', 'params should NOT be sorted' );
-  
+
 });
 
 test( 'jQuery.param.querystring', function() {
   expect( 11 );
-  
+
   equal( $.param.querystring( 'http://example.com/' ), '', 'properly identifying params' );
   equal( $.param.querystring( 'http://example.com/?foo' ),'foo', 'properly identifying params' );
   equal( $.param.querystring( 'http://example.com/?foo#bar' ),'foo', 'properly identifying params' );
   equal( $.param.querystring( 'http://example.com/?foo#bar?baz' ),'foo', 'properly identifying params' );
   equal( $.param.querystring( 'http://example.com/#foo' ),'', 'properly identifying params' );
   equal( $.param.querystring( 'http://example.com/#foo?bar' ),'', 'properly identifying params' );
-  
+
   equal( $.param.querystring(), params_str, 'params string from window.location' );
   equal( $.param.querystring( '?' + params_str ), params_str, 'params string from url' );
   equal( $.param.querystring( 'foo.html?' + params_str ), params_str, 'params string from url' );
@@ -185,276 +185,276 @@ test( 'jQuery.param.querystring', function() {
 
 test( 'jQuery.param.querystring - build URL', function() {
   expect( 10 );
-  
+
   function fake_encode( params_str ) {
     return '?' + $.map( params_str.split('&'), encodeURIComponent ).join('&').replace( /%3D/g, '=' ).replace( /%2B/g, '+' );
   }
-  
+
   var pre = 'http://a:b@example.com:1234/foo.html',
     post = '#get-on-the-floor',
     current_url = pre + post;
-  
+
   run_many_tests(
-    
+
     // execute this for each array item
     function(){
       current_url = $.param.querystring.apply( this, [ current_url ].concat( aps.call( arguments ) ) );
     },
-    
+
     // tests:
-    
+
     [ { a:'2' } ],
-    
+
     function(result){
       equal( current_url, pre + '?a=2' + post, '$.param.querystring( url, Object )' );
     },
-    
+
     [ { b:'2' } ],
-    
+
     function(result){
       equal( current_url, pre + '?a=2&b=2' + post, '$.param.querystring( url, Object )' );
     },
-    
+
     [ { c:true, d:false, e:'undefined', f:'' } ],
-    
+
     function(result){
       equal( current_url, pre + '?a=2&b=2&c=true&d=false&e=undefined&f=' + post, '$.param.querystring( url, Object )' );
     },
-    
+
     [ { a:[4,5,6]}],//, b:{x:[7], y:8, z:[9,0,<any>'true',<any>'false',<any>'undefined',<any>'']} }, 2 ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=';
-      
+
       equal( current_url, pre + fake_encode( params ) + post, '$.param.querystring( url, Object, 2 )' );
     },
-    
+
     [ <any>{ a:'1', c:'2' }, 1 ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]&c=2'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=&c=2';
-      
+
       equal( current_url, pre + fake_encode( params ) + post, '$.param.querystring( url, Object, 1 )' );
     },
-    
+
     [ 'foo=1' ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]&c=2&foo=1'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=&c=2&foo=1';
-      
+
       equal( current_url, pre + fake_encode( params ) + post, '$.param.querystring( url, String )' );
     },
-    
+
     [ <any>'foo=2&bar=3', 1 ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]&bar=3&c=2&foo=1'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=&bar=3&c=2&foo=1';
-      
+
       equal( current_url, pre + fake_encode( params ) + post, '$.param.querystring( url, String, 1 )' );
     },
-    
+
     [ <any>'http://example.com/test.html?/path/to/file.php#the-cow-goes-moo', 2 ],
-    
+
     function(result){
       equal( current_url, pre + '?/path/to/file.php' + post, '$.param.querystring( url, String, 2 )' );
     },
-    
+
     [ <any>'?another-example', 2 ],
-    
+
     function(result){
       equal( current_url, pre + '?another-example' + post, '$.param.querystring( url, String, 2 )' );
     },
-    
+
     [ <any>'i_am_out_of_witty_strings', 2 ],
-    
+
     function(result){
       equal( current_url, pre + '?i_am_out_of_witty_strings' + post, '$.param.querystring( url, String, 2 )' );
     }
-    
+
   );
-  
+
 });
 
 test( 'jQuery.param.fragment', function() {
   expect( 29 );
-  
+
   equal( $.param.fragment( 'http://example.com/' ), '', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/?foo' ),'', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/?foo#bar' ),'bar', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/?foo#bar?baz' ),'bar?baz', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/#foo' ),'foo', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/#foo?bar' ),'foo?bar', 'properly identifying params' );
-  
+
   equal( $.param.fragment( 'http://example.com/' ), '', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/?foo' ),'', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/?foo#!bar' ),'!bar', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/?foo#!bar?baz' ),'!bar?baz', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/#!foo' ),'!foo', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/#!foo?bar' ),'!foo?bar', 'properly identifying params' );
-  
+
   equal( $.param.fragment(), params_str, 'params string from window.location' );
   equal( $.param.fragment( '#' + params_str ), params_str, 'params string from url' );
   equal( $.param.fragment( 'foo.html#' + params_str ), params_str, 'params string from url' );
   equal( $.param.fragment( 'http://a:b@example.com:1234/foo.html#' + params_str ), params_str, 'params string from url' );
   equal( $.param.fragment( 'http://a:b@example.com:1234/foo.html?bippity-boppity-boo#' + params_str ), params_str, 'params string from url' );
-  
+
   $.param.fragment.ajaxCrawlable( true );
-  
+
   equal( $.param.fragment( 'http://example.com/' ), '', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/?foo' ),'', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/?foo#bar' ),'bar', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/?foo#bar?baz' ),'bar?baz', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/#foo' ),'foo', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/#foo?bar' ),'foo?bar', 'properly identifying params' );
-  
+
   equal( $.param.fragment( 'http://example.com/' ), '', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/?foo' ),'', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/?foo#!bar' ),'bar', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/?foo#!bar?baz' ),'bar?baz', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/#!foo' ),'foo', 'properly identifying params' );
   equal( $.param.fragment( 'http://example.com/#!foo?bar' ),'foo?bar', 'properly identifying params' );
-  
+
   $.param.fragment.ajaxCrawlable( false );
-  
+
 });
 
 test( 'jQuery.param.fragment - build URL', function() {
   expect( 40 );
-  
+
   function fake_encode( params_str ) {
     return '#' + $.map( params_str.split('&'), encodeURIComponent ).join('&').replace( /%3D/g, '=' ).replace( /%2B/g, '+' );
   }
-  
+
   var pre = 'http://a:b@example.com:1234/foo.html?and-dance-with-me',
     current_url = pre;
-  
+
   run_many_tests(
-    
+
     // execute this for each array item
     function(){
       current_url = $.param.fragment.apply( this, [ current_url ].concat( aps.call( arguments ) ) );
     },
-    
+
     // tests:
-    
+
     [ { a:'2' } ],
-    
+
     function(result){
       equal( current_url, pre + '#a=2', '$.param.fragment( url, Object )' );
     },
-    
+
     [ { b:'2' } ],
-    
+
     function(result){
       equal( current_url, pre + '#a=2&b=2', '$.param.fragment( url, Object )' );
     },
-    
+
     [ { c:true, d:false, e:'undefined', f:'' } ],
-    
+
     function(result){
       equal( current_url, pre + '#a=2&b=2&c=true&d=false&e=undefined&f=', '$.param.fragment( url, Object )' );
     },
-    
+
     [ { a:[4,5,6]}],//, b:{x:[7], y:8, z:[9,0,'true','false','undefined','']} }, 2 ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=';
-      
+
       equal( current_url, pre + fake_encode( params ), '$.param.fragment( url, Object, 2 )' );
     },
-    
+
     [ <any>{ a:'1', c:'2' }, 1 ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]&c=2'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=&c=2';
-      
+
       equal( current_url, pre + fake_encode( params ), '$.param.fragment( url, Object, 1 )' );
     },
-    
+
     [ 'foo=1' ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]&c=2&foo=1'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=&c=2&foo=1';
-      
+
       equal( current_url, pre + fake_encode( params ), '$.param.fragment( url, String )' );
     },
-    
+
     [ <any>'foo=2&bar=3', 1 ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]&bar=3&c=2&foo=1'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=&bar=3&c=2&foo=1';
-      
+
       equal( current_url, pre + fake_encode( params ), '$.param.fragment( url, String, 1 )' );
     },
-    
+
     [ <any>'http://example.com/test.html?the-cow-goes-moo#/path/to/file.php', 2 ],
-    
+
     function(result){
       equal( current_url, pre + '#/path/to/file.php', '$.param.fragment( url, String, 2 )' );
     },
-    
+
     [ <any>'#another-example', 2 ],
-    
+
     function(result){
       equal( current_url, pre + '#another-example', '$.param.fragment( url, String, 2 )' );
     },
-    
+
     [ <any>'i_am_out_of_witty_strings', 2 ],
-    
+
     function(result){
       equal( current_url, pre + '#i_am_out_of_witty_strings', '$.param.fragment( url, String, 2 )' );
     }
-    
+
   );
-  
+
   $.param.fragment.ajaxCrawlable( true );
-  
+
   equal( $.param.fragment( 'foo', {} ) , 'foo#!', '$.param.fragment( url, Object )' );
   equal( $.param.fragment( 'foo', { b:2, a:1 } ) , 'foo#!a=1&b=2', '$.param.fragment( url, Object )' );
   equal( $.param.fragment( 'foo#', { b:2, a:1 } ) , 'foo#!a=1&b=2', '$.param.fragment( url, Object )' );
   equal( $.param.fragment( 'foo#!', { b:2, a:1 } ) , 'foo#!a=1&b=2', '$.param.fragment( url, Object )' );
   equal( $.param.fragment( 'foo#c=3&a=4', { b:2, a:1 } ) , 'foo#!a=1&b=2&c=3', '$.param.fragment( url, Object )' );
   equal( $.param.fragment( 'foo#!c=3&a=4', { b:2, a:1 } ) , 'foo#!a=1&b=2&c=3', '$.param.fragment( url, Object )' );
-  
+
   equal( $.param.fragment( 'foo', '' ) , 'foo#!', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo', 'b=2&a=1' ) , 'foo#!a=1&b=2', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo#', 'b=2&a=1' ) , 'foo#!a=1&b=2', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo#!', 'b=2&a=1' ) , 'foo#!a=1&b=2', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo#c=3&a=4', 'b=2&a=1' ) , 'foo#!a=1&b=2&c=3', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo#!c=3&a=4', 'b=2&a=1' ) , 'foo#!a=1&b=2&c=3', '$.param.fragment( url, String )' );
-  
+
   equal( $.param.fragment( 'foo', '#' ) , 'foo#!', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo', '#b=2&a=1' ) , 'foo#!a=1&b=2', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo#', '#b=2&a=1' ) , 'foo#!a=1&b=2', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo#!', '#b=2&a=1' ) , 'foo#!a=1&b=2', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo#c=3&a=4', '#b=2&a=1' ) , 'foo#!a=1&b=2&c=3', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo#!c=3&a=4', '#b=2&a=1' ) , 'foo#!a=1&b=2&c=3', '$.param.fragment( url, String )' );
-  
+
   equal( $.param.fragment( 'foo', '#!' ) , 'foo#!', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo', '#!b=2&a=1' ) , 'foo#!a=1&b=2', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo#', '#!b=2&a=1' ) , 'foo#!a=1&b=2', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo#!', '#!b=2&a=1' ) , 'foo#!a=1&b=2', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo#c=3&a=4', '#!b=2&a=1' ) , 'foo#!a=1&b=2&c=3', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo#!c=3&a=4', '#!b=2&a=1' ) , 'foo#!a=1&b=2&c=3', '$.param.fragment( url, String )' );
-  
+
   $.param.fragment.ajaxCrawlable( false );
-  
+
   // If a params fragment starts with ! and BBQ is not in ajaxCrawlable mode,
   // things can get very ugly, very quickly.
   equal( $.param.fragment( 'foo', '#!' ) , 'foo#!=', '$.param.fragment( url, String )' );
@@ -463,12 +463,12 @@ test( 'jQuery.param.fragment - build URL', function() {
   equal( $.param.fragment( 'foo#!', '#!b=2&a=1' ) , 'foo#!=&!b=2&a=1', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo#c=3&a=4', '#!b=2&a=1' ) , 'foo#!b=2&a=1&c=3', '$.param.fragment( url, String )' );
   equal( $.param.fragment( 'foo#!c=3&a=4', '#!b=2&a=1' ) , 'foo#!b=2&!c=3&a=1', '$.param.fragment( url, String )' );
-  
+
 });
 
 test( 'jQuery.param.fragment.ajaxCrawlable', function() {
   expect( 5 );
-  
+
   equal( ajaxcrawlable_init, false, 'ajaxCrawlable is disabled by default' );
   equal( $.param.fragment.ajaxCrawlable( true ), true, 'enabling ajaxCrawlable should return true' );
   equal( $.param.fragment.ajaxCrawlable(), true, 'ajaxCrawlable is now enabled' );
@@ -478,13 +478,13 @@ test( 'jQuery.param.fragment.ajaxCrawlable', function() {
 
 test( 'jQuery.param.fragment.noEscape', function() {
   expect( 2 );
-  
+
   equal( $.param.fragment( '#', { foo: '/a,b@c$d+e&f=g h!' } ), '#foo=/a,b%40c%24d%2Be%26f%3Dg+h!', '/, should be unescaped, everything else but space (+) should be urlencoded' );
-  
+
   $.param.fragment.ajaxCrawlable( true );
-  
+
   equal( $.param.fragment( '#', { foo: '/a,b@c$d+e&f=g h!' } ), '#!foo=/a,b%40c%24d%2Be%26f%3Dg+h!', '/, should be unescaped, everything else but ! and space (+) should be urlencoded' );
-  
+
   $.param.fragment.ajaxCrawlable( false );
 });
 
@@ -505,7 +505,7 @@ test( 'jQuery.deparam - pre-1.4-style params', function() {
   var params_str = 'a=1&a=2&a=3&b=4&c=5&c=6&c=true&c=false&c=undefined&c=&d=7',
     params_obj = { a:['1','2','3'], b:'4', c:['5','6','true','false','undefined',''], d:'7' },
     params_obj_coerce = { a:[1,2,3], b:4, c:[5,6,true,false,undefined,''], d:7 };
-    
+
   expect( 2 );
   deepEqual( $.deparam( params_str ), params_obj, '$.deparam( String )' );
   deepEqual( $.deparam( params_str, true ), params_obj_coerce, '$.deparam( String, true )' );
@@ -513,7 +513,7 @@ test( 'jQuery.deparam - pre-1.4-style params', function() {
 
 test( 'jQuery.deparam.querystring', function() {
   expect( 12 );
-  
+
   deepEqual( $.deparam.querystring(), params_obj, 'params obj from window.location' );
   deepEqual( $.deparam.querystring( /*true*/ ), params_obj_coerce, 'params obj from window.location, coerced' );
   deepEqual( $.deparam.querystring( params_str ), params_obj, 'params obj from string' );
@@ -530,12 +530,12 @@ test( 'jQuery.deparam.querystring', function() {
 
 test( 'jQuery.deparam.fragment', function() {
   expect( 36 );
-  
+
   deepEqual( $.deparam.fragment(), params_obj, 'params obj from window.location' );
   deepEqual( $.deparam.fragment( /*true*/ ), params_obj_coerce, 'params obj from window.location, coerced' );
   deepEqual( $.deparam.fragment( params_str ), params_obj, 'params obj from string' );
   deepEqual( $.deparam.fragment( params_str, true ), params_obj_coerce, 'params obj from string, coerced' );
-  
+
   deepEqual( $.deparam.fragment( '#' + params_str ), params_obj, 'params obj from string' );
   deepEqual( $.deparam.fragment( '#' + params_str, true ), params_obj_coerce, 'params obj from string, coerced' );
   deepEqual( $.deparam.fragment( 'foo.html#' + params_str ), params_obj, 'params obj from string' );
@@ -544,7 +544,7 @@ test( 'jQuery.deparam.fragment', function() {
   deepEqual( $.deparam.fragment( 'http://a:b@example.com:1234/foo.html#' + params_str, true ), params_obj_coerce, 'params obj from string, coerced' );
   deepEqual( $.deparam.fragment( 'http://a:b@example.com:1234/foo.html?bippity-boppity-boo#' + params_str ), params_obj, 'params obj from string' );
   deepEqual( $.deparam.fragment( 'http://a:b@example.com:1234/foo.html?bippity-boppity-boo#' + params_str, true ), params_obj_coerce, 'params obj from string, coerced' );
-  
+
   // If a params fragment starts with ! and BBQ is not in ajaxCrawlable mode,
   // things can get very ugly, very quickly.
   deepEqual( $.deparam.fragment( '#!' + params_str ), params_obj_bang, 'params obj from string' );
@@ -555,9 +555,9 @@ test( 'jQuery.deparam.fragment', function() {
   deepEqual( $.deparam.fragment( 'http://a:b@example.com:1234/foo.html#!' + params_str, true ), params_obj_bang_coerce, 'params obj from string, coerced' );
   deepEqual( $.deparam.fragment( 'http://a:b@example.com:1234/foo.html?bippity-boppity-boo#!' + params_str ), params_obj_bang, 'params obj from string' );
   deepEqual( $.deparam.fragment( 'http://a:b@example.com:1234/foo.html?bippity-boppity-boo#!' + params_str, true ), params_obj_bang_coerce, 'params obj from string, coerced' );
-  
+
   $.param.fragment.ajaxCrawlable( true );
-  
+
   deepEqual( $.deparam.fragment( '#' + params_str ), params_obj, 'params obj from string' );
   deepEqual( $.deparam.fragment( '#' + params_str, true ), params_obj_coerce, 'params obj from string, coerced' );
   deepEqual( $.deparam.fragment( 'foo.html#' + params_str ), params_obj, 'params obj from string' );
@@ -566,7 +566,7 @@ test( 'jQuery.deparam.fragment', function() {
   deepEqual( $.deparam.fragment( 'http://a:b@example.com:1234/foo.html#' + params_str, true ), params_obj_coerce, 'params obj from string, coerced' );
   deepEqual( $.deparam.fragment( 'http://a:b@example.com:1234/foo.html?bippity-boppity-boo#' + params_str ), params_obj, 'params obj from string' );
   deepEqual( $.deparam.fragment( 'http://a:b@example.com:1234/foo.html?bippity-boppity-boo#' + params_str, true ), params_obj_coerce, 'params obj from string, coerced' );
-  
+
   deepEqual( $.deparam.fragment( '#!' + params_str ), params_obj, 'params obj from string' );
   deepEqual( $.deparam.fragment( '#!' + params_str, true ), params_obj_coerce, 'params obj from string, coerced' );
   deepEqual( $.deparam.fragment( 'foo.html#!' + params_str ), params_obj, 'params obj from string' );
@@ -575,7 +575,7 @@ test( 'jQuery.deparam.fragment', function() {
   deepEqual( $.deparam.fragment( 'http://a:b@example.com:1234/foo.html#!' + params_str, true ), params_obj_coerce, 'params obj from string, coerced' );
   deepEqual( $.deparam.fragment( 'http://a:b@example.com:1234/foo.html?bippity-boppity-boo#!' + params_str ), params_obj, 'params obj from string' );
   deepEqual( $.deparam.fragment( 'http://a:b@example.com:1234/foo.html?bippity-boppity-boo#!' + params_str, true ), params_obj_coerce, 'params obj from string, coerced' );
-  
+
   $.param.fragment.ajaxCrawlable( false );
 });
 
@@ -599,7 +599,7 @@ function init_url_attr( _, url ) {
 
 function test_url_attr( container ) {
   var url;
-  
+
   $.each( test_elems, function(i,v){
     var val = container.children( v ).attr( $.elemUrlAttr()[ v ] );
     if ( !url ) {
@@ -608,277 +608,277 @@ function test_url_attr( container ) {
       url = -1;
     }
   });
-  
+
   return url;
 };
 
 test( 'jQuery.fn.querystring', function() {
   expect( 60 );
-  
+
   function fake_encode( params_str ) {
     return '?' + $.map( params_str.split('&'), encodeURIComponent ).join('&').replace( /%3D/g, '=' ).replace( /%2B/g, '+' );
   }
-  
+
   var pre = 'http://a:b@example.com:1234/foo.html',
     post = '#get-on-the-floor',
     current_url = pre + post;
-  
+
   run_many_tests(
-    
+
     // execute this for each array item
     function(){
       var container,
         elems;
-      
+
       container = init_url_attr( container, current_url );
       elems = container.children('span');
       equal( elems.length, 1, 'select the correct elements' );
       equal( elems.querystring.apply( elems, [ 'arbitrary_attr' ].concat( aps.call( arguments ) ) ), elems, 'pass query string' );
-      
+
       container = init_url_attr( container, current_url );
       elems = container.children('a, link');
       equal( elems.length, 2, 'select the correct elements' );
       equal( elems.querystring.apply( elems, [ 'href' ].concat( aps.call( arguments ) ) ), elems, 'pass query string' );
-      
+
       container = init_url_attr( container, current_url );
       elems = container.children();
       equal( elems.querystring.apply( elems, aps.call( arguments ) ), elems, 'pass query string' );
-      
+
       current_url = test_url_attr( container );
     },
-    
+
     // tests:
-    
+
     [ { a:'2' } ],
-    
+
     function(result){
       equal( current_url, pre + '?a=2' + post, '$.fn.querystring( url, Object )' );
     },
-    
+
     [ { b:'2' } ],
-    
+
     function(result){
       equal( current_url, pre + '?a=2&b=2' + post, '$.fn.querystring( url, Object )' );
     },
-    
+
     [ { c:true, d:false, e:'undefined', f:'' } ],
-    
+
     function(result){
       equal( current_url, pre + '?a=2&b=2&c=true&d=false&e=undefined&f=' + post, '$.fn.querystring( url, Object )' );
     },
-    
+
     [ { a:[4,5,6]}],//, b:{x:[7], y:8, z:[9,0,'true','false','undefined','']} }, 2 ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=';
-      
+
       equal( current_url, pre + fake_encode( params ) + post, '$.fn.querystring( url, Object, 2 )' );
     },
-    
+
     [ <any>{ a:'1', c:'2' }, 1 ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]&c=2'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=&c=2';
-      
+
       equal( current_url, pre + fake_encode( params ) + post, '$.fn.querystring( url, Object, 1 )' );
     },
-    
+
     [ 'foo=1' ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]&c=2&foo=1'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=&c=2&foo=1';
-      
+
       equal( current_url, pre + fake_encode( params ) + post, '$.fn.querystring( url, String )' );
     },
-    
+
     [ <any>'foo=2&bar=3', 1 ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]&bar=3&c=2&foo=1'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=&bar=3&c=2&foo=1';
-      
+
       equal( current_url, pre + fake_encode( params ) + post, '$.fn.querystring( url, String, 1 )' );
     },
-    
+
     [ <any>'http://example.com/test.html?/path/to/file.php#the-cow-goes-moo', 2 ],
-    
+
     function(result){
       equal( current_url, pre + '?/path/to/file.php' + post, '$.fn.querystring( url, String, 2 )' );
     },
-    
+
     [ <any>'?another-example', 2 ],
-    
+
     function(result){
       equal( current_url, pre + '?another-example' + post, '$.fn.querystring( url, String, 2 )' );
     },
-    
+
     [ <any>'i_am_out_of_witty_strings', 2 ],
-    
+
     function(result){
       equal( current_url, pre + '?i_am_out_of_witty_strings' + post, '$.fn.querystring( url, String, 2 )' );
     }
-    
+
   );
-  
+
 });
 
 test( 'jQuery.fn.fragment', function() {
   expect( 240 );
-  
+
   function fake_encode( params_str ) {
     return '#' + $.map( params_str.split('&'), encodeURIComponent ).join('&').replace( /%3D/g, '=' ).replace( /%2B/g, '+' );
   }
-  
+
   var pre = 'http://a:b@example.com:1234/foo.html?and-dance-with-me',
     current_url = pre;
-  
+
   run_many_tests(
-    
+
     // execute this for each array item
     function( params, merge_mode ){
       current_url = test_fn_fragment( current_url, params, merge_mode );
     },
-    
+
     // tests:
-    
+
     [ { a:'2' } ],
-    
+
     function(result){
       equal( current_url, pre + '#a=2', '$.fn.fragment( url, Object )' );
     },
-    
+
     [ { b:'2' } ],
-    
+
     function(result){
       equal( current_url, pre + '#a=2&b=2', '$.fn.fragment( url, Object )' );
     },
-    
+
     [ { c:true, d:false, e:'undefined', f:'' } ],
-    
+
     function(result){
       equal( current_url, pre + '#a=2&b=2&c=true&d=false&e=undefined&f=', '$.fn.fragment( url, Object )' );
     },
-    
+
     [ { a:[4,5,6]}],//, b:{x:[7], y:8, z:[9,0,'true','false','undefined','']} }, 2 ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=';
-      
+
       equal( current_url, pre + fake_encode( params ), '$.fn.fragment( url, Object, 2 )' );
     },
-    
+
     [ <any>{ a:'1', c:'2' }, 1 ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]&c=2'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=&c=2';
-      
+
       equal( current_url, pre + fake_encode( params ), '$.fn.fragment( url, Object, 1 )' );
     },
-    
+
     [ 'foo=1' ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]&c=2&foo=1'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=&c=2&foo=1';
-      
+
       equal( current_url, pre + fake_encode( params ), '$.fn.fragment( url, String )' );
     },
-    
+
     [ <any>'foo=2&bar=3', 1 ],
-    
+
     function(result){
       var params = old_jquery
         ? 'a=4&a=5&a=6&b=[object+Object]&bar=3&c=2&foo=1'
         : 'a[]=4&a[]=5&a[]=6&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=0&b[z][]=true&b[z][]=false&b[z][]=undefined&b[z][]=&bar=3&c=2&foo=1';
-      
+
       equal( current_url, pre + fake_encode( params ), '$.fn.fragment( url, String, 1 )' );
     },
-    
+
     [ <any>'http://example.com/test.html?the-cow-goes-moo#/path/to/file.php', 2 ],
-    
+
     function(result){
       equal( current_url, pre + '#/path/to/file.php', '$.fn.fragment( url, String, 2 )' );
     },
-    
+
     [ <any>'#another-example', 2 ],
-    
+
     function(result){
       equal( current_url, pre + '#another-example', '$.fn.fragment( url, String, 2 )' );
     },
-    
+
     [ <any>'i_am_out_of_witty_strings', 2 ],
-    
+
     function(result){
       equal( current_url, pre + '#i_am_out_of_witty_strings', '$.fn.fragment( url, String, 2 )' );
     }
-    
+
   );
-  
+
   $.param.fragment.ajaxCrawlable( true );
-  
+
   function test_fn_fragment( url, params, merge_mode? ) {
     var container,
       elems;
-    
+
     container = init_url_attr( container, url );
     elems = container.children('span');
     equal( elems.length, 1, 'select the correct elements' );
     equal( elems.fragment( 'arbitrary_attr', params, merge_mode ), elems, 'pass fragment' );
-    
+
     container = init_url_attr( container, url );
     elems = container.children('a, link');
     equal( elems.length, 2, 'select the correct elements' );
     equal( elems.fragment( params, merge_mode ), elems, 'pass fragment' );
-    
+
     container = init_url_attr( container, url );
     elems = container.children();
     equal( elems.fragment( params, merge_mode ), elems, 'pass fragment' );
-    
+
     return test_url_attr( container );
   };
-  
+
   equal( test_fn_fragment( 'foo', {} ) , 'foo#!', '$.fn.fragment( url, Object )' );
   equal( test_fn_fragment( 'foo', { b:2, a:1 } ) , 'foo#!a=1&b=2', '$.fn.fragment( url, Object )' );
   equal( test_fn_fragment( 'foo#', { b:2, a:1 } ) , 'foo#!a=1&b=2', '$.fn.fragment( url, Object )' );
   equal( test_fn_fragment( 'foo#!', { b:2, a:1 } ) , 'foo#!a=1&b=2', '$.fn.fragment( url, Object )' );
   equal( test_fn_fragment( 'foo#c=3&a=4', { b:2, a:1 } ) , 'foo#!a=1&b=2&c=3', '$.fn.fragment( url, Object )' );
   equal( test_fn_fragment( 'foo#!c=3&a=4', { b:2, a:1 } ) , 'foo#!a=1&b=2&c=3', '$.fn.fragment( url, Object )' );
-  
+
   equal( test_fn_fragment( 'foo', '' ) , 'foo#!', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo', 'b=2&a=1' ) , 'foo#!a=1&b=2', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo#', 'b=2&a=1' ) , 'foo#!a=1&b=2', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo#!', 'b=2&a=1' ) , 'foo#!a=1&b=2', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo#c=3&a=4', 'b=2&a=1' ) , 'foo#!a=1&b=2&c=3', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo#!c=3&a=4', 'b=2&a=1' ) , 'foo#!a=1&b=2&c=3', '$.fn.fragment( url, String )' );
-  
+
   equal( test_fn_fragment( 'foo', '#' ) , 'foo#!', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo', '#b=2&a=1' ) , 'foo#!a=1&b=2', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo#', '#b=2&a=1' ) , 'foo#!a=1&b=2', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo#!', '#b=2&a=1' ) , 'foo#!a=1&b=2', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo#c=3&a=4', '#b=2&a=1' ) , 'foo#!a=1&b=2&c=3', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo#!c=3&a=4', '#b=2&a=1' ) , 'foo#!a=1&b=2&c=3', '$.fn.fragment( url, String )' );
-  
+
   equal( test_fn_fragment( 'foo', '#!' ) , 'foo#!', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo', '#!b=2&a=1' ) , 'foo#!a=1&b=2', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo#', '#!b=2&a=1' ) , 'foo#!a=1&b=2', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo#!', '#!b=2&a=1' ) , 'foo#!a=1&b=2', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo#c=3&a=4', '#!b=2&a=1' ) , 'foo#!a=1&b=2&c=3', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo#!c=3&a=4', '#!b=2&a=1' ) , 'foo#!a=1&b=2&c=3', '$.fn.fragment( url, String )' );
-  
+
   $.param.fragment.ajaxCrawlable( false );
-  
+
   // If a params fragment starts with ! and BBQ is not in ajaxCrawlable mode,
   // things can get very ugly, very quickly.
   equal( test_fn_fragment( 'foo', '#!' ) , 'foo#!=', '$.fn.fragment( url, String )' );
@@ -887,7 +887,7 @@ test( 'jQuery.fn.fragment', function() {
   equal( test_fn_fragment( 'foo#!', '#!b=2&a=1' ) , 'foo#!=&!b=2&a=1', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo#c=3&a=4', '#!b=2&a=1' ) , 'foo#!b=2&a=1&c=3', '$.fn.fragment( url, String )' );
   equal( test_fn_fragment( 'foo#!c=3&a=4', '#!b=2&a=1' ) , 'foo#!b=2&!c=3&a=1', '$.fn.fragment( url, String )' );
-  
+
 });
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -897,21 +897,21 @@ QUnit.module( 'jQuery.bbq' );
 
 test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(), window.onhashchange', function() {
   expect( old_jquery ? 95 : 167 );
-  
-  var a, b, c, d, e, f, x, y, hash, hash_actual, obj, event, msg = 'Testing window.onhashchange and history';
-  
+
+  var a:{ str: string, coerce: boolean }, b:{ str: string, coerce: boolean }, c, d, e, f, x, y, hash, hash_actual, obj: { str: string, coerce: boolean }, event:JQueryBbq.EventObject, msg = 'Testing window.onhashchange and history';
+
   $.bbq.pushState();
   equal( window.location.hash.replace( /^#/, ''), '', 'window.location hash should be empty' );
-  
+
   $.bbq.pushState({ a:'1', b:'1' });
   deepEqual( $.deparam.fragment(), { a:'1', b:'1' }, 'hash should be set properly' );
-  
+
   $(window).bind( 'hashchange', function(evt) {
     var hash_str = $.param.fragment(),
       param_obj = $.bbq.getState(),
       param_val = $.bbq.getState( 'param_name' );
-    
-    event = evt;
+
+    //event = evt;
     hash = $.param.fragment();
     hash_actual = location.hash;
     obj = { str: $.bbq.getState(), coerce: $.bbq.getState( true ) };
@@ -921,40 +921,40 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
     d = { str: $.bbq.getState( 'd' ), coerce: $.bbq.getState( 'd', true ) };
     e = { str: $.bbq.getState( 'e' ), coerce: $.bbq.getState( 'e', true ) };
     f = { str: $.bbq.getState( 'f' ), coerce: $.bbq.getState( 'f', true ) };
-    
+
   }).trigger( 'hashchange' );
-  
+
   deepEqual( obj.str, { a:'1', b:'1' }, 'hashchange triggered manually: $.bbq.getState()' );
   deepEqual( obj.coerce, { a:1, b:1 },  'hashchange triggered manually: $.bbq.getState( true )' );
   equal( a.str, '1', 'hashchange triggered manually: $.bbq.getState( "a" )' );
   equal( a.coerce, 1, 'hashchange triggered manually: $.bbq.getState( "a", true )' );
-  
+
   if ( !old_jquery ) {
     deepEqual( event.getState(), { a:'1', b:'1' }, 'hashchange triggered manually: event.getState()' );
-    deepEqual( event.getState(true), { a:1, b:1 },  'hashchange triggered manually: event.getState( true )' );
+    deepEqual( event.getState('a'), { a:1, b:1 },  'hashchange triggered manually: event.getState( true )' );
     equal( event.getState('a'), '1', 'hashchange triggered manually: event.getState( "a" )' );
     equal( event.getState('a',true), 1, 'hashchange triggered manually: event.getState( "a", true )' );
   }
-  
+
   run_many_tests(
     // run asynchronously
     250,
-    
+
     // execute this for each array item
     function(){
       notice( msg += '.' );
       $.bbq.pushState.apply( this, aps.call( arguments ) );
     },
-    
+
     // execute this at the end
     function(){
       notice();
     },
-    
+
     // tests:
-    
+
     [ { a:'2' } ],
-    
+
     function(result){
       equal( hash_actual, '#' + hash, 'hash should begin with #!' );
       deepEqual( obj.str, { a:'2', b:'1' }, '$.bbq.getState()' );
@@ -963,14 +963,14 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
       equal( a.coerce, 2, '$.bbq.getState( "a", true )' );
       if ( !old_jquery ) {
         deepEqual( event.getState(), { a:'2', b:'1' }, 'event.getState()' );
-        deepEqual( event.getState(true), { a:2, b:1 },  'event.getState( true )' );
+        deepEqual( event.getState('a'), { a:2, b:1 },  'event.getState( true )' );
         equal( event.getState('a'), '2', 'event.getState( "a" )' );
         equal( event.getState('a',true), 2, 'event.getState( "a", true )' );
       }
     },
-    
+
     [ { b:'2' } ],
-    
+
     function(result){
       equal( hash_actual, '#' + hash, 'hash should begin with #!' );
       deepEqual( obj.str, { a:'2', b:'2' }, '$.bbq.getState()' );
@@ -979,14 +979,14 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
       equal( b.coerce, 2, '$.bbq.getState( "b", true )' );
       if ( !old_jquery ) {
         deepEqual( event.getState(), { a:'2', b:'2' }, 'event.getState()' );
-        deepEqual( event.getState(true), { a:2, b:2 },  'event.getState( true )' );
+        deepEqual( event.getState('a'), { a:2, b:2 },  'event.getState( true )' );
         equal( event.getState('b'), '2', 'event.getState( "b" )' );
         equal( event.getState('b',true), 2, 'event.getState( "b", true )' );
       }
     },
-    
+
     [ { c:true, d:false, e:'undefined', f:'' } ],
-    
+
     function(result){
       equal( hash_actual, '#' + hash, 'hash should begin with #!' );
       deepEqual( obj.str, { a:'2', b:'2', c:'true', d:'false', e:'undefined', f:'' }, '$.bbq.getState()' );
@@ -1001,7 +1001,7 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
       equal( f.coerce, '', '$.bbq.getState( "f", true )' );
       if ( !old_jquery ) {
         deepEqual( event.getState(), { a:'2', b:'2', c:'true', d:'false', e:'undefined', f:'' }, 'event.getState()' );
-        deepEqual( event.getState(true), { a:2, b:2, c:true, d:false, e:undefined, f:'' },  'event.getState( true )' );
+        deepEqual( event.getState('a'), { a:2, b:2, c:true, d:false, e:undefined, f:'' },  'event.getState( true )' );
         equal( event.getState('c'), 'true', 'event.getState( "c" )' );
         equal( event.getState('c',true), true, 'event.getState( "c", true )' );
         equal( event.getState('d'), 'false', 'event.getState( "d" )' );
@@ -1012,15 +1012,15 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
         equal( event.getState('f',true), '', 'event.getState( "f", true )' );
       }
     },
-    
+
     function(result){
       $.param.fragment.ajaxCrawlable( true );
     },
-    
+
     function(result){
       $.bbq.removeState( 'c' );
     },
-    
+
     function(result){
       equal( hash_actual, '#!' + hash, 'hash should begin with #!' );
       deepEqual( obj.str, { a:'2', b:'2', d:'false', e:'undefined', f:'' }, '$.bbq.getState()' );
@@ -1039,7 +1039,7 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
       equal( f.coerce, '', '$.bbq.getState( "f", true )' );
       if ( !old_jquery ) {
         deepEqual( event.getState(), { a:'2', b:'2', d:'false', e:'undefined', f:'' }, 'event.getState()' );
-        deepEqual( event.getState(true), { a:2, b:2, d:false, e:undefined, f:'' },  'event.getState( true )' );
+        deepEqual( event.getState('a'), { a:2, b:2, d:false, e:undefined, f:'' },  'event.getState( true )' );
         equal( event.getState('a'), '2', 'event.getState( "a" )' );
         equal( event.getState('a',true), 2, 'event.getState( "a", true )' );
         equal( event.getState('b'), '2', 'event.getState( "b" )' );
@@ -1054,11 +1054,11 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
         equal( event.getState('f',true), '', 'event.getState( "f", true )' );
       }
     },
-    
+
     function(result){
       $.bbq.removeState( [ 'd', 'e', 'f', 'nonexistent' ] );
     },
-    
+
     function(result){
       equal( hash_actual, '#!' + hash, 'hash should begin with #!' );
       deepEqual( obj.str, { a:'2', b:'2' }, '$.bbq.getState()' );
@@ -1077,7 +1077,7 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
       equal( f.coerce, undefined, '$.bbq.getState( "f", true )' );
       if ( !old_jquery ) {
         deepEqual( event.getState(), { a:'2', b:'2' }, 'event.getState()' );
-        deepEqual( event.getState(true), { a:2, b:2 },  'event.getState( true )' );
+        deepEqual( event.getState('a'), { a:2, b:2 },  'event.getState( true )' );
         equal( event.getState('a'), '2', 'event.getState( "a" )' );
         equal( event.getState('a',true), 2, 'event.getState( "a", true )' );
         equal( event.getState('b'), '2', 'event.getState( "b" )' );
@@ -1092,11 +1092,11 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
         equal( event.getState('f',true), undefined, 'event.getState( "f", true )' );
       }
     },
-    
+
     function(result){
       $.bbq.removeState();
     },
-    
+
     function(result){
       equal( hash_actual, '#!', 'hash should just be #!' );
       deepEqual( obj.str, {}, '$.bbq.getState()' );
@@ -1115,7 +1115,7 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
       equal( f.coerce, undefined, '$.bbq.getState( "f", true )' );
       if ( !old_jquery ) {
         deepEqual( event.getState(), {}, 'event.getState()' );
-        deepEqual( event.getState(true), {},  'event.getState( true )' );
+        deepEqual( event.getState('a'), {},  'event.getState( true )' );
         equal( event.getState('a'), undefined, 'event.getState( "a" )' );
         equal( event.getState('a',true), undefined, 'event.getState( "a", true )' );
         equal( event.getState('b'), undefined, 'event.getState( "b" )' );
@@ -1130,11 +1130,11 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
         equal( event.getState('f',true), undefined, 'event.getState( "f", true )' );
       }
     },
-    
+
     [ { a:'2', b:'2', c:true, d:false, e:'undefined', f:'' } ],
-    
+
     [ { a:[4,5,6]}],//, b:{x:[7], y:8, z:[9,0,'true','false','undefined','']} }, 2 ],
-    
+
     function(result){
       var b_str = old_jquery
           ? '[object Object]'
@@ -1142,7 +1142,7 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
         b_coerce = old_jquery
           ? '[object Object]'
           : <any>{x:[7], y:8};//z:[9,0,true,false,undefined,'']};
-      
+
       equal( hash_actual, '#!' + hash, 'hash should begin with #!' );
       deepEqual( obj.str, { a:['4','5','6'], b:b_str }, '$.bbq.getState()' );
       deepEqual( obj.coerce, { a:[4,5,6], b:b_coerce },  '$.bbq.getState( true )' );
@@ -1150,14 +1150,14 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
       deepEqual( a.coerce, [4,5,6], '$.bbq.getState( "a", true )' );
       if ( !old_jquery ) {
         deepEqual( event.getState(), { a:['4','5','6'], b:b_str }, 'event.getState()' );
-        deepEqual( event.getState(true), { a:[4,5,6], b:b_coerce },  'event.getState( true )' );
+        deepEqual( event.getState('a'), { a:[4,5,6], b:b_coerce },  'event.getState( true )' );
         deepEqual( event.getState('a'), ['4','5','6'], 'event.getState( "a" )' );
         deepEqual( event.getState('a',true), [4,5,6], 'event.getState( "a", true )' );
       }
     },
-    
+
     [ <any>{ a:'1', c:'2' }, 1 ],
-    
+
     function(result){
       var b_str = old_jquery
           ? '[object Object]'
@@ -1165,18 +1165,18 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
         b_coerce = old_jquery
           ? '[object Object]'
           : <any>{x:[7], y:8};//, z:[9,0,true,false,undefined,'']};
-      
+
       equal( hash_actual, '#!' + hash, 'hash should begin with #!' );
       deepEqual( obj.str, { a:['4','5','6'], b:b_str, c:'2' }, '$.bbq.getState()' );
       deepEqual( obj.coerce, { a:[4,5,6], b:b_coerce, c:2 },  '$.bbq.getState( true )' );
       if ( !old_jquery ) {
         deepEqual( event.getState(), { a:['4','5','6'], b:b_str, c:'2' }, 'event.getState()' );
-        deepEqual( event.getState(true), { a:[4,5,6], b:b_coerce, c:2 },  'event.getState( true )' );
+        deepEqual( event.getState('a'), { a:[4,5,6], b:b_coerce, c:2 },  'event.getState( true )' );
       }
     },
-    
+
     [ <any>'#/path/to/file.php', 2 ],
-    
+
     function(result){
       equal( hash_actual, '#!' + hash, 'hash should begin with #!' );
       equal( hash, '/path/to/file.php', '$.param.fragment()' );
@@ -1184,9 +1184,9 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
         equal( event.fragment, '/path/to/file.php', 'event.fragment' );
       }
     },
-    
+
     [],
-    
+
     function(result){
       equal( hash_actual, '#!', 'hash should just be #!' );
       equal( hash, '', '$.param.fragment()' );
@@ -1194,67 +1194,67 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
         equal( event.fragment, '', 'event.fragment' );
       }
     },
-    
+
     function(result){
       $(window).bind( 'hashchange', function(evt){
         x = $.param.fragment();
       });
     },
-    
+
     [ <any>'#omg_ponies', 2 ],
-    
+
     function(result){
       equal( hash, 'omg_ponies', 'event handler 1: $.param.fragment()' );
       equal( x, 'omg_ponies', 'event handler 2: $.param.fragment()' );
-      
+
       hash = x = '';
       equal( hash + x, '', 'vars reset' );
-      
+
       $(window).triggerHandler( 'hashchange' );
       equal( hash, 'omg_ponies', 'event handler 1: $.param.fragment()' );
       equal( x, 'omg_ponies', 'event handler 2: $.param.fragment()' );
-      
+
       hash = x = '';
       equal( hash + x, '', 'vars reset' );
-      
+
       $(window).unbind( 'hashchange' );
     },
-    
+
     [ <any>'#almost_done?not_search', 2 ],
-    
+
     function(result){
       equal( hash, '', 'event handler 1: $.param.fragment()' );
       equal( x, '', 'event handler 2: $.param.fragment()' );
-      
+
       var events:any;// = $.data( window, 'events' );
       ok( !events || !events.hashchange, 'hashchange event unbound' );
     },
-    
+
     [ '#' ],
-    
+
     function(result){
       x = [];
       $(window).bind( 'hashchange', function(evt){
         x.push( $.param.fragment() );
       });
     },
-    
+
     function(result){
       !is_chrome && window.history.go( -1 );
     },
-    
+
     function(result){
       !is_chrome && window.history.go( -1 );
     },
-    
+
     function(result){
       !is_chrome && window.history.go( -1 );
     },
-    
+
     function(result){
       !is_chrome && window.history.go( -1 );
     },
-    
+
     function(result){
       if ( is_chrome ) {
         // Read about this issue here: http://benalman.com/news/2009/09/chrome-browser-history-buggine/
@@ -1262,20 +1262,20 @@ test( 'jQuery.bbq.pushState(), jQuery.bbq.getState(), jQuery.bbq.removeState(),
       } else {
         deepEqual( x, ['almost_done?not_search', 'omg_ponies', '', '/path/to/file.php'], 'back button and window.bbq.go(-1) should work' );
       }
-      
+
       $(window).unbind( 'hashchange' );
       var events: any;// = $.data( window, 'events' );
       ok( !events || !events.hashchange, 'hashchange event unbound' );
     },
-    
+
     function(result){
       $.param.fragment.ajaxCrawlable( false );
     },
-    
+
     [ '#all_done' ]
-    
+
   );
-  
+
 });
 
 
diff --git a/jqueryui/jqueryui-tests.ts b/jqueryui/jqueryui-tests.ts
index 0063a6115b..2cce742f86 100644
--- a/jqueryui/jqueryui-tests.ts
+++ b/jqueryui/jqueryui-tests.ts
@@ -816,11 +816,7 @@ function test_autocomplete() {
                 }, response);
             },
             search: () => {
-                // custom minLength
-                var term = null
-                if (term.length < 2) {
-                    return false;
-                }
+                return false;
             },
             focus: () => {
                 return false;
diff --git a/knockout/tests/knockout-templatingBehaviors-tests.ts b/knockout/tests/knockout-templatingBehaviors-tests.ts
index 29e09f5729..213ee06f15 100644
--- a/knockout/tests/knockout-templatingBehaviors-tests.ts
+++ b/knockout/tests/knockout-templatingBehaviors-tests.ts
@@ -120,7 +120,7 @@ describe('Templating', function() {
     });
 
     it('Should be able to access newly rendered/inserted elements in \'afterRender\' callaback', function () {
-        var passedElement, passedDataItem;
+        var passedElement:any, passedDataItem;
         var myCallback = function(elementsArray, dataItem) {
             expect(elementsArray.length).toEqual(1);
             passedElement = elementsArray[0];
diff --git a/knockout/tests/knockout-tests.ts b/knockout/tests/knockout-tests.ts
index 1f9f52ff47..ba96f6863f 100644
--- a/knockout/tests/knockout-tests.ts
+++ b/knockout/tests/knockout-tests.ts
@@ -242,7 +242,13 @@ function test_bindings() {
         }
     };
 
-    var node, containerElem, nodeToInsert, insertAfter, nodeToPrepend, arrayOfNodes;
+    var node: Node = <any>{};
+    var insertAfter: Node = <any>{};
+    var nodeToPrepend: Node = <any>{};
+    var arrayOfNodes: Node[] = <any>[];
+    var containerElem: KnockoutVirtualElement = <any>{};
+    var nodeToInsert: Node = <any>{}
+
     ko.virtualElements.emptyNode(containerElem);
     ko.virtualElements.firstChild(containerElem);
     ko.virtualElements.insertAfter(containerElem, nodeToInsert, insertAfter);
@@ -568,7 +574,7 @@ function test_misc() {
 
     var x = ko.observableArray([1, 2, 3]);
 
-    var element;
+    var element: Element = <any>{};
     ko.utils.domNodeDisposal.addDisposeCallback(element, function () {
         $(element).datepicker("destroy");
     });
diff --git a/kolite/kolite-tests.ts b/kolite/kolite-tests.ts
index 698e915578..539c284861 100644
--- a/kolite/kolite-tests.ts
+++ b/kolite/kolite-tests.ts
@@ -7,11 +7,11 @@ function test_activityDefaults() {
         container: 'i',
         inactiveClass: ''
     };
-    
+
     ko.bindingHandlers.activity.defaultOptions = {
         activityClass: 'some Value'
     };
-    
+
     ko.bindingHandlers.activity.defaultOptions = {
     };
 }
@@ -60,12 +60,12 @@ function test_asyncCommand_isExecuting() {
 }
 
 function test_dirtyFlag() {
-    var viewModel;
+    var viewModel: any;
     viewModel.dirtyFlag = new ko.DirtyFlag(viewModel.model);
     viewModel.dirtyFlag().isDirty();
     viewModel.dirtyFlag().reset();
 
-    var self;
+    var self: any;
     this.dirtyFlag = new ko.DirtyFlag(
        self.firstName,
        self.lastName);
diff --git a/physijs/tests/body.ts b/physijs/tests/body.ts
index 83924a9a4d..4cb57a40d9 100644
--- a/physijs/tests/body.ts
+++ b/physijs/tests/body.ts
@@ -13,20 +13,20 @@ initScene = function() {
     renderer = new THREE.WebGLRenderer({ antialias: true });
     renderer.setSize( window.innerWidth, window.innerHeight );
     renderer.shadowMapEnabled = true;
-    renderer.shadowMapSoft = true;
+   // // renderer.shadowMapSoft = true;
     document.getElementById( 'viewport' ).appendChild( renderer.domElement );
 
     render_stats = new Stats();
-    render_stats.domElement.style.position = 'absolute';
-    render_stats.domElement.style.top = '1px';
-    render_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( render_stats.domElement );
+    render_stats.dom.style.position = 'absolute';
+    render_stats.dom.style.top = '1px';
+    render_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( render_stats.dom );
 
     physics_stats = new Stats();
-    physics_stats.domElement.style.position = 'absolute';
-    physics_stats.domElement.style.top = '50px';
-    physics_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( physics_stats.domElement );
+    physics_stats.dom.style.position = 'absolute';
+    physics_stats.dom.style.top = '50px';
+    physics_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( physics_stats.dom );
 
     scene = new Physijs.Scene();
     scene.setGravity(new THREE.Vector3( 0, -30, 0 ));
@@ -62,7 +62,7 @@ initScene = function() {
     light.shadowCameraFar = 200;
     light.shadowBias = -.0001
     light.shadowMapWidth = light.shadowMapHeight = 2048;
-    light.shadowDarkness = .7;
+    //// light.shadowDarkness = .7;
     scene.add( light );
 
     // Materials
@@ -71,16 +71,16 @@ initScene = function() {
         .8, // high friction
         .4 // low restitution
     );
-    ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
-    ground_material.map.repeat.set( 3, 3 );
+    // ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
+    // ground_material.map.repeat.set( 3, 3 );
 
     box_material = Physijs.createMaterial(
         new THREE.MeshLambertMaterial({ map: THREE.ImageUtils.loadTexture( 'images/plywood.jpg' ) }),
         .4, // low friction
         .6 // high restitution
     );
-    box_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
-    box_material.map.repeat.set( .25, .25 );
+    // box_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
+    // box_material.map.repeat.set( .25, .25 );
 
     // Ground
     ground = new Physijs.BoxMesh(
@@ -131,8 +131,8 @@ render = function() {
 setMousePosition = function( evt ) {
     // Find where mouse cursor intersects the ground plane
     var vector = new THREE.Vector3(
-        ( evt.clientX / renderer.domElement.clientWidth ) * 2 - 1,
-        -( ( evt.clientY / renderer.domElement.clientHeight ) * 2 - 1 ),
+        ( evt.clientX / renderer.dom.clientWidth ) * 2 - 1,
+        -( ( evt.clientY / renderer.dom.clientHeight ) * 2 - 1 ),
         .5
     );
     projector.unprojectVector( vector, camera );
diff --git a/physijs/tests/collisions.ts b/physijs/tests/collisions.ts
index 82cb9f9589..6946cf8457 100644
--- a/physijs/tests/collisions.ts
+++ b/physijs/tests/collisions.ts
@@ -12,20 +12,20 @@ initScene = function() {
     renderer = new THREE.WebGLRenderer({ antialias: true });
     renderer.setSize( window.innerWidth, window.innerHeight );
     renderer.shadowMapEnabled = true;
-    renderer.shadowMapSoft = true;
+   // // renderer.shadowMapSoft = true;
     document.getElementById( 'viewport' ).appendChild( renderer.domElement );
 
     render_stats = new Stats();
-    render_stats.domElement.style.position = 'absolute';
-    render_stats.domElement.style.top = '0px';
-    render_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( render_stats.domElement );
+    render_stats.dom.style.position = 'absolute';
+    render_stats.dom.style.top = '0px';
+    render_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( render_stats.dom );
 
     physics_stats = new Stats();
-    physics_stats.domElement.style.position = 'absolute';
-    physics_stats.domElement.style.top = '50px';
-    physics_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( physics_stats.domElement );
+    physics_stats.dom.style.position = 'absolute';
+    physics_stats.dom.style.top = '50px';
+    physics_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( physics_stats.dom );
 
     scene = new Physijs.Scene;
     scene.setGravity(new THREE.Vector3( 0, -30, 0 ));
@@ -60,7 +60,7 @@ initScene = function() {
     light.shadowCameraFar = 200;
     light.shadowBias = -.0001
     light.shadowMapWidth = light.shadowMapHeight = 2048;
-    light.shadowDarkness = .7;
+    //// light.shadowDarkness = .7;
     scene.add( light );
 
     // Ground
@@ -69,8 +69,8 @@ initScene = function() {
         .8, // high friction
         .3 // low restitution
     );
-    ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
-    ground_material.map.repeat.set( 3, 3 );
+    //ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
+   // ground_material.map.repeat.set( 3, 3 );
 
     ground = new Physijs.BoxMesh(
         new THREE.BoxGeometry(100, 1, 100),
@@ -89,7 +89,7 @@ initScene = function() {
 spawnBox = (function() {
 
     var box_geometry = new THREE.BoxGeometry( 4, 4, 4 ),
-        handleCollision = function( collided_with, linearVelocity, angularVelocity ) {
+        handleCollision = function( collided_with ) {
             var target = <any>this;
             target.collisions = 0;
             switch (++target.collisions) {
@@ -127,8 +127,8 @@ spawnBox = (function() {
                 .6, // medium friction
                 .3 // low restitution
             );
-            material.map.wrapS = material.map.wrapT = THREE.RepeatWrapping;
-            material.map.repeat.set( .5, .5 );
+            // material.map.wrapS = material.map.wrapT = THREE.RepeatWrapping;
+            // material.map.repeat.set( .5, .5 );
 
             //material = new THREE.MeshLambertMaterial({ map: THREE.ImageUtils.loadTexture( 'images/rocks.jpg' ) });
 
@@ -137,7 +137,7 @@ spawnBox = (function() {
                 material
             );
 
-            box.collisions = 0;
+            // box.collisions = 0;
 
             box.position.set(
                 Math.random() * 15 - 7.5,
diff --git a/physijs/tests/compound.ts b/physijs/tests/compound.ts
index 36e4a48e1a..c5445d7776 100644
--- a/physijs/tests/compound.ts
+++ b/physijs/tests/compound.ts
@@ -12,20 +12,20 @@ initScene = function() {
     renderer = new THREE.WebGLRenderer({ antialias: true });
     renderer.setSize( window.innerWidth, window.innerHeight );
     renderer.shadowMapEnabled = true;
-    renderer.shadowMapSoft = true;
+    // renderer.shadowMapSoft = true;
     document.getElementById( 'viewport' ).appendChild( renderer.domElement );
 
     render_stats = new Stats();
-    render_stats.domElement.style.position = 'absolute';
-    render_stats.domElement.style.top = '0px';
-    render_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( render_stats.domElement );
+    render_stats.dom.style.position = 'absolute';
+    render_stats.dom.style.top = '0px';
+    render_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( render_stats.dom );
 
     physics_stats = new Stats();
-    physics_stats.domElement.style.position = 'absolute';
-    physics_stats.domElement.style.top = '50px';
-    physics_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( physics_stats.domElement );
+    physics_stats.dom.style.position = 'absolute';
+    physics_stats.dom.style.top = '50px';
+    physics_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( physics_stats.dom );
 
     scene = new Physijs.Scene;
     scene.setGravity(new THREE.Vector3( 0, -50, 0 ));
@@ -60,7 +60,7 @@ initScene = function() {
     light.shadowCameraFar = 200;
     light.shadowBias = -.0001
     light.shadowMapWidth = light.shadowMapHeight = 2048;
-    light.shadowDarkness = .7;
+    // light.shadowDarkness = .7;
     scene.add( light );
 
     // Materials
@@ -69,16 +69,16 @@ initScene = function() {
         .8, // high friction
         .4 // low restitution
     );
-    ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
-    ground_material.map.repeat.set( 3, 3 );
+    // ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
+    // ground_material.map.repeat.set( 3, 3 );
 
     chair_material = Physijs.createMaterial(
         new THREE.MeshLambertMaterial({ map: THREE.ImageUtils.loadTexture( 'images/wood.jpg' ) }),
         .6, // medium friction
         .2 // low restitution
     );
-    chair_material.map.wrapS = chair_material.map.wrapT = THREE.RepeatWrapping;
-    chair_material.map.repeat.set( .25, .25 );
+    // chair_material.map.wrapS = chair_material.map.wrapT = THREE.RepeatWrapping;
+    // chair_material.map.repeat.set( .25, .25 );
 
     // Ground
     ground = new Physijs.BoxMesh(
diff --git a/physijs/tests/constraints_car.ts b/physijs/tests/constraints_car.ts
index 4e343c06d1..2863253d63 100644
--- a/physijs/tests/constraints_car.ts
+++ b/physijs/tests/constraints_car.ts
@@ -14,20 +14,20 @@ initScene = function() {
     renderer = new THREE.WebGLRenderer({ antialias: true });
     renderer.setSize( window.innerWidth, window.innerHeight );
     renderer.shadowMapEnabled = true;
-    renderer.shadowMapSoft = true;
+  //  // renderer.shadowMapSoft = true;
     document.getElementById( 'viewport' ).appendChild( renderer.domElement );
 
     render_stats = new Stats();
-    render_stats.domElement.style.position = 'absolute';
-    render_stats.domElement.style.top = '0px';
-    render_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( render_stats.domElement );
+    render_stats.dom.style.position = 'absolute';
+    render_stats.dom.style.top = '0px';
+    render_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( render_stats.dom );
 
     physics_stats = new Stats();
-    physics_stats.domElement.style.position = 'absolute';
-    physics_stats.domElement.style.top = '50px';
-    physics_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( physics_stats.domElement );
+    physics_stats.dom.style.position = 'absolute';
+    physics_stats.dom.style.top = '50px';
+    physics_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( physics_stats.dom );
 
     scene = new Physijs.Scene;
     scene.setGravity(new THREE.Vector3( 0, -30, 0 ));
@@ -62,7 +62,7 @@ initScene = function() {
     light.shadowCameraFar = 200;
     light.shadowBias = -.0001
     light.shadowMapWidth = light.shadowMapHeight = 2048;
-    light.shadowDarkness = .7;
+    //// light.shadowDarkness = .7;
     scene.add( light );
 
     // Materials
@@ -71,8 +71,8 @@ initScene = function() {
         .8, // high friction
         .4 // low restitution
     );
-    ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
-    ground_material.map.repeat.set( 3, 3 );
+    // ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
+    // ground_material.map.repeat.set( 3, 3 );
 
     // Ground
     ground = new Physijs.BoxMesh(
diff --git a/physijs/tests/heightfield.ts b/physijs/tests/heightfield.ts
index 30caf48398..d184d705ea 100644
--- a/physijs/tests/heightfield.ts
+++ b/physijs/tests/heightfield.ts
@@ -17,20 +17,20 @@ initScene = function() {
     renderer = new THREE.WebGLRenderer({ antialias: true });
     renderer.setSize( window.innerWidth, window.innerHeight );
     renderer.shadowMapEnabled = true;
-    renderer.shadowMapSoft = true;
+    // // renderer.shadowMapSoft = true;
     document.getElementById( 'viewport' ).appendChild( renderer.domElement );
 
     render_stats = new Stats();
-    render_stats.domElement.style.position = 'absolute';
-    render_stats.domElement.style.top = '0px';
-    render_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( render_stats.domElement );
+    render_stats.dom.style.position = 'absolute';
+    render_stats.dom.style.top = '0px';
+    render_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( render_stats.dom );
 
     physics_stats = new Stats();
-    physics_stats.domElement.style.position = 'absolute';
-    physics_stats.domElement.style.top = '50px';
-    physics_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( physics_stats.domElement );
+    physics_stats.dom.style.position = 'absolute';
+    physics_stats.dom.style.top = '50px';
+    physics_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( physics_stats.dom );
 
     scene = new Physijs.Scene({ fixedTimeStep: 1 / 120 });
     scene.setGravity(new THREE.Vector3( 0, -30, 0 ));
@@ -65,7 +65,7 @@ initScene = function() {
     light.shadowCameraFar = 200;
     light.shadowBias = -.0001
     light.shadowMapWidth = light.shadowMapHeight = 2048;
-    light.shadowDarkness = .7;
+    // // light.shadowDarkness = .7;
     scene.add( light );
 
     // Materials
@@ -74,8 +74,8 @@ initScene = function() {
         .8, // high friction
         .4 // low restitution
     );
-    ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
-    ground_material.map.repeat.set( 2.5, 2.5 );
+    // ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
+    // ground_material.map.repeat.set( 2.5, 2.5 );
 
     // Ground
     NoiseGen = new SimplexNoise;
@@ -155,7 +155,7 @@ createShape = (function() {
                 break;
         }
 
-        shape.material.color.setRGB( Math.random() * 100 / 100, Math.random() * 100 / 100, Math.random() * 100 / 100 );
+        // shape.material.color.setRGB( Math.random() * 100 / 100, Math.random() * 100 / 100, Math.random() * 100 / 100 );
         shape.castShadow = true;
         shape.receiveShadow = true;
 
diff --git a/physijs/tests/jenga.ts b/physijs/tests/jenga.ts
index 43a4d924de..d4a333f426 100644
--- a/physijs/tests/jenga.ts
+++ b/physijs/tests/jenga.ts
@@ -12,20 +12,20 @@ initScene = function() {
     renderer = new THREE.WebGLRenderer({ antialias: true });
     renderer.setSize( window.innerWidth, window.innerHeight );
     renderer.shadowMapEnabled = true;
-    renderer.shadowMapSoft = true;
+    // // renderer.shadowMapSoft = true;
     document.getElementById( 'viewport' ).appendChild( renderer.domElement );
 
     render_stats = new Stats();
-    render_stats.domElement.style.position = 'absolute';
-    render_stats.domElement.style.top = '1px';
-    render_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( render_stats.domElement );
+    render_stats.dom.style.position = 'absolute';
+    render_stats.dom.style.top = '1px';
+    render_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( render_stats.dom );
 
     physics_stats = new Stats();
-    physics_stats.domElement.style.position = 'absolute';
-    physics_stats.domElement.style.top = '50px';
-    physics_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( physics_stats.domElement );
+    physics_stats.dom.style.position = 'absolute';
+    physics_stats.dom.style.top = '50px';
+    physics_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( physics_stats.dom );
 
     scene = new Physijs.Scene({ fixedTimeStep: 1 / 120 });
     scene.setGravity(new THREE.Vector3( 0, -30, 0 ));
@@ -78,7 +78,7 @@ initScene = function() {
     dir_light.shadowCameraFar = 200;
     dir_light.shadowBias = -.001
     dir_light.shadowMapWidth = dir_light.shadowMapHeight = 2048;
-    dir_light.shadowDarkness = .5;
+    // dir_light.shadowDarkness = .5;
     scene.add( dir_light );
 
     // Materials
@@ -87,16 +87,16 @@ initScene = function() {
         .9, // high friction
         .2 // low restitution
     );
-    table_material.map.wrapS = table_material.map.wrapT = THREE.RepeatWrapping;
-    table_material.map.repeat.set( 5, 5 );
+    // table_material.map.wrapS = table_material.map.wrapT = THREE.RepeatWrapping;
+    // table_material.map.repeat.set( 5, 5 );
 
     block_material = Physijs.createMaterial(
         new THREE.MeshLambertMaterial({ map: THREE.ImageUtils.loadTexture( 'images/plywood.jpg' ) }),
         .4, // medium friction
         .4 // medium restitution
     );
-    block_material.map.wrapS = block_material.map.wrapT = THREE.RepeatWrapping;
-    block_material.map.repeat.set( 1, .5 );
+    // block_material.map.wrapS = block_material.map.wrapT = THREE.RepeatWrapping;
+    // block_material.map.repeat.set( 1, .5 );
 
     // Table
     table = new Physijs.BoxMesh(
@@ -179,10 +179,10 @@ initEventHandling = (function() {
             selected_block = intersections[0].object;
 
             _vector.set( 0, 0, 0 );
-            selected_block.setAngularFactor( _vector );
-            selected_block.setAngularVelocity( _vector );
-            selected_block.setLinearFactor( _vector );
-            selected_block.setLinearVelocity( _vector );
+            // selected_block.setAngularFactor( _vector );
+            // selected_block.setAngularVelocity( _vector );
+            // selected_block.setLinearFactor( _vector );
+            // selected_block.setLinearVelocity( _vector );
 
             mouse_pos.copy( intersections[0].point );
             block_offset.subVectors( selected_block.position, mouse_pos );
@@ -225,9 +225,9 @@ initEventHandling = (function() {
     };
 
     return function() {
-        renderer.domElement.addEventListener( 'mousedown', handleMouseDown );
-        renderer.domElement.addEventListener( 'mousemove', handleMouseMove );
-        renderer.domElement.addEventListener( 'mouseup', handleMouseUp );
+        renderer.dom.addEventListener( 'mousedown', handleMouseDown );
+        renderer.dom.addEventListener( 'mousemove', handleMouseMove );
+        renderer.dom.addEventListener( 'mouseup', handleMouseUp );
     };
 })();
 
diff --git a/physijs/tests/memorytest-compound.ts b/physijs/tests/memorytest-compound.ts
index b755092ac2..a30a56658e 100644
--- a/physijs/tests/memorytest-compound.ts
+++ b/physijs/tests/memorytest-compound.ts
@@ -17,20 +17,20 @@ initScene = function() {
     renderer = new THREE.WebGLRenderer({ antialias: true });
     renderer.setSize( window.innerWidth, window.innerHeight );
     renderer.shadowMapEnabled = true;
-    renderer.shadowMapSoft = true;
+    // // renderer.shadowMapSoft = true;
     document.getElementById( 'viewport' ).appendChild( renderer.domElement );
 
     render_stats = new Stats();
-    render_stats.domElement.style.position = 'absolute';
-    render_stats.domElement.style.top = '0px';
-    render_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( render_stats.domElement );
+    render_stats.dom.style.position = 'absolute';
+    render_stats.dom.style.top = '0px';
+    render_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( render_stats.dom );
 
     physics_stats = new Stats();
-    physics_stats.domElement.style.position = 'absolute';
-    physics_stats.domElement.style.top = '50px';
-    physics_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( physics_stats.domElement );
+    physics_stats.dom.style.position = 'absolute';
+    physics_stats.dom.style.top = '50px';
+    physics_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( physics_stats.dom );
 
     scene = new Physijs.Scene;
     scene.setGravity(new THREE.Vector3( 0, -30, 0 ));
@@ -81,7 +81,7 @@ initScene = function() {
     light.shadowCameraFar = 200;
     light.shadowBias = -.0001
     light.shadowMapWidth = light.shadowMapHeight = 2048;
-    light.shadowDarkness = .7;
+    // // light.shadowDarkness = .7;
     scene.add( light );
 
     // Ground
@@ -90,8 +90,8 @@ initScene = function() {
         .8, // high friction
         .3 // low restitution
     );
-    ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
-    ground_material.map.repeat.set( 3, 3 );
+    // ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
+    // ground_material.map.repeat.set( 3, 3 );
 
     ground = new Physijs.BoxMesh(
         new THREE.BoxGeometry(100, 1, 100),
@@ -119,7 +119,7 @@ spawnBox = (function() {
                 .3 // low restitution
             );
 
-            material.color.setRGB(Math.random() * 100 / 100, Math.random() * 100 / 100, Math.random() * 100 / 100);
+            // material.color.setRGB(Math.random() * 100 / 100, Math.random() * 100 / 100, Math.random() * 100 / 100);
 
             box = new Physijs.BoxMesh(
                 box_geometry,
@@ -130,8 +130,8 @@ spawnBox = (function() {
                 material
             );
 
-            childBox.collisions = 0;
-            box.collisions = 0;
+            // childBox.collisions = 0;
+            // box.collisions = 0;
             box.add(childBox);
 
             box.position.set(
diff --git a/physijs/tests/memorytest-convex.ts b/physijs/tests/memorytest-convex.ts
index 4a73bd6130..a46183498a 100644
--- a/physijs/tests/memorytest-convex.ts
+++ b/physijs/tests/memorytest-convex.ts
@@ -17,20 +17,20 @@ initScene = function() {
     renderer = new THREE.WebGLRenderer({ antialias: true });
     renderer.setSize( window.innerWidth, window.innerHeight );
     renderer.shadowMapEnabled = true;
-    renderer.shadowMapSoft = true;
+    // renderer.shadowMapSoft = true;
     document.getElementById( 'viewport' ).appendChild( renderer.domElement );
 
     render_stats = new Stats();
-    render_stats.domElement.style.position = 'absolute';
-    render_stats.domElement.style.top = '0px';
-    render_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( render_stats.domElement );
+    render_stats.dom.style.position = 'absolute';
+    render_stats.dom.style.top = '0px';
+    render_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( render_stats.dom );
 
     physics_stats = new Stats();
-    physics_stats.domElement.style.position = 'absolute';
-    physics_stats.domElement.style.top = '50px';
-    physics_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( physics_stats.domElement );
+    physics_stats.dom.style.position = 'absolute';
+    physics_stats.dom.style.top = '50px';
+    physics_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( physics_stats.dom );
 
     scene = new Physijs.Scene;
     scene.setGravity(new THREE.Vector3( 0, -30, 0 ));
@@ -81,7 +81,7 @@ initScene = function() {
     light.shadowCameraFar = 200;
     light.shadowBias = -.0001
     light.shadowMapWidth = light.shadowMapHeight = 2048;
-    light.shadowDarkness = .7;
+    // light.shadowDarkness = .7;
     scene.add( light );
 
     // Ground
@@ -90,8 +90,8 @@ initScene = function() {
         .8, // high friction
         .3 // low restitution
     );
-    ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
-    ground_material.map.repeat.set( 3, 3 );
+    // ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
+    // ground_material.map.repeat.set( 3, 3 );
 
     ground = new Physijs.BoxMesh(
         new THREE.BoxGeometry(100, 1, 100),
@@ -119,13 +119,13 @@ spawnBox = (function() {
                 .3 // low restitution
             );
 
-            material.color.setRGB(Math.random() * 100 / 100, Math.random() * 100 / 100, Math.random() * 100 / 100);
+            // material.color.setRGB(Math.random() * 100 / 100, Math.random() * 100 / 100, Math.random() * 100 / 100);
 
             box = new Physijs.ConvexMesh(
                 box_geometry,
                 material
             );
-            box.collisions = 0;
+            // box.collisions = 0;
 
             box.position.set(
                 Math.random() * 15 - 7.5,
diff --git a/physijs/tests/memorytest.ts b/physijs/tests/memorytest.ts
index 4b5d6ac325..d7c2a3ddc3 100644
--- a/physijs/tests/memorytest.ts
+++ b/physijs/tests/memorytest.ts
@@ -17,20 +17,20 @@ initScene = function() {
     renderer = new THREE.WebGLRenderer({ antialias: true });
     renderer.setSize( window.innerWidth, window.innerHeight );
     renderer.shadowMapEnabled = true;
-    renderer.shadowMapSoft = true;
+    // renderer.shadowMapSoft = true;
     document.getElementById( 'viewport' ).appendChild( renderer.domElement );
 
     render_stats = new Stats();
-    render_stats.domElement.style.position = 'absolute';
-    render_stats.domElement.style.top = '0px';
-    render_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( render_stats.domElement );
+    render_stats.dom.style.position = 'absolute';
+    render_stats.dom.style.top = '0px';
+    render_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( render_stats.dom );
 
     physics_stats = new Stats();
-    physics_stats.domElement.style.position = 'absolute';
-    physics_stats.domElement.style.top = '50px';
-    physics_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( physics_stats.domElement );
+    physics_stats.dom.style.position = 'absolute';
+    physics_stats.dom.style.top = '50px';
+    physics_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( physics_stats.dom );
 
     scene = new Physijs.Scene;
     scene.setGravity(new THREE.Vector3( 0, -30, 0 ));
@@ -81,7 +81,7 @@ initScene = function() {
     light.shadowCameraFar = 200;
     light.shadowBias = -.0001
     light.shadowMapWidth = light.shadowMapHeight = 2048;
-    light.shadowDarkness = .7;
+    // light.shadowDarkness = .7;
     scene.add( light );
 
     // Ground
@@ -90,8 +90,8 @@ initScene = function() {
         .8, // high friction
         .3 // low restitution
     );
-    ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
-    ground_material.map.repeat.set( 3, 3 );
+    // ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
+    // ground_material.map.repeat.set( 3, 3 );
 
     ground = new Physijs.BoxMesh(
         new THREE.BoxGeometry(100, 1, 100),
@@ -119,13 +119,13 @@ spawnBox = (function() {
                 .3 // low restitution
             );
 
-            material.color.setRGB(Math.random() * 100 / 100, Math.random() * 100 / 100, Math.random() * 100 / 100);
+            // material.color.setRGB(Math.random() * 100 / 100, Math.random() * 100 / 100, Math.random() * 100 / 100);
 
             box = new Physijs.BoxMesh(
                 box_geometry,
                 material
             );
-            box.collisions = 0;
+            // box.collisions = 0;
 
             box.position.set(
                 Math.random() * 15 - 7.5,
diff --git a/physijs/tests/shapes.ts b/physijs/tests/shapes.ts
index b5cecd0262..72f3cda0c2 100644
--- a/physijs/tests/shapes.ts
+++ b/physijs/tests/shapes.ts
@@ -18,20 +18,20 @@ initScene = function() {
     renderer = new THREE.WebGLRenderer({ antialias: true });
     renderer.setSize( window.innerWidth, window.innerHeight );
     renderer.shadowMapEnabled = true;
-    renderer.shadowMapSoft = true;
+    // renderer.shadowMapSoft = true;
     document.getElementById( 'viewport' ).appendChild( renderer.domElement );
 
     render_stats = new Stats();
-    render_stats.domElement.style.position = 'absolute';
-    render_stats.domElement.style.top = '0px';
-    render_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( render_stats.domElement );
+    render_stats.dom.style.position = 'absolute';
+    render_stats.dom.style.top = '0px';
+    render_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( render_stats.dom );
 
     physics_stats = new Stats();
-    physics_stats.domElement.style.position = 'absolute';
-    physics_stats.domElement.style.top = '50px';
-    physics_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( physics_stats.domElement );
+    physics_stats.dom.style.position = 'absolute';
+    physics_stats.dom.style.top = '50px';
+    physics_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( physics_stats.dom );
 
     scene = new Physijs.Scene({ fixedTimeStep: 1 / 120 });
     scene.setGravity(new THREE.Vector3( 0, -30, 0 ));
@@ -66,7 +66,7 @@ initScene = function() {
     light.shadowCameraFar = 200;
     light.shadowBias = -.0001
     light.shadowMapWidth = light.shadowMapHeight = 2048;
-    light.shadowDarkness = .7;
+    // light.shadowDarkness = .7;
     scene.add( light );
 
     // Materials
@@ -75,8 +75,8 @@ initScene = function() {
         .8, // high friction
         .4 // low restitution
     );
-    ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
-    ground_material.map.repeat.set( 2.5, 2.5 );
+    // ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
+    // ground_material.map.repeat.set( 2.5, 2.5 );
 
     // Ground
     ground = new Physijs.BoxMesh(
@@ -204,7 +204,7 @@ createShape = (function() {
                 break;
         }
 
-        shape.material.color.setRGB( Math.random() * 100 / 100, Math.random() * 100 / 100, Math.random() * 100 / 100 );
+        // shape.material.color.setRGB( Math.random() * 100 / 100, Math.random() * 100 / 100, Math.random() * 100 / 100 );
         shape.castShadow = true;
         shape.receiveShadow = true;
 
diff --git a/physijs/tests/vehicle.ts b/physijs/tests/vehicle.ts
index b133299a5b..beecaa1c8b 100644
--- a/physijs/tests/vehicle.ts
+++ b/physijs/tests/vehicle.ts
@@ -18,20 +18,20 @@ initScene = function() {
     renderer = new THREE.WebGLRenderer({ antialias: true });
     renderer.setSize( window.innerWidth, window.innerHeight );
     renderer.shadowMapEnabled = true;
-    renderer.shadowMapSoft = true;
+    // renderer.shadowMapSoft = true;
     document.getElementById( 'viewport' ).appendChild( renderer.domElement );
 
     render_stats = new Stats();
-    render_stats.domElement.style.position = 'absolute';
-    render_stats.domElement.style.top = '1px';
-    render_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( render_stats.domElement );
+    render_stats.dom.style.position = 'absolute';
+    render_stats.dom.style.top = '1px';
+    render_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( render_stats.dom );
 
     physics_stats = new Stats();
-    physics_stats.domElement.style.position = 'absolute';
-    physics_stats.domElement.style.top = '50px';
-    physics_stats.domElement.style.zIndex = 100;
-    document.getElementById( 'viewport' ).appendChild( physics_stats.domElement );
+    physics_stats.dom.style.position = 'absolute';
+    physics_stats.dom.style.top = '50px';
+    physics_stats.dom.style.zIndex = '100';
+    document.getElementById( 'viewport' ).appendChild( physics_stats.dom );
 
     scene = new Physijs.Scene;
     scene.setGravity(new THREE.Vector3( 0, -30, 0 ));
@@ -84,7 +84,7 @@ initScene = function() {
     light.shadowCameraFar = 400;
     light.shadowBias = -.0001
     light.shadowMapWidth = light.shadowMapHeight = 2048;
-    light.shadowDarkness = .7;
+    // light.shadowDarkness = .7;
     scene.add( light );
 
 
@@ -97,16 +97,16 @@ initScene = function() {
         .8, // high friction
         .4 // low restitution
     );
-    ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
-    ground_material.map.repeat.set( 3, 3 );
+    // ground_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
+    // ground_material.map.repeat.set( 3, 3 );
 
     box_material = Physijs.createMaterial(
         new THREE.MeshLambertMaterial({ map: THREE.ImageUtils.loadTexture( 'images/plywood.jpg' ) }),
         .4, // low friction
         .6 // high restitution
     );
-    box_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
-    box_material.map.repeat.set( .25, .25 );
+    // box_material.map.wrapS = ground_material.map.wrapT = THREE.RepeatWrapping;
+    // box_material.map.repeat.set( .25, .25 );
 
     // Ground
     var NoiseGen = new SimplexNoise;
diff --git a/three/tests/canvas/canvas_camera_orthographic.ts b/three/tests/canvas/canvas_camera_orthographic.ts
index 785512835f..c3b793fb14 100644
--- a/three/tests/canvas/canvas_camera_orthographic.ts
+++ b/three/tests/canvas/canvas_camera_orthographic.ts
@@ -96,9 +96,9 @@
         container.appendChild(renderer.domElement);
 
         stats = new Stats();
-        stats.domElement.style.position = 'absolute';
-        stats.domElement.style.top = '0px';
-        container.appendChild(stats.domElement);
+        stats.dom.style.position = 'absolute';
+        stats.dom.style.top = '0px';
+        container.appendChild(stats.dom);
 
         //
 
diff --git a/three/tests/canvas/canvas_geometry_cube.ts b/three/tests/canvas/canvas_geometry_cube.ts
index b1af3f97a2..3c704c8f6f 100644
--- a/three/tests/canvas/canvas_geometry_cube.ts
+++ b/three/tests/canvas/canvas_geometry_cube.ts
@@ -76,9 +76,9 @@
         container.appendChild(renderer.domElement);
 
         stats = new Stats();
-        stats.domElement.style.position = 'absolute';
-        stats.domElement.style.top = '0px';
-        container.appendChild(stats.domElement);
+        stats.dom.style.position = 'absolute';
+        stats.dom.style.top = '0px';
+        container.appendChild(stats.dom);
 
         document.addEventListener('mousedown', onDocumentMouseDown, false);
         document.addEventListener('touchstart', onDocumentTouchStart, false);
diff --git a/three/tests/canvas/canvas_interactive_cubes_tween.ts b/three/tests/canvas/canvas_interactive_cubes_tween.ts
index 4f85c068fb..0e86e5a2c5 100644
--- a/three/tests/canvas/canvas_interactive_cubes_tween.ts
+++ b/three/tests/canvas/canvas_interactive_cubes_tween.ts
@@ -63,9 +63,9 @@
         container.appendChild(renderer.domElement);
 
         stats = new Stats();
-        stats.domElement.style.position = 'absolute';
-        stats.domElement.style.top = '0px';
-        container.appendChild(stats.domElement);
+        stats.dom.style.position = 'absolute';
+        stats.dom.style.top = '0px';
+        container.appendChild(stats.dom);
 
         document.addEventListener('mousedown', onDocumentMouseDown, false);
         document.addEventListener('touchstart', onDocumentTouchStart, false);
diff --git a/three/tests/canvas/canvas_materials.ts b/three/tests/canvas/canvas_materials.ts
index 9fd59a6b4c..4518b46ea0 100644
--- a/three/tests/canvas/canvas_materials.ts
+++ b/three/tests/canvas/canvas_materials.ts
@@ -135,9 +135,9 @@
         debugContext.strokeStyle = '#000000';
 
         stats = new Stats();
-        stats.domElement.style.position = 'absolute';
-        stats.domElement.style.top = '0px';
-        container.appendChild(stats.domElement);
+        stats.dom.style.position = 'absolute';
+        stats.dom.style.top = '0px';
+        container.appendChild(stats.dom);
 
         //
 
diff --git a/three/tests/canvas/canvas_particles_floor.ts b/three/tests/canvas/canvas_particles_floor.ts
index cf38f9a02d..b0725f6dbe 100644
--- a/three/tests/canvas/canvas_particles_floor.ts
+++ b/three/tests/canvas/canvas_particles_floor.ts
@@ -52,9 +52,9 @@
         container.appendChild(renderer.domElement);
 
         stats = new Stats();
-        stats.domElement.style.position = 'absolute';
-        stats.domElement.style.top = '0px';
-        container.appendChild(stats.domElement);
+        stats.dom.style.position = 'absolute';
+        stats.dom.style.top = '0px';
+        container.appendChild(stats.dom);
 
         document.addEventListener('mousemove', onDocumentMouseMove, false);
         document.addEventListener('touchstart', onDocumentTouchStart, false);
diff --git a/three/tests/webgl/webgl_animation_cloth.ts b/three/tests/webgl/webgl_animation_cloth.ts
index 1d7bf3ad39..a1cc4917cc 100644
--- a/three/tests/webgl/webgl_animation_cloth.ts
+++ b/three/tests/webgl/webgl_animation_cloth.ts
@@ -43,13 +43,16 @@
 
     if (!Detector.webgl) Detector.addGetWebGLMessage();
 
-    var container, stats;
-    var camera, scene, renderer;
-
-    var clothGeometry;
-    var sphere;
-    var object, arrow;
-
+    var container: HTMLElement;
+    var stats: Stats;
+    var camera: THREE.PerspectiveCamera;
+    var scene: THREE.Scene;
+    var renderer: THREE.WebGLRenderer;
+    var clothGeometry: THREE.ParametricGeometry;
+    var sphere: THREE.Mesh;
+    var object: THREE.Mesh;
+    var arrow: THREE.ArrowHelper;
+    var light:  THREE.DirectionalLight, materials;
     var rotate = true;
 
     init();
@@ -75,8 +78,6 @@
 
         // lights
 
-        var light, materials;
-
         scene.add(new THREE.AmbientLight(0x666666));
 
         light = new THREE.DirectionalLight(0xdfebff, 1.75);
@@ -97,7 +98,7 @@
         light.shadowCameraBottom = -d;
 
         light.shadowCameraFar = 1000;
-        light.shadowDarkness = 0.5;
+        //light.shadowDarkness = 0.5;
 
         scene.add(light);
 
@@ -111,7 +112,7 @@
 
         // cloth geometry
         clothGeometry = new THREE.ParametricGeometry(clothFunction, cloth.w, cloth.h);
-        clothGeometry.dynamic = true;
+        //clothGeometry.dynamic = true;
         clothGeometry.computeFaceNormals();
 
         var uniforms = { texture: { value: clothTexture } };
@@ -126,7 +127,7 @@
         object.receiveShadow = true;
         scene.add(object);
 
-        object.customDepthMaterial = new THREE.ShaderMaterial({ uniforms: uniforms, vertexShader: vertexShader, fragmentShader: fragmentShader });
+        //object.customDepthMaterial = new THREE.ShaderMaterial({ uniforms: uniforms, vertexShader: vertexShader, fragmentShader: fragmentShader });
 
         // sphere
 
@@ -217,7 +218,7 @@
         //
 
         stats = new Stats();
-        container.appendChild(stats.domElement);
+        container.appendChild(stats.dom);
 
         //
 
diff --git a/three/tests/webgl/webgl_animation_skinning_morph.ts b/three/tests/webgl/webgl_animation_skinning_morph.ts
index b8f2f767be..4beb0dde39 100644
--- a/three/tests/webgl/webgl_animation_skinning_morph.ts
+++ b/three/tests/webgl/webgl_animation_skinning_morph.ts
@@ -11,14 +11,14 @@
     var SCREEN_HEIGHT = window.innerHeight;
     var FLOOR = -250;
 
-    var container,stats;
-
-    var camera, scene;
-    var renderer;
-
-    var mesh, helper;
-
-    var mixer;
+    var container: HTMLElement;
+    var stats: Stats;
+    var camera: THREE.PerspectiveCamera;
+    var scene: THREE.Scene;
+    var renderer: THREE.WebGLRenderer;
+    var mesh: THREE.Mesh;
+    var helper: THREE.SkeletonHelper;
+    var mixer: THREE.AnimationMixer;
 
     var mouseX = 0, mouseY = 0;
 
@@ -100,7 +100,7 @@
         // STATS
 
         stats = new Stats();
-        container.appendChild( stats.domElement );
+        container.appendChild( stats.dom );
 
         //
 
@@ -177,12 +177,12 @@
         mesh.receiveShadow = true;
 
         helper = new THREE.SkeletonHelper( mesh );
-        helper.material.linewidth = 3;
+        //helper.material.linewidth = 3;
         helper.visible = false;
         scene.add( helper );
 
 
-        var clipMorpher = THREE.AnimationClip.CreateFromMorphTargetSequence( 'facialExpressions', mesh.geometry.morphTargets, 3, true );
+        var clipMorpher = THREE.AnimationClip.CreateFromMorphTargetSequence( 'facialExpressions', (mesh.geometry as THREE.Geometry).morphTargets, 3, true );
         var clipBones = geometry.animations[0];
 
         mixer = new THREE.AnimationMixer( mesh );
diff --git a/three/tests/webgl/webgl_buffergeometry.ts b/three/tests/webgl/webgl_buffergeometry.ts
index 57106f0aed..8be65dc8a0 100644
--- a/three/tests/webgl/webgl_buffergeometry.ts
+++ b/three/tests/webgl/webgl_buffergeometry.ts
@@ -10,11 +10,12 @@
 
     if ( ! Detector.webgl ) Detector.addGetWebGLMessage();
 
-    var container, stats;
-
-    var camera, scene, renderer;
-
-    var mesh;
+var container: HTMLElement;
+    var stats: Stats;
+    var camera: THREE.PerspectiveCamera;
+    var scene: THREE.Scene;
+    var renderer: THREE.WebGLRenderer;
+    var mesh: THREE.Mesh;
 
     init();
     animate();
@@ -176,9 +177,9 @@
         //
 
         stats = new Stats();
-        stats.domElement.style.position = 'absolute';
-        stats.domElement.style.top = '0px';
-        container.appendChild( stats.domElement );
+        stats.dom.style.position = 'absolute';
+        stats.dom.style.top = '0px';
+        container.appendChild( stats.dom );
 
         //
 
diff --git a/three/tests/webgl/webgl_camera.ts b/three/tests/webgl/webgl_camera.ts
index 7f05840923..6f60b5f3d7 100644
--- a/three/tests/webgl/webgl_camera.ts
+++ b/three/tests/webgl/webgl_camera.ts
@@ -7,8 +7,13 @@
     var SCREEN_WIDTH = window.innerWidth;
     var SCREEN_HEIGHT = window.innerHeight;
 
-    var container, stats;
-    var camera, scene, renderer, mesh;
+    var container: HTMLElement;
+    var stats: Stats;
+    var camera: THREE.PerspectiveCamera;
+    var scene: THREE.Scene;
+    var renderer: THREE.WebGLRenderer;
+    var mesh: THREE.Mesh;
+
     var cameraRig, activeCamera, activeHelper;
     var cameraPerspective, cameraOrtho;
     var cameraPerspectiveHelper, cameraOrthoHelper;
@@ -112,7 +117,7 @@
         //
 
         stats = new Stats();
-        container.appendChild( stats.domElement );
+        container.appendChild( stats.dom );
 
         //
 
diff --git a/three/tests/webgl/webgl_custom_attributes.ts b/three/tests/webgl/webgl_custom_attributes.ts
index 077b99424d..fc920abd8f 100644
--- a/three/tests/webgl/webgl_custom_attributes.ts
+++ b/three/tests/webgl/webgl_custom_attributes.ts
@@ -68,9 +68,9 @@
         container.appendChild(renderer.domElement);
 
         stats = new Stats();
-        stats.domElement.style.position = 'absolute';
-        stats.domElement.style.top = '0px';
-        container.appendChild(stats.domElement);
+        stats.dom.style.position = 'absolute';
+        stats.dom.style.top = '0px';
+        container.appendChild(stats.dom);
 
         //
 
@@ -104,16 +104,16 @@
 
         uniforms.amplitude.value = 2.5 * Math.sin(sphere.rotation.y * 0.125);
         uniforms.color.value.offsetHSL(0.0005, 0, 0);
-        
+
         for ( var i = 0; i < displacement.length; i ++ ) {
-        
+
             displacement[ i ] = Math.sin( 0.1 * i + time );
-            
+
             noise[ i ] += 0.5 * ( 0.5 - Math.random() );
             noise[ i ] = THREE.Math.clamp( noise[ i ], -5, 5 );
-            
+
             displacement[ i ] += noise[ i ];
-        
+
         }
 
         sphere.geometry.attributes.displacement.needsUpdate = true;
diff --git a/three/tests/webgl/webgl_geometries.ts b/three/tests/webgl/webgl_geometries.ts
index aed2b2e2b6..d1d9764536 100644
--- a/three/tests/webgl/webgl_geometries.ts
+++ b/three/tests/webgl/webgl_geometries.ts
@@ -116,9 +116,9 @@
         container.appendChild(renderer.domElement);
 
         stats = new Stats();
-        stats.domElement.style.position = 'absolute';
-        stats.domElement.style.top = '0px';
-        container.appendChild(stats.domElement);
+        stats.dom.style.position = 'absolute';
+        stats.dom.style.top = '0px';
+        container.appendChild(stats.dom);
 
         //
 
diff --git a/three/tests/webgl/webgl_interactive_cubes.ts b/three/tests/webgl/webgl_interactive_cubes.ts
index 2c574e2bad..f9a2d2d224 100644
--- a/three/tests/webgl/webgl_interactive_cubes.ts
+++ b/three/tests/webgl/webgl_interactive_cubes.ts
@@ -66,9 +66,9 @@
         container.appendChild(renderer.domElement);
 
         stats = new Stats();
-        stats.domElement.style.position = 'absolute';
-        stats.domElement.style.top = '0px';
-        container.appendChild(stats.domElement);
+        stats.dom.style.position = 'absolute';
+        stats.dom.style.top = '0px';
+        container.appendChild(stats.dom);
 
         document.addEventListener('mousemove', onDocumentMouseMove, false);
 
@@ -147,4 +147,4 @@
         renderer.render(scene, camera);
 
     }
-} 
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/three/tests/webgl/webgl_interactive_raycasting_points.ts b/three/tests/webgl/webgl_interactive_raycasting_points.ts
index 86edace793..798a5a193c 100644
--- a/three/tests/webgl/webgl_interactive_raycasting_points.ts
+++ b/three/tests/webgl/webgl_interactive_raycasting_points.ts
@@ -249,9 +249,9 @@
         //
 
         stats = new Stats();
-        stats.domElement.style.position = 'absolute';
-        stats.domElement.style.top = '0px';
-        container.appendChild(stats.domElement);
+        stats.dom.style.position = 'absolute';
+        stats.dom.style.top = '0px';
+        container.appendChild(stats.dom);
 
         //
 
diff --git a/three/tests/webgl/webgl_lensflares.ts b/three/tests/webgl/webgl_lensflares.ts
index 5e2e3a1a20..2f9f748ad5 100644
--- a/three/tests/webgl/webgl_lensflares.ts
+++ b/three/tests/webgl/webgl_lensflares.ts
@@ -138,7 +138,7 @@
         // stats
 
         stats = new Stats();
-        container.appendChild(stats.domElement);
+        container.appendChild(stats.dom);
 
         // events
 
diff --git a/three/tests/webgl/webgl_lights_hemisphere.ts b/three/tests/webgl/webgl_lights_hemisphere.ts
index 41ff781a87..1ea5013f67 100644
--- a/three/tests/webgl/webgl_lights_hemisphere.ts
+++ b/three/tests/webgl/webgl_lights_hemisphere.ts
@@ -151,7 +151,7 @@
         // STATS
 
         stats = new Stats();
-        container.appendChild( stats.domElement );
+        container.appendChild( stats.dom );
 
         //
 
diff --git a/three/tests/webgl/webgl_lines_colors.ts b/three/tests/webgl/webgl_lines_colors.ts
index 2d8ec1156e..7621f55ad9 100644
--- a/three/tests/webgl/webgl_lines_colors.ts
+++ b/three/tests/webgl/webgl_lines_colors.ts
@@ -73,23 +73,20 @@
 
         material = new THREE.LineBasicMaterial({ color: 0xffffff, opacity: 1, linewidth: 3, vertexColors: THREE.VertexColors });
 
-        var line, p, scale = 0.3, d = 225;
-        var parameters = [
+        var line, scale = 0.3, d = 225;
+        var parameters : [THREE.LineBasicMaterial, number, [number, number, number], THREE.Geometry][] = [
             [material, scale * 1.5, [-d, 0, 0], geometry],
             [material, scale * 1.5, [0, 0, 0], geometry2],
             [material, scale * 1.5, [d, 0, 0], geometry3]
         ];
 
-        for (i = 0; i < parameters.length; ++i) {
-
-            p = parameters[i];
+        for (const p of parameters) {
             line = new THREE.Line(p[3], p[0]);
             line.scale.x = line.scale.y = line.scale.z = p[1];
             line.position.x = p[2][0];
             line.position.y = p[2][1];
             line.position.z = p[2][2];
             scene.add(line);
-
         }
 
         //
diff --git a/three/tests/webgl/webgl_loader_awd.ts b/three/tests/webgl/webgl_loader_awd.ts
index fedc182619..8bdf496df0 100644
--- a/three/tests/webgl/webgl_loader_awd.ts
+++ b/three/tests/webgl/webgl_loader_awd.ts
@@ -77,9 +77,9 @@
         container.appendChild(renderer.domElement);
 
         stats = new Stats();
-        stats.domElement.style.position = 'absolute';
-        stats.domElement.style.top = '0px';
-        container.appendChild(stats.domElement);
+        stats.dom.style.position = 'absolute';
+        stats.dom.style.top = '0px';
+        container.appendChild(stats.dom);
 
         //
 
diff --git a/three/tests/webgl/webgl_materials.ts b/three/tests/webgl/webgl_materials.ts
index 47356cad68..a821d8198b 100644
--- a/three/tests/webgl/webgl_materials.ts
+++ b/three/tests/webgl/webgl_materials.ts
@@ -146,10 +146,10 @@
         //
 
         stats = new Stats();
-        stats.domElement.style.position = 'absolute';
-        stats.domElement.style.top = '0px';
+        stats.dom.style.position = 'absolute';
+        stats.dom.style.top = '0px';
 
-        container.appendChild(stats.domElement);
+        container.appendChild(stats.dom);
 
         //
 
diff --git a/three/tests/webgl/webgl_points_billboards.ts b/three/tests/webgl/webgl_points_billboards.ts
index 0fb5283cd6..bc2f133531 100644
--- a/three/tests/webgl/webgl_points_billboards.ts
+++ b/three/tests/webgl/webgl_points_billboards.ts
@@ -58,9 +58,9 @@
         //
 
         stats = new Stats();
-        stats.domElement.style.position = 'absolute';
-        stats.domElement.style.top = '0px';
-        container.appendChild( stats.domElement );
+        stats.dom.style.position = 'absolute';
+        stats.dom.style.top = '0px';
+        container.appendChild( stats.dom );
 
         //
 
diff --git a/three/tests/webgl/webgl_shader.ts b/three/tests/webgl/webgl_shader.ts
index 8ddb9e5dd8..57825368da 100644
--- a/three/tests/webgl/webgl_shader.ts
+++ b/three/tests/webgl/webgl_shader.ts
@@ -47,9 +47,9 @@
         container.appendChild(renderer.domElement);
 
         stats = new Stats();
-        stats.domElement.style.position = 'absolute';
-        stats.domElement.style.top = '0px';
-        container.appendChild(stats.domElement);
+        stats.dom.style.position = 'absolute';
+        stats.dom.style.top = '0px';
+        container.appendChild(stats.dom);
 
         onWindowResize();
 

From 85348cdf99b6e2e8c990151f58c0e10e65593a1d Mon Sep 17 00:00:00 2001
From: Rogier Schouten <rogierschouten@users.noreply.github.com>
Date: Sat, 8 Oct 2016 19:32:36 +0200
Subject: [PATCH 14/24] Add typings for ent. (#11782)

* Add typings for ent.

* process review comment

* process review comment
---
 ent/ent-tests.ts  |  9 +++++++++
 ent/index.d.ts    | 36 ++++++++++++++++++++++++++++++++++++
 ent/tsconfig.json | 19 +++++++++++++++++++
 3 files changed, 64 insertions(+)
 create mode 100644 ent/ent-tests.ts
 create mode 100644 ent/index.d.ts
 create mode 100644 ent/tsconfig.json

diff --git a/ent/ent-tests.ts b/ent/ent-tests.ts
new file mode 100644
index 0000000000..70b8bee858
--- /dev/null
+++ b/ent/ent-tests.ts
@@ -0,0 +1,9 @@
+
+import ent = require("ent");
+
+// encode
+const s: string = ent.encode("foo");
+const s2: string = ent.encode("foo", { numeric: true, named: true, special: { foo: true } });
+
+// decode
+const t: string = ent.decode("foo");
diff --git a/ent/index.d.ts b/ent/index.d.ts
new file mode 100644
index 0000000000..61dcfff355
--- /dev/null
+++ b/ent/index.d.ts
@@ -0,0 +1,36 @@
+// Type definitions for ent 2.2.0
+// Project: https://github.com/substack/node-ent
+// Definitions by: Rogier Schouten <https://github.com/rogierschouten>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference types="node" />
+
+/**
+ * Options for the encode() function
+ */
+export interface EntOpts {
+	/**
+	 * If opts.numeric is false or opts.named is true, encoding will used named codes like &pi;.
+	 */
+	numeric?: boolean;
+
+	/**
+	 * If opts.numeric is false or opts.named is true, encoding will used named codes like &pi;.
+	 */
+	named?: boolean;
+	
+	/**
+	 * If opts.special is set to an Object, the key names will be forced to be encoded (defaults to forcing: <>'"&)
+	 */
+	special?: any;
+}
+
+/**
+ * Escape unsafe characters in str with html entities. By default, entities are encoded with numeric decimal codes
+ */
+export function encode(s: string, opts?: EntOpts): string;
+
+/**
+ * Convert html entities in str back to raw text.
+ */
+export function decode(s: string): string;
diff --git a/ent/tsconfig.json b/ent/tsconfig.json
new file mode 100644
index 0000000000..469af5853a
--- /dev/null
+++ b/ent/tsconfig.json
@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "ent-tests.ts"
+    ]
+}
\ No newline at end of file

From 9fbb6f6df031a21cd6039dc4d30f72c87e0c7d03 Mon Sep 17 00:00:00 2001
From: Rogier Schouten <rogierschouten@users.noreply.github.com>
Date: Sat, 8 Oct 2016 19:32:59 +0200
Subject: [PATCH 15/24] Add typings for detect-browser (#11776)

* Add typings for detect-browser

* process review comment
---
 detect-browser/detect-browser-tests.ts |  5 +++++
 detect-browser/index.d.ts              | 14 ++++++++++++++
 detect-browser/tsconfig.json           | 19 +++++++++++++++++++
 3 files changed, 38 insertions(+)
 create mode 100644 detect-browser/detect-browser-tests.ts
 create mode 100644 detect-browser/index.d.ts
 create mode 100644 detect-browser/tsconfig.json

diff --git a/detect-browser/detect-browser-tests.ts b/detect-browser/detect-browser-tests.ts
new file mode 100644
index 0000000000..336da5150a
--- /dev/null
+++ b/detect-browser/detect-browser-tests.ts
@@ -0,0 +1,5 @@
+
+import detectBrowser = require("detect-browser");
+
+const n: string = detectBrowser.name;
+const v: string = detectBrowser.version;
diff --git a/detect-browser/index.d.ts b/detect-browser/index.d.ts
new file mode 100644
index 0000000000..0f845cd781
--- /dev/null
+++ b/detect-browser/index.d.ts
@@ -0,0 +1,14 @@
+// Type definitions for detect-browser v1.3.3
+// Project: https://github.com/DamonOehlman/detect-browser
+// Definitions by: Rogier Schouten <https://github.com/rogierschouten>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/**
+ * Browser name
+ */
+export const name: string;
+
+/**
+ * Browser version
+ */
+export const version: string;
diff --git a/detect-browser/tsconfig.json b/detect-browser/tsconfig.json
new file mode 100644
index 0000000000..c4acdf52df
--- /dev/null
+++ b/detect-browser/tsconfig.json
@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "detect-browser-tests.ts"
+    ]
+}
\ No newline at end of file

From e4f4b5138f0c422bb9d9bb4d0c2b21b7ed11002d Mon Sep 17 00:00:00 2001
From: Rogier Schouten <rogierschouten@users.noreply.github.com>
Date: Sat, 8 Oct 2016 19:33:09 +0200
Subject: [PATCH 16/24] Add typings for simplesmtp. (#11780)

* Add typings for simplesmtp.

* Process review comment.
---
 simplesmtp/index.d.ts          | 152 +++++++++++++++++++++++++++++++++
 simplesmtp/simplesmtp-tests.ts |  30 +++++++
 simplesmtp/tsconfig.json       |  19 +++++
 3 files changed, 201 insertions(+)
 create mode 100644 simplesmtp/index.d.ts
 create mode 100644 simplesmtp/simplesmtp-tests.ts
 create mode 100644 simplesmtp/tsconfig.json

diff --git a/simplesmtp/index.d.ts b/simplesmtp/index.d.ts
new file mode 100644
index 0000000000..1ac91a6fa5
--- /dev/null
+++ b/simplesmtp/index.d.ts
@@ -0,0 +1,152 @@
+// Type definitions for simplesmtp 0.3.35
+// Project: https://github.com/andris9/simplesmtp
+// Definitions by: Rogier Schouten <https://github.com/rogierschouten/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference types="node" />
+
+import events = require("events");
+
+export interface SmtpServerOptions {
+	/**
+	 * the hostname of the server, will be used for informational messages
+	 */
+	name?: string;
+	/**
+	 * if set to true, print out messages about the connection
+	 */
+	debug?: boolean;
+	/**
+	 * client timeout in milliseconds, defaults to 60 000
+	 */
+	timeout?: number;
+	/**
+	 * start a server on secure connection
+	 */
+	secureConnection?: boolean;
+	/**
+	 * greeting banner that is sent to the client on connection
+	 */
+	SMTPBanner?: string;
+	/**
+	 * if set to true, require that the client must authenticate itself
+	 */
+	requireAuthentication?: boolean;
+	/**
+	 * if set to true, client may authenticate itself but don't have to
+	 */
+	enableAuthentication?: boolean;
+	/**
+	 * maximum size of an e-mail in bytes
+	 */
+	maxSize?: number;
+	/**
+	 * TLS credentials
+	 */
+	credentials?: any;
+	/**
+	 * allowed authentication methods, defaults to <code>['PLAIN', 'LOGIN']</code>
+	 */
+	authMethods?: string[];
+	/**
+	 * if set, support HELO only
+	 */
+	disableEHLO?: boolean;
+	/**
+	 * if set, allow client do not use STARTTLS
+	 */
+	ignoreTLS?: boolean;
+	/**
+	 * if set, do not validate sender domains
+	 */
+	disableDNSValidation?: boolean;
+	/**
+	 * if set, limit the number of simultaneous connections to the server
+	 */
+	maxClients?: number;
+}
+
+/**
+ * <p>Constructs a SMTP server</p>
+ *
+ * @constructor
+ * @namespace SMTP Server module
+ * @param {Object} [options] Options object
+ */
+export class SMTPServer extends events.EventEmitter {
+
+	constructor(options?: SmtpServerOptions);
+
+	/**
+	 * Server starts listening on defined port and hostname
+	 *
+	 * @param {Number} port The port number to listen
+	 * @param {String} [host] The hostname to listen
+	 * @param {Function} callback The callback function to run when the server is listening
+	 */
+	public listen(port: number, host: string, callback?: (error: Error) => void): void;
+
+	/**
+	 * <p>Closes the server</p>
+	 *
+	 * @param {Function} callback The callback function to run when the server is closed
+	 */
+	public end(callback: () => void): void;
+
+
+}
+
+export class SimpleServer extends events.EventEmitter {
+
+	constructor(callback?: (connection: SimpleServerConnection) => void);
+	constructor(options?: SmtpServerOptions, callback?: (connection: SimpleServerConnection) => void);
+
+
+	public server: SMTPServer;
+
+	/**
+	 * Server starts listening on defined port and hostname
+	 *
+	 * @param {Number} port The port number to listen
+	 * @param {String} [host] The hostname to listen
+	 * @param {Function} callback The callback function to run when the server is listening
+	 */
+	public listen(port: number, host: string, callback?: (error: Error) => void): void;
+
+}
+
+/**
+ * Events:
+ * 'data' (chunk) - A chunk (Buffer) of the message.
+ * 'end' - The message has been transferred
+ */
+export interface SimpleServerConnection extends NodeJS.ReadableStream {
+	/**
+	 * From address
+	 */
+	from: string;
+	/**
+	 * an array of To addresses
+	 */
+	to: string[];
+	/**
+	 * hostname reported by the client
+	 */
+	host: string;
+	/**
+	 * client IP address
+	 */
+	remoteAddress: string;
+	/**
+	 * Accept the message with the selected ID
+	 */
+	accept(id?: string): void;
+	/**
+	 * Reject the message with the selected message
+	 */
+	reject(reason?: string): void;
+}
+
+
+export function createSimpleServer(callback?: (connection: SimpleServerConnection) => void): SimpleServer;
+export function createSimpleServer(options?: SmtpServerOptions, callback?: (connection: SimpleServerConnection) => void): SimpleServer;
diff --git a/simplesmtp/simplesmtp-tests.ts b/simplesmtp/simplesmtp-tests.ts
new file mode 100644
index 0000000000..c479a9ea1b
--- /dev/null
+++ b/simplesmtp/simplesmtp-tests.ts
@@ -0,0 +1,30 @@
+
+import simplesmtp = require("simplesmtp");
+
+let server: simplesmtp.SimpleServer;
+
+server = simplesmtp.createSimpleServer({
+	disableDNSValidation: true,
+	enableAuthentication: true,
+	requireAuthentication: false,
+	name: "localhost",
+	secureConnection: false,
+	SMTPBanner: "Hoi dit is de test server",
+	timeout: this.timeout,
+	ignoreTLS: true
+}, (req: simplesmtp.SimpleServerConnection) => {
+	req.on("data", (chunk: Buffer): void => {
+		//
+	});
+	req.on("end", (): void => {
+		//
+	});
+	req.accept("12");
+});
+this._server.server.on("authorizeUser",
+	(envelope: any, username: string|Buffer, password: string, callback: (error: Error, success: boolean) => void
+): void => {
+	callback(null, true);
+});
+this._server.listen(this.port, "0.0.0.0", (error?: Error): void => {
+});
diff --git a/simplesmtp/tsconfig.json b/simplesmtp/tsconfig.json
new file mode 100644
index 0000000000..323ad73e15
--- /dev/null
+++ b/simplesmtp/tsconfig.json
@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "simplesmtp-tests.ts"
+    ]
+}
\ No newline at end of file

From 92cf2a36b10ebb796a9e31a697033162f961956a Mon Sep 17 00:00:00 2001
From: Rogier Schouten <rogierschouten@users.noreply.github.com>
Date: Sat, 8 Oct 2016 19:33:18 +0200
Subject: [PATCH 17/24] Add typings for ldapjs. (#11783)

* Add typings for ldapjs.

* process review comment
---
 ldapjs/index.d.ts      | 93 ++++++++++++++++++++++++++++++++++++++++++
 ldapjs/ldapjs-tests.ts | 20 +++++++++
 ldapjs/tsconfig.json   | 19 +++++++++
 3 files changed, 132 insertions(+)
 create mode 100644 ldapjs/index.d.ts
 create mode 100644 ldapjs/ldapjs-tests.ts
 create mode 100644 ldapjs/tsconfig.json

diff --git a/ldapjs/index.d.ts b/ldapjs/index.d.ts
new file mode 100644
index 0000000000..50942be9fd
--- /dev/null
+++ b/ldapjs/index.d.ts
@@ -0,0 +1,93 @@
+// Type definitions for ldapjs v0.7.1
+// Project: http://ldapjs.org
+// Definitions by: Peter Kooijmans <https://github.com/peterkooijmans/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference types="node" />
+
+export interface Error {
+	code: number;
+	name: string;
+	message: string;
+}
+
+export interface CallBack {
+	(error: Error, result?: any): void;
+}
+
+export interface ClientOptions {
+	url: string;
+	socketPath?: string;
+	log?: any;
+	timeout?: number;
+	connectTimeout?: number;
+	maxConnections?: number;
+	bindDN?: string;
+	bindCredentials?: string;
+	checkInterval?: number;
+	maxIdleTime?: number;
+}
+
+export interface SearchOptions {
+	scope?: string;
+	filter?: string;
+	attributes?: string[];
+	attrsOnly?: boolean;
+	sizeLimit?: number;
+	timeLimit?: number;
+}
+
+export interface SearchCallBack {
+	(error: Error, result: NodeJS.EventEmitter): void;
+}
+
+export interface Client {
+	/**
+	 * Performs a simple authentication against the server.
+	 *
+	 * @param name the DN to bind as.
+	 * @param credentials the userPassword associated with name.
+	 * @param controls (optional) either a Control or [Control].
+	 * @param callback callback of the form f(err, res).
+	 * @throws {TypeError} on invalid input.
+	 */
+	bind(dn: string, password: string, callback: CallBack): void;
+
+	/**
+	 * Performs an LDAP search against the server.
+	 *
+	 * Note that the defaults for options are a 'base' search, if that's what
+	 * you want you can just pass in a string for options and it will be treated
+	 * as the search filter.  Also, you can either pass in programatic Filter
+	 * objects or a filter string as the filter option.
+	 *
+	 * Note that this method is 'special' in that the callback 'res' param will
+	 * have two important events on it, namely 'entry' and 'end' that you can hook
+	 * to.  The former will emit a SearchEntry object for each record that comes
+	 * back, and the latter will emit a normal LDAPResult object.
+	 *
+	 * @param {String} base the DN in the tree to start searching at.
+	 * @param {Object} options parameters:
+	 *                           - {String} scope default of 'base'.
+	 *                           - {String} filter default of '(objectclass=*)'.
+	 *                           - {Array} attributes [string] to return.
+	 *                           - {Boolean} attrsOnly whether to return values.
+	 * @param {Control} controls (optional) either a Control or [Control].
+	 * @param {Function} callback of the form f(err, res).
+	 * @throws {TypeError} on invalid input.
+	 */
+	search(base: string, options: SearchOptions, callback: SearchCallBack): void;
+
+	/**
+	 * Unbinds this client from the LDAP server.
+	 *
+	 * Note that unbind does not have a response, so this callback is actually
+	 * optional; either way, the client is disconnected.
+	 *
+	 * @param {Function} callback of the form f(err).
+	 * @throws {TypeError} if you pass in callback as not a function.
+	 */
+	unbind(callback: CallBack): void;
+}
+
+export function createClient(options? : ClientOptions): Client;
diff --git a/ldapjs/ldapjs-tests.ts b/ldapjs/ldapjs-tests.ts
new file mode 100644
index 0000000000..6b2d879142
--- /dev/null
+++ b/ldapjs/ldapjs-tests.ts
@@ -0,0 +1,20 @@
+
+import ldap = require("ldapjs");
+
+let client = ldap.createClient({
+  url: 'ldap://127.0.0.1:1389'
+});
+
+client.bind('cn=root', 'secret', (err: Error): void => {
+	// nothing
+});
+
+let opts: ldap.SearchOptions = {
+  filter: '(&(l=Seattle)(email=*@foo.com))',
+  scope: 'sub',
+  attributes: ['dn', 'sn', 'cn']
+};
+
+client.search('o=example', opts, (err: Error, res: NodeJS.EventEmitter): void => {
+	// nothing
+});
diff --git a/ldapjs/tsconfig.json b/ldapjs/tsconfig.json
new file mode 100644
index 0000000000..b9ed13b2e2
--- /dev/null
+++ b/ldapjs/tsconfig.json
@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "ldapjs-tests.ts"
+    ]
+}
\ No newline at end of file

From 477908eeba8ae69e7eed0fc2058ef7e3c383289f Mon Sep 17 00:00:00 2001
From: Rogier Schouten <rogierschouten@users.noreply.github.com>
Date: Sat, 8 Oct 2016 19:33:27 +0200
Subject: [PATCH 18/24] Add typings for url-join. (#11784)

* Add typings for url-join.

* process review comment
---
 url-join/index.d.ts        | 12 ++++++++++++
 url-join/tsconfig.json     | 19 +++++++++++++++++++
 url-join/url-join-tests.ts |  4 ++++
 3 files changed, 35 insertions(+)
 create mode 100644 url-join/index.d.ts
 create mode 100644 url-join/tsconfig.json
 create mode 100644 url-join/url-join-tests.ts

diff --git a/url-join/index.d.ts b/url-join/index.d.ts
new file mode 100644
index 0000000000..82715e643e
--- /dev/null
+++ b/url-join/index.d.ts
@@ -0,0 +1,12 @@
+// Type definitions for url-join v0.8.3
+// Project: https://github.com/jfromaniello/url-join
+// Definitions by: Rogier Schouten <https://github.com/rogierschouten>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/**
+ * Join all arguments together and normalize the resulting url.
+ * This works similar to path.join but you shouldn't use path.join for urls since it will work different depending of the operative systems but also doesn't work for some cases.
+ */	
+declare function urljoin(...parts: string[]): string;
+
+export = urljoin;
diff --git a/url-join/tsconfig.json b/url-join/tsconfig.json
new file mode 100644
index 0000000000..de90da89d2
--- /dev/null
+++ b/url-join/tsconfig.json
@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "url-join-tests.ts"
+    ]
+}
\ No newline at end of file
diff --git a/url-join/url-join-tests.ts b/url-join/url-join-tests.ts
new file mode 100644
index 0000000000..182b44359e
--- /dev/null
+++ b/url-join/url-join-tests.ts
@@ -0,0 +1,4 @@
+
+import urljoin = require("url-join");
+
+const s: string = urljoin("foo", "bar", "baz");

From bccd4c091a574c063a371603ab9d0b300ed60959 Mon Sep 17 00:00:00 2001
From: Rogier Schouten <rogierschouten@users.noreply.github.com>
Date: Sat, 8 Oct 2016 19:33:37 +0200
Subject: [PATCH 19/24] Turn random-js into an UMD module. (#11820)

---
 random-js/index.d.ts                          | 111 ++++++++++--------
 ...js-tests.ts => random-js-ambient-tests.ts} |   3 +-
 random-js/random-js-commonjs-tests.ts         |  29 +++++
 random-js/tsconfig.json                       |   3 +-
 4 files changed, 91 insertions(+), 55 deletions(-)
 rename random-js/{random-js-tests.ts => random-js-ambient-tests.ts} (94%)
 create mode 100644 random-js/random-js-commonjs-tests.ts

diff --git a/random-js/index.d.ts b/random-js/index.d.ts
index 81a056e82e..fd3909e508 100644
--- a/random-js/index.d.ts
+++ b/random-js/index.d.ts
@@ -3,60 +3,67 @@
 // Definitions by: Gustavo Di Pietro <https://github.com/pistacchio>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-declare namespace random {
-    export function Engine(): number;
-    export interface Engine {
 
-    }
+declare module TemporaryName {
+	
+	export interface Engine {
 
-    export function MT19937 (): number;
-    export interface MT19937 extends Engine{
-        seed (value: number): Engine;
-        seedWithArray(array: Array<number>): Engine
-        autoSeed(): Engine;
-        discard(count: number): Engine;
-        getUseCount(): Engine;
-    }
+	}
 
-    export class Random {
-        constructor (engine?: Engine);
+	export interface MT19937 extends Engine{
+		seed (value: number): Engine;
+		seedWithArray(array: Array<number>): Engine
+		autoSeed(): Engine;
+		discard(count: number): Engine;
+		getUseCount(): Engine;
+	}
 
-        static engines: {
-            nativeMath: Engine,
-            browserCrypto: Engine,
-            mt19937: () => MT19937
-        }
-
-        static integer(min: number, max: number): (engine: Engine) => number;
-        static real(min: number, max: number, inclusive: boolean): (engine: Engine) => number;
-        static bool(percentage?: number): (engine: Engine) => boolean;
-        static bool(numerator: number, denominator: number): (engine: Engine) => boolean;
-        static pick<T>(engine: Engine, array: Array<T>, begin?: number, end?: number): T;
-        static picker<T>(array: Array<T>, begin?: number, end?: number): (engine: Engine) => T;
-        static shuffle<T>(engine: Engine, array: Array<T>): Array<T>;
-        static sample<T>(engine: Engine, population: Array<T>, sampleSize: number): Array<T>;
-        static die(sideCount: number): (engine: Engine) => number;
-        static dice(sideCount: number, dieCount: number): (engine: Engine) => number;
-        static uuid4(engine: Engine): string;
-        static string(engine: Engine, length: number): string;
-        static string(pool: string, length: number): (engine: Engine, length: number) => string;
-        static hex(upperCase?: boolean): (engine: Engine, length: number) => string;
-        static date(start: Date, end: Date): (engine: Engine) => Date;
-
-        integer(min: number, max: number): number;
-        real(min: number, max: number, inclusive: boolean): number;
-        bool(percentage?: number): (engine: Engine) => boolean;
-        bool(numerator: number, denominator: number): boolean;
-        pick<T>(engine: Engine, array: Array<T>, begin?: number, end?: number): T;
-        picker<T>(array: Array<T>, begin?: number, end?: number): (engine: Engine) => T;
-        shuffle<T>(engine: Engine, array: Array<T>): Array<T>;
-        sample<T>(engine: Engine, population: Array<T>, sampleSize: number): Array<T>;
-        die(sideCount: number): (engine: Engine) => number;
-        dice(sideCount: number, dieCount: number): number;
-        uuid4(engine: Engine): string;
-        string(engine: Engine, length: number): string;
-        string(pool: string, length: number): string;
-        hex(upperCase?: boolean): string;
-        date(start: Date, end: Date): Date;
-    }
 }
+
+declare class TemporaryName {
+	constructor (engine?: TemporaryName.Engine);
+
+	static engines: {
+		nativeMath: TemporaryName.Engine,
+		browserCrypto: TemporaryName.Engine,
+		mt19937: () => TemporaryName.MT19937
+	}
+
+    static Engine(): number;
+    static MT19937 (): number;
+
+	static integer(min: number, max: number): (engine: TemporaryName.Engine) => number;
+	static real(min: number, max: number, inclusive: boolean): (engine: TemporaryName.Engine) => number;
+	static bool(percentage?: number): (engine: TemporaryName.Engine) => boolean;
+	static bool(numerator: number, denominator: number): (engine: TemporaryName.Engine) => boolean;
+	static pick<T>(engine: TemporaryName.Engine, array: Array<T>, begin?: number, end?: number): T;
+	static picker<T>(array: Array<T>, begin?: number, end?: number): (engine: TemporaryName.Engine) => T;
+	static shuffle<T>(engine: TemporaryName.Engine, array: Array<T>): Array<T>;
+	static sample<T>(engine: TemporaryName.Engine, population: Array<T>, sampleSize: number): Array<T>;
+	static die(sideCount: number): (engine: TemporaryName.Engine) => number;
+	static dice(sideCount: number, dieCount: number): (engine: TemporaryName.Engine) => number;
+	static uuid4(engine: TemporaryName.Engine): string;
+	static string(engine: TemporaryName.Engine, length: number): string;
+	static string(pool: string, length: number): (engine: TemporaryName.Engine, length: number) => string;
+	static hex(upperCase?: boolean): (engine: TemporaryName.Engine, length: number) => string;
+	static date(start: Date, end: Date): (engine: TemporaryName.Engine) => Date;
+
+	integer(min: number, max: number): number;
+	real(min: number, max: number, inclusive: boolean): number;
+	bool(percentage?: number): (engine: TemporaryName.Engine) => boolean;
+	bool(numerator: number, denominator: number): boolean;
+	pick<T>(engine: TemporaryName.Engine, array: Array<T>, begin?: number, end?: number): T;
+	picker<T>(array: Array<T>, begin?: number, end?: number): (engine: TemporaryName.Engine) => T;
+	shuffle<T>(engine: TemporaryName.Engine, array: Array<T>): Array<T>;
+	sample<T>(engine: TemporaryName.Engine, population: Array<T>, sampleSize: number): Array<T>;
+	die(sideCount: number): (engine: TemporaryName.Engine) => number;
+	dice(sideCount: number, dieCount: number): number;
+	uuid4(engine: TemporaryName.Engine): string;
+	string(engine: TemporaryName.Engine, length: number): string;
+	string(pool: string, length: number): string;
+	hex(upperCase?: boolean): string;
+	date(start: Date, end: Date): Date;
+}
+
+export = TemporaryName;
+export as namespace Random;
\ No newline at end of file
diff --git a/random-js/random-js-tests.ts b/random-js/random-js-ambient-tests.ts
similarity index 94%
rename from random-js/random-js-tests.ts
rename to random-js/random-js-ambient-tests.ts
index 77c698e321..177a037dee 100644
--- a/random-js/random-js-tests.ts
+++ b/random-js/random-js-ambient-tests.ts
@@ -2,8 +2,7 @@
 
 // Examples taken from the documentation at https://github.com/ckknight/random-js
 // create a Mersenne Twister-19937 that is auto-seeded based on time and other random values
-import Engine = random.Engine;
-import Random = random.Random;
+import Engine = Random.Engine;
 
 var engine: Engine = Random.engines.mt19937().autoSeed();
 // create a distribution that will consistently produce integers within inclusive range [0, 99].
diff --git a/random-js/random-js-commonjs-tests.ts b/random-js/random-js-commonjs-tests.ts
new file mode 100644
index 0000000000..0508aafb32
--- /dev/null
+++ b/random-js/random-js-commonjs-tests.ts
@@ -0,0 +1,29 @@
+/// <reference types="node"/>
+
+import Random = require('random-js');
+
+// Examples taken from the documentation at https://github.com/ckknight/random-js
+// create a Mersenne Twister-19937 that is auto-seeded based on time and other random values
+import Engine = Random.Engine;
+
+var engine: Engine = Random.engines.mt19937().autoSeed();
+// create a distribution that will consistently produce integers within inclusive range [0, 99].
+var distribution: Function = Random.integer(0, 99);
+// generate a number that is guaranteed to be within [0, 99] without any particular bias.
+function generateNaturalLessThan100(): number {
+    return distribution(engine);
+}
+
+// using essentially Math.random()
+var engine2: Engine = Random.engines.nativeMath;
+// lower-case Hex string distribution
+var distribution2: Function = Random.hex(false);
+// generate a 40-character hex string
+function generateSHA1(): string {
+    return distribution(40);
+}
+
+var r: Random = new Random(Random.engines.mt19937().seedWithArray([0x12345678, 0x90abcdef]));
+var value = r.integer(0, 99);
+
+r = new Random(); // same as new Random(Random.engines.nativeMath)
diff --git a/random-js/tsconfig.json b/random-js/tsconfig.json
index 357505a668..e1b7b50c26 100644
--- a/random-js/tsconfig.json
+++ b/random-js/tsconfig.json
@@ -14,6 +14,7 @@
     },
     "files": [
         "index.d.ts",
-        "random-js-tests.ts"
+        "random-js-ambient-tests.ts",
+        "random-js-commonjs-tests.ts"
     ]
 }
\ No newline at end of file

From b430e39c9722ab096eed4faed957aa2041ec1eca Mon Sep 17 00:00:00 2001
From: Rogier Schouten <rogierschouten@users.noreply.github.com>
Date: Sat, 8 Oct 2016 19:33:43 +0200
Subject: [PATCH 20/24] add jcanvas typings (#11822)

---
 jcanvas/index.d.ts       | 84 ++++++++++++++++++++++++++++++++++++++++
 jcanvas/jcanvas-tests.ts | 23 +++++++++++
 jcanvas/tsconfig.json    | 21 ++++++++++
 3 files changed, 128 insertions(+)
 create mode 100644 jcanvas/index.d.ts
 create mode 100644 jcanvas/jcanvas-tests.ts
 create mode 100644 jcanvas/tsconfig.json

diff --git a/jcanvas/index.d.ts b/jcanvas/index.d.ts
new file mode 100644
index 0000000000..2a9c1f587c
--- /dev/null
+++ b/jcanvas/index.d.ts
@@ -0,0 +1,84 @@
+// Type definitions for jCanvas 15.02.07
+// Project: http://projects.calebevans.me/jcanvas/
+// Definitions by: Rogier Schouten <https://github.com/rogierschouten>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference types="jquery"/>
+
+interface JCanvasRect {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+}
+
+interface JCanvasSliceDef {
+	fillStyle: string;
+	x: number;
+	y: number;
+	/**
+	 * Radius in pixels
+	 */
+	radius: number;
+	/**
+	 * Start angle in degrees from north
+	 */
+	start: number;
+	/**
+	 * End angle in degrees from north
+	 */
+	end: number;
+	/**
+	 * Distance between slices as a fraction of the radius
+	 */
+	spread?: number;
+
+	layer?: boolean;
+	name?: string;
+	groups?: string[];
+}
+
+interface JCanvasTextDef {
+	fillStyle: string;
+	strokeStyle: string;
+	strokeWidth: number;
+	x: number;
+	y: number;
+	fontSize: number;
+	fontFamily: string;
+	text: string;
+}
+
+interface JQuery {
+
+	/**
+	 * This clearCanvas() clears all or any part of the canvas
+	 * If nothing is passed, the entire canvas is cleared.
+	 * Clearing a section works in the same way as drawing a rectangle,
+	 * with the rectangle being drawn from its center (by default).
+	 */
+	clearCanvas(rect?: JCanvasRect): void;
+
+	/**
+	 * A slice in jCanvas is, essentially, a slice of a circle (similar to a pizza slice).
+	 * You can draw a slice using the drawSlice() method. The size of a slice is determined by its start, end, and radius properties.
+	 * The position of a slice is determined by its x and y properties. These coordinates lie at the tip of the slice.
+	 */
+	drawSlice(def: JCanvasSliceDef): void;
+
+	/**
+	 * To draw text on the canvas, use the drawText() method.
+	 * The resulting text on the canvas is determined by the value of the text property, as well as any of the following font properties:
+	 * fontStyle
+	 * fontSize
+	 * fontFamily
+	 */
+	drawText(def: JCanvasTextDef): void;
+}
+
+// note this declare module is necessary to tell TypeScript not to interpret the whole file as one module;
+// the JQuery interface below should extend the existing jquery module interface
+declare module "jcanvas" {
+	function jcanvas(jquery: JQueryStatic, window: Window): void;
+	export = jcanvas;
+}
diff --git a/jcanvas/jcanvas-tests.ts b/jcanvas/jcanvas-tests.ts
new file mode 100644
index 0000000000..3cd5e32cab
--- /dev/null
+++ b/jcanvas/jcanvas-tests.ts
@@ -0,0 +1,23 @@
+
+import $ = require("jquery");
+import jcanvas = require("jcanvas");
+jcanvas($, window);
+
+
+const elt = $(".foo");
+elt.clearCanvas();
+elt.drawSlice({
+	fillStyle: "blue",
+	x: 100, y: 100,
+	radius: 80,
+	start: 0, end: 359.9
+});
+elt.drawText({
+	fillStyle: "white",
+	strokeStyle: "red",
+	strokeWidth: 2,
+	x: 100, y: 100,
+	fontSize: 48,
+	fontFamily: "Arial",
+	text: "bar"
+});
diff --git a/jcanvas/tsconfig.json b/jcanvas/tsconfig.json
new file mode 100644
index 0000000000..6f92aa9018
--- /dev/null
+++ b/jcanvas/tsconfig.json
@@ -0,0 +1,21 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [
+            "node"
+        ],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "jcanvas-tests.ts"
+    ]
+}

From 2a09ec44d5ae46d8408cc94942b3f0964f1287b9 Mon Sep 17 00:00:00 2001
From: Mizunashi Mana <mizunashi_mana@mma.club.uec.ac.jp>
Date: Sun, 9 Oct 2016 02:34:17 +0900
Subject: [PATCH 21/24] Fix yargs type definitions (#11823)

---
 yargs/index.d.ts     |  9 +++---
 yargs/yargs-tests.ts | 69 ++++++++++++++++++++++++++++++++++++++++----
 2 files changed, 69 insertions(+), 9 deletions(-)

diff --git a/yargs/index.d.ts b/yargs/index.d.ts
index df84b8dc3d..a10edc717b 100644
--- a/yargs/index.d.ts
+++ b/yargs/index.d.ts
@@ -1,6 +1,6 @@
 // Type definitions for yargs
 // Project: https://github.com/chevex/yargs
-// Definitions by: Martin Poelstra <https://github.com/poelstra>
+// Definitions by: Martin Poelstra <https://github.com/poelstra>, Mizunashi Mana <https://github.com/mizunashi-mana>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 declare namespace yargs {
@@ -124,8 +124,6 @@ declare namespace yargs {
         nargs(key: string, count: number): Argv;
         nargs(nargs: { [key: string]: number }): Argv;
 
-        /* Undocumented */
-
         normalize(key: string): Argv;
         normalize(keys: string[]): Argv;
 
@@ -135,7 +133,10 @@ declare namespace yargs {
         count(key: string): Argv;
         count(keys: string[]): Argv;
 
-        fail(func: (msg: string) => any): void;
+        fail(func: (msg: string, err?: Error) => any): Argv;
+
+        coerce<T, U>(key: string|string[], func: (arg: T) => U): Argv;
+        coerce<T, U>(opts: { [key: string]: (arg: T) => U; }): Argv;
     }
 
     interface RequireDirectoryOptions {
diff --git a/yargs/yargs-tests.ts b/yargs/yargs-tests.ts
index e2fedd7b66..8a88b8720e 100644
--- a/yargs/yargs-tests.ts
+++ b/yargs/yargs-tests.ts
@@ -1,9 +1,11 @@
-// Type definition tests for yargs
-// Project: https://github.com/chevex/yargs
-// Definitions by: Martin Poelstra <https://github.com/poelstra>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+/// <reference types="node" />
 
-import yargs = require('yargs');
+import * as yargs from 'yargs';
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+const stringVal = 'string';
 
 // Examples taken from yargs website
 // https://github.com/chevex/yargs
@@ -349,3 +351,60 @@ function Argv$commandDirWithOptions() {
 		})
 		.argv
 }
+
+function Argv$normalize() {
+	var ya = yargs
+		.normalize('path')
+		.normalize(['user', 'group'])
+		.argv
+}
+
+// From http://yargs.js.org/docs/#methods-coercekey-fn
+function Argv$coerce() {
+	var ya = yargs
+		.coerce('file', function (arg: string) {
+			return fs.readFileSync(arg, 'utf8');
+		})
+		.argv
+}
+function Argv$coerces() {
+	var ya = yargs
+		.coerce({
+			date: Date.parse,
+			json: JSON.parse
+		})
+		.argv
+}
+function Argv$coerceWithKeys() {
+	var ya = yargs
+		.coerce(['src', 'dest'], path.resolve)
+		.argv
+}
+
+// From http://yargs.js.org/docs/#methods-failfn
+function Argv$fail() {
+	var ya = yargs
+		.fail(function (msg, err) {
+			if (err) throw err // preserve stack
+			console.error('You broke it!')
+			console.error(msg)
+			process.exit(1)
+		})
+		.argv
+}
+
+function Argv$implies() {
+	var ya = yargs
+		.implies('foo', 'snuh')
+		.implies({
+			x: 'y'
+		})
+		.argv
+}
+
+function Argv$count() {
+	var ya = yargs
+		.count('size')
+		.count(['w', 'h'])
+		.argv
+}

From cab65f1d394cf31daa19951a626ba257ed09b791 Mon Sep 17 00:00:00 2001
From: Andy <anhans@microsoft.com>
Date: Sat, 8 Oct 2016 13:07:12 -0700
Subject: [PATCH 22/24] Break up ts-activex into separate modules (#11805)

---
 .../activex-data-objects-tests.ts             |  3 ---
 .../index.d.ts                                |  2 --
 activex-data-objects/tsconfig.json            | 19 +++++++++++++++++++
 .../activex-scripting-runtime-tests.ts        |  3 ---
 .../index.d.ts                                |  2 --
 activex-scripting-runtime/tsconfig.json       | 19 +++++++++++++++++++
 ...activex-windows-image-acquisition-tests.ts |  2 --
 .../index.d.ts                                |  2 --
 .../tsconfig.json                             | 19 +++++++++++++++++++
 ts-activex/jscript-extensions-tests.ts        |  5 -----
 ts-activex/jscript-extensions.d.ts            | 16 ----------------
 11 files changed, 57 insertions(+), 35 deletions(-)
 rename {ts-activex => activex-data-objects}/activex-data-objects-tests.ts (92%)
 rename ts-activex/activex-data-objects.d.ts => activex-data-objects/index.d.ts (99%)
 create mode 100644 activex-data-objects/tsconfig.json
 rename ts-activex/microsoft-scripting-runtime-tests.ts => activex-scripting-runtime/activex-scripting-runtime-tests.ts (97%)
 rename ts-activex/microsoft-scripting-runtime.d.ts => activex-scripting-runtime/index.d.ts (99%)
 create mode 100644 activex-scripting-runtime/tsconfig.json
 rename ts-activex/windows-image-acquisition-tests.ts => activex-windows-image-acquisition/activex-windows-image-acquisition-tests.ts (97%)
 rename ts-activex/windows-image-acquisition.d.ts => activex-windows-image-acquisition/index.d.ts (99%)
 create mode 100644 activex-windows-image-acquisition/tsconfig.json
 delete mode 100644 ts-activex/jscript-extensions-tests.ts
 delete mode 100644 ts-activex/jscript-extensions.d.ts

diff --git a/ts-activex/activex-data-objects-tests.ts b/activex-data-objects/activex-data-objects-tests.ts
similarity index 92%
rename from ts-activex/activex-data-objects-tests.ts
rename to activex-data-objects/activex-data-objects-tests.ts
index 27373ff8f0..6298298a48 100644
--- a/ts-activex/activex-data-objects-tests.ts
+++ b/activex-data-objects/activex-data-objects-tests.ts
@@ -1,6 +1,3 @@
-/// <reference path="activex-data-objects.d.ts" />
-
-
 //open connection to an Excel file
 var pathToExcelFile = 'C:\\path\\to\\excel\\file.xlsx';
 var conn = new ActiveXObject('ADODB.Connection');
diff --git a/ts-activex/activex-data-objects.d.ts b/activex-data-objects/index.d.ts
similarity index 99%
rename from ts-activex/activex-data-objects.d.ts
rename to activex-data-objects/index.d.ts
index 5b6844fef4..d3ccf7a6c7 100644
--- a/ts-activex/activex-data-objects.d.ts
+++ b/activex-data-objects/index.d.ts
@@ -3,8 +3,6 @@
 // Definitions by: Zev Spitz <https://github.com/zspitz>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference path="jscript-extensions.d.ts" />
-
 declare namespace ADODB {
 
     //Enums
diff --git a/activex-data-objects/tsconfig.json b/activex-data-objects/tsconfig.json
new file mode 100644
index 0000000000..5fb09cb648
--- /dev/null
+++ b/activex-data-objects/tsconfig.json
@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "activex-data-objects-tests.ts"
+    ]
+}
\ No newline at end of file
diff --git a/ts-activex/microsoft-scripting-runtime-tests.ts b/activex-scripting-runtime/activex-scripting-runtime-tests.ts
similarity index 97%
rename from ts-activex/microsoft-scripting-runtime-tests.ts
rename to activex-scripting-runtime/activex-scripting-runtime-tests.ts
index d08dc5cf96..1510b98e1b 100644
--- a/ts-activex/microsoft-scripting-runtime-tests.ts
+++ b/activex-scripting-runtime/activex-scripting-runtime-tests.ts
@@ -1,6 +1,3 @@
-/// <reference path="microsoft-scripting-runtime.d.ts" />
-
-
 //source -- https://msdn.microsoft.com/en-us/library/ebkhfaaz.aspx
 
 
diff --git a/ts-activex/microsoft-scripting-runtime.d.ts b/activex-scripting-runtime/index.d.ts
similarity index 99%
rename from ts-activex/microsoft-scripting-runtime.d.ts
rename to activex-scripting-runtime/index.d.ts
index fd50b7504f..54065e1bd7 100644
--- a/ts-activex/microsoft-scripting-runtime.d.ts
+++ b/activex-scripting-runtime/index.d.ts
@@ -3,8 +3,6 @@
 // Definitions by: Zev Spitz <https://github.com/zspitz>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference path="jscript-extensions.d.ts" />
-
 declare namespace Scripting {
 
     //Enums
diff --git a/activex-scripting-runtime/tsconfig.json b/activex-scripting-runtime/tsconfig.json
new file mode 100644
index 0000000000..8845470e70
--- /dev/null
+++ b/activex-scripting-runtime/tsconfig.json
@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "activex-scripting-runtime-tests.ts"
+    ]
+}
\ No newline at end of file
diff --git a/ts-activex/windows-image-acquisition-tests.ts b/activex-windows-image-acquisition/activex-windows-image-acquisition-tests.ts
similarity index 97%
rename from ts-activex/windows-image-acquisition-tests.ts
rename to activex-windows-image-acquisition/activex-windows-image-acquisition-tests.ts
index ae394a99f8..549bb4433f 100644
--- a/ts-activex/windows-image-acquisition-tests.ts
+++ b/activex-windows-image-acquisition/activex-windows-image-acquisition-tests.ts
@@ -1,5 +1,3 @@
-/// <reference path="windows-image-acquisition.d.ts" />
-
 //source -- https://msdn.microsoft.com/en-us/library/windows/desktop/ms630826(v=vs.85).aspx
 
 
diff --git a/ts-activex/windows-image-acquisition.d.ts b/activex-windows-image-acquisition/index.d.ts
similarity index 99%
rename from ts-activex/windows-image-acquisition.d.ts
rename to activex-windows-image-acquisition/index.d.ts
index 7be1884a4e..af32d8a865 100644
--- a/ts-activex/windows-image-acquisition.d.ts
+++ b/activex-windows-image-acquisition/index.d.ts
@@ -3,8 +3,6 @@
 // Definitions by: Zev Spitz <https://github.com/zspitz>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference path="jscript-extensions.d.ts" />
-
 declare namespace WIA {
 
     //Enums
diff --git a/activex-windows-image-acquisition/tsconfig.json b/activex-windows-image-acquisition/tsconfig.json
new file mode 100644
index 0000000000..d06b9b3b35
--- /dev/null
+++ b/activex-windows-image-acquisition/tsconfig.json
@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "activex-windows-image-acquisition-tests.ts"
+    ]
+}
\ No newline at end of file
diff --git a/ts-activex/jscript-extensions-tests.ts b/ts-activex/jscript-extensions-tests.ts
deleted file mode 100644
index 1e4fa6a41d..0000000000
--- a/ts-activex/jscript-extensions-tests.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-/// <reference path="jscript-extensions.d.ts" />
-
-var x: VarDate;
-var dte = new Date(x);
-x = dte.getVarDate();
\ No newline at end of file
diff --git a/ts-activex/jscript-extensions.d.ts b/ts-activex/jscript-extensions.d.ts
deleted file mode 100644
index b7291366bf..0000000000
--- a/ts-activex/jscript-extensions.d.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-// Type definitions for Microsoft JScript extensions
-// Project: https://msdn.microsoft.com/en-us/library/yek4tbz0(v=vs.84).aspx
-// Definitions by: Zev Spitz <https://github.com/zspitz>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-//These will become unnecessary with the next version of Typescript
-
-interface VarDate { }
-
-interface DateConstructor {
-    new (vd: VarDate): Date;
-}
-
-interface Date {
-    getVarDate: () => VarDate;
-}
\ No newline at end of file

From bc4978960865efdefb3a2b86ea005b185f478203 Mon Sep 17 00:00:00 2001
From: osechet <osechet@gmail.com>
Date: Sun, 9 Oct 2016 18:49:47 +0200
Subject: [PATCH 23/24] [openlayers] Update definition version (#11819)

The definition file is for v3.18.2. During the merge from master, the version has not been updated and remained 3.6.0.
---
 openlayers/index.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/openlayers/index.d.ts b/openlayers/index.d.ts
index f7f11d8ebf..5d72ce5711 100644
--- a/openlayers/index.d.ts
+++ b/openlayers/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for OpenLayers v3.6.0
+// Type definitions for OpenLayers v3.18.2
 // Project: http://openlayers.org/
 // Definitions by: Olivier Sechet <https://github.com/osechet>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -13786,4 +13786,4 @@ declare module olx {
 
 declare module "openlayers" {
     export = ol;
-}
\ No newline at end of file
+}

From 8093f71e55644e52669fcef31a0ea65adc1c04cb Mon Sep 17 00:00:00 2001
From: Christian Crowhurst <christian.crowhurst@gmail.com>
Date: Sun, 9 Oct 2016 17:51:33 +0100
Subject: [PATCH 24/24] Add ng-table to the notNeededPackages list (#11856)

* Add ng-table to the notNeededPackages list

* Delete old ng-table external type declarations
---
 ng-table/index.d.ts        | 838 -------------------------------------
 ng-table/ng-table-tests.ts | 114 -----
 ng-table/tsconfig.json     |  19 -
 notNeededPackages.json     |   6 +
 4 files changed, 6 insertions(+), 971 deletions(-)
 delete mode 100644 ng-table/index.d.ts
 delete mode 100644 ng-table/ng-table-tests.ts
 delete mode 100644 ng-table/tsconfig.json

diff --git a/ng-table/index.d.ts b/ng-table/index.d.ts
deleted file mode 100644
index e079977db9..0000000000
--- a/ng-table/index.d.ts
+++ /dev/null
@@ -1,838 +0,0 @@
-// Type definitions for ng-table
-// Project: https://github.com/esvit/ng-table
-// Definitions by: Christian Crowhurst <https://github.com/christianacca>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-/// <reference types="angular" />
-
-/**
- * Parameters manager for an ngTable directive
- */
-declare class NgTableParams<T> {
-    /**
-     * The page of data rows currently being displayed in the table
-     */
-    data: T[];
-
-    constructor(baseParameters?: NgTable.IParamValues<T>, baseSettings?: NgTable.ISettings<T>)
-    
-    /**
-     * Returns the number of data rows per page
-     */
-    count(): number
-    /**
-     * Sets the number of data rows per page.
-     * Changes to count will cause `isDataReloadRequired` to return true
-     */
-    count(count: number): NgTableParams<T>
-    
-    /**
-     * Returns the current filter values used to restrict the set of data rows.
-     * @param trim supply true to return the current filter minus any insignificant values
-     * (null,  undefined and empty string)
-     */
-    filter(trim?: boolean): NgTable.IFilterValues
-    /**
-     * Sets filter values to the `filter` supplied; any existing filter will be removed
-     * Changes to filter will cause `isDataReloadRequired` to return true and the current `page` to be set to 1
-     */
-    filter(filter: NgTable.IFilterValues): NgTableParams<T>
-    /**
-     * Generate array of pages.
-     * When no arguments supplied, the current parameter state of this `NgTableParams` instance will be used
-     */
-    generatePagesArray(currentPage?: number, totalItems?: number, pageSize?: number, maxBlocks?: number): NgTable.IPageButton[]
-    /**
-     * Returns the current grouping used to group the data rows
-     */
-    group(): NgTable.Grouping<T>
-    /**
-     * Sets grouping to the `field` and `sortDirection` supplied; any existing grouping will be removed
-     * Changes to group will cause `isDataReloadRequired` to return true and the current `page` to be set to 1
-     */
-    group(field: string, sortDirection?: string): NgTableParams<T>
-    /**
-     * Sets grouping to the `group` supplied; any existing grouping will be removed.
-     * Changes to group will cause `isDataReloadRequired` to return true and the current `page` to be set to 1
-     */
-    group(group: NgTable.Grouping<T>): NgTableParams<T>
-    /**
-     * Returns true when an attempt to `reload` the current `parameter` values have resulted in a failure.
-     * This method will continue to return true until the `reload` is successfully called or when the
-     * `parameter` values have changed
-     */
-    hasErrorState(): boolean
-    /**
-     * Returns true if `filter` has significant filter value(s) (any value except null, undefined, or empty string),
-     * otherwise false
-     */
-    hasFilter(): boolean
-    /**
-     * Return true when a change to `filters` require the `reload` method
-     * to be run so as to ensure the data presented to the user reflects these filters
-     */
-    hasFilterChanges(): boolean
-    /**
-     * Returns true when at least one group has been set
-     */
-    hasGroup(): boolean
-    /**
-     * Returns true when the `group` and when supplied, the `sortDirection` matches an existing group
-     */
-    hasGroup(group: string | NgTable.IGroupingFunc<T>, sortDirection?: string): boolean
-    /**
-     * Return true when a change to this instance should require the `reload` method
-     * to be run so as to ensure the data rows presented to the user reflects the current state.
-     * 
-     * Note that this method will return false when the `reload` method has run but fails. In this case
-     * `hasErrorState` will return true.
-     * 
-     * The built-in `ngTable` directives will watch for when this function returns true and will then call
-     * the `reload` method to load its data rows
-     */
-    isDataReloadRequired(): boolean
-    /**
-     * Returns sorting values in a format that can be consumed by the angular `$orderBy` filter service
-     */
-    orderBy(): string[]
-    /**
-     * Trigger a reload of the data rows
-     */
-    reload<TResult extends NgTable.Data.DataResult<T>>(): ng.IPromise<TResult[]>
-    /**
-     * Returns the settings for the table.
-     */
-    settings(): NgTable.ISettings<T>
-    /**
-     * Sets the settings for the table; new setting values will be merged with the existing settings.
-     * Supplying a new `dataset` will cause `isDataReloadRequired` to return true and the `ngTableEventsChannel`
-     * to fire its `datasetChanged` event
-     */
-    settings(newSettings: NgTable.ISettings<T>): NgTableParams<T>
-    /** 
-     * Returns the current sorting used to order the data rows.
-     * Changes to sorting will cause `isDataReloadRequired` to return true
-     */
-    sorting(): NgTable.ISortingValues
-    /**
-     * Sets sorting values to the `sorting` supplied; any existing sorting will be removed.
-     * Changes to sorting will cause `isDataReloadRequired` to return true
-     */
-    sorting(sorting: NgTable.ISortingValues): NgTableParams<T>
-    /**
-     * Sets sorting to the `field` and `direction` supplied; any existing sorting will be removed
-     */
-    sorting(field: string, direction: string): NgTableParams<T>
-    /**
-     * Returns the index of the current "slice" of data rows
-     */
-    page(): number
-    /**
-     * Sets the index of the current "slice" of data rows. The index starts at 1.
-     * Changing the page number will cause `isDataReloadRequired` to return true
-     */
-    page(page: number): NgTableParams<T>
-    /**
-     * Returns the count of the data rows that match the current `filter`
-     */
-    total(): number
-    /**
-     * Sets `settings().total` to the value supplied.
-     * Typically you will need to set a `total` in the body of any custom `getData` function
-     * you supply as a setting value to this instance.
-     * @example
-     * var tp = new NgTableParams({}, { getData: customGetData })
-     * function customGetData(params) {
-     *      var queryResult = /* code to fetch current data rows and total *\/
-     *      params.total(queryResult.total);
-     *      return queryResult.dataRowsPage;
-     * }
-     */
-    total(total: number): NgTableParams<T>
-    /**
-     * Returns the current parameter values uri-encoded. Set `asString` to 
-     * true for the parameters to be returned as an array of strings of the form 'paramName=value'
-     * otherwise parameters returned as a key-value object
-     */
-    url(asString?: boolean): { [name: string]: string } | string[]
-}
-
-declare namespace NgTable {
-
-    interface IDataSettings {
-        applyPaging?: boolean;
-    }
-    
-    /**
-     * An angular value object that allow for overriding of the initial default values used when constructing
-     * an instance of `NgTableParams`  
-     */
-    interface IDefaults {
-        params?: IParamValues<any>;
-        settings?: ISettings<any>
-    }
-
-    /**
-     * Map of the names of fields declared on a data row and the corrosponding filter value
-     */
-    interface IFilterValues { [name: string]: any }
-    
-    /**
-     * Map of the names of fields on a data row and the corrosponding sort direction;
-     * Set the value of a key to undefined to let value of `ISettings.defaultSort` apply
-     */
-    interface ISortingValues { [name: string]: string }
-
-    type Grouping<T> = IGroupValues | IGroupingFunc<T>;
-
-    /**
-     * Map of the names of fields on a data row and the corrosponding sort direction
-     */
-    interface IGroupValues { [name: string]: string }
-    
-    /**
-     * Signature of a function that should return the name of the group
-     * that the `item` should be placed within
-     */
-    interface IGroupingFunc<T> {
-        (item: T): string;
-        /**
-         * 'asc' or 'desc'; leave undefined to let the value of `ISettings.groupOptions.defaultSort` apply
-         */
-        sortDirection?: string
-    }
-     
-    /**
-     * The runtime values for `NgTableParams` that determine the set of data rows and 
-     * how they are to be displayed in a table
-     */
-    interface IParamValues<T> {
-        /**
-         * The index of the "slice" of data rows, starting at 1, to be displayed by the table.
-         */
-        page?: number;
-        /**
-         * The number of data rows per page
-         */
-        count?: number;
-        /** 
-         * The filter that should be applied to restrict the set of data rows
-         */
-        filter?: IFilterValues;
-        /**
-         * The sort order that should be applied to the data rows.
-         */
-        sorting?: ISortingValues;
-        /**
-         * The grouping that should be applied to the data rows
-         */
-        group?: string | Grouping<T>;
-    }
-
-
-    type FilterComparator<T> = boolean | IFilterComparatorFunc<T>;
-
-    interface IFilterComparatorFunc<T> {
-        (actual: T, expected: T): boolean;
-    }
-
-    interface IFilterFunc<T> {
-        (data: T[], filter: IFilterValues, filterComparator: FilterComparator<T>): T[]
-    }
-
-
-    interface IFilterSettings<T> {
-        /**
-         * Use this to determine how items are matched against the filter values.
-         * This setting is identical to the `comparator` parameter supported by the angular 
-         * `$filter` filter service
-         * 
-         * Defaults to `undefined` which will result in a case insensitive susbstring match when 
-         * `IDefaultGetData` service is supplying the implementation for the
-         * `ISettings.getData` function
-         */
-        filterComparator?: FilterComparator<T>;
-        /**
-         * A duration to wait for the user to stop typing before applying the filter.
-         * - Defaults to 0 for small managed inmemory arrays ie where a `ISettings.dataset` argument is 
-         *   supplied to `NgTableParams.settings`.
-         * - Defaults to 500 milliseconds otherwise.
-         */
-        filterDelay?: number;
-        /**
-         * The number of elements up to which a managed inmemory array is considered small. Defaults to 10000.
-         */
-        filterDelayThreshold?: number;
-        /**
-         * Overrides `IDefaultGetDataProvider.filterFilterName`.
-         * The value supplied should be the name of the angular `$filter` service that will be selected to perform 
-         * the actual filter logic.
-         * Defaults to 'filter'.
-         */
-        filterFilterName?: string;
-        /**
-         * Tells `IDefaultGetData` to use this function supplied to perform the filtering instead of selecting an angular $filter.
-         */
-        filterFn?: IFilterFunc<T>;
-        /**
-         * The layout to use when multiple html templates are to rendered in a single table header column.
-         * Available values:
-         * - stack (the default)
-         * - horizontal 
-         */
-        filterLayout?: string
-    }
-
-    interface IGroupSettings {
-        /**
-         * The default sort direction that will be used whenever a group is supplied that
-         * does not define its own sort direction
-         */
-        defaultSort?: string;
-        /**
-         * Determines whether groups should be displayed expanded to show their items. Defaults to true
-         */
-        isExpanded?: boolean;
-    }
-    
-    /**
-     * Definition of the buttons rendered by the data row pager directive
-     */
-    interface IPageButton {
-        type: string;
-        number?: number;
-        active: boolean;
-        current?: boolean;
-    }
-        
-    /**
-     * Configuration settings for `NgTableParams`
-     */
-    interface ISettings<T> {
-        /**
-         * Returns true whenever a call to `getData` is in progress
-         */
-        $loading?: boolean;
-        /**
-         * An array that contains all the data rows that NgTable should manage.
-         * The `gateData` function will be used to manage the data rows
-         * that ultimately will be displayed.
-         */
-        dataset?: T[];
-        dataOptions?: {};
-        /**
-         * The total number of data rows before paging has been applied.
-         * Typically you will not need to supply this yourself
-         */
-        total?: number;
-        /**
-         * The default sort direction that will be used whenever a sorting is supplied that
-         * does not define its own sort direction
-         */
-        defaultSort?: string;
-        filterOptions?: IFilterSettings<T>;
-        groupOptions?: IGroupSettings;
-        /**
-         * The page size buttons that should be displayed. Each value defined in the array
-         * determines the possible values that can be supplied to `NgTableParams.page()`
-         */
-        counts?: number[];
-        /**
-         * The collection of interceptors that should apply to the results of a call to
-         * the `getData` function before the data rows are displayed in the table
-         */
-        interceptors?: IInterceptor<T>[];
-        /**
-         * Configuration for the template that will display the page size buttons
-         */
-        paginationMaxBlocks?: number;
-        /**
-         * Configuration for the template that will display the page size buttons
-         */
-        paginationMinBlocks?: number;
-        /**
-         * The html tag that will be used to display the sorting indicator in the table header
-         */
-        sortingIndicator?: string;
-        /**
-         * The function that will be used fetch data rows. Leave undefined to let the `IDefaultGetData`
-         * service provide a default implementation that will work with the `dataset` array you supply.
-         * 
-         * Typically you will supply a custom function when you need to execute filtering, paging and sorting
-         * on the server
-         */
-        getData?: Data.IGetDataFunc<T> | Data.IInterceptableGetDataFunc<T>;
-        /** 
-         * The function that will be used group data rows according to the groupings returned by `NgTableParams.group()`
-        */
-        getGroups?: Data.IGetGroupFunc<T>;
-    }
-
-    /**
-     * Configuration values that determine the behaviour of the `ngTableFilterConfig` service
-     */
-    interface IFilterConfigValues {
-        /**
-         * The default base url to use when deriving the url for a filter template given just an alias name
-         * Defaults to 'ng-table/filters/'
-         */
-        defaultBaseUrl?: string;
-        /**
-         * The extension to use when deriving the url of a filter template when given just an alias name
-         */
-        defaultExt?: string;
-        /**
-         * A map of alias names and their corrosponding urls. A lookup against this map will be used
-         * to find the url matching an alias name.
-         * If no match is found then a url will be derived using the following pattern `${defaultBaseUrl}${aliasName}.${defaultExt}`
-         */
-        aliasUrls?: { [name: string]: string };
-    }
-    
-    /**
-     * The angular provider used to configure the behaviour of the `ngTableFilterConfig` service
-     */
-    interface IFilterConfigProvider {
-        $get: IFilterConfig;
-        /**
-         * Reset back to factory defaults the config values that `ngTableFilterConfig` service will use
-         */
-        resetConfigs(): void;
-        /**
-         * Set the config values used by `ngTableFilterConfig` service
-         */
-        setConfig(customConfig: IFilterConfigValues): void;
-    }
-    
-    /**
-     * A key value-pair map where the key is the name of a field in a data row and the value is the definition 
-     * for the template used to render a filter cell in the header of a html table.
-     * Where the value is supplied as a string this should either be url to a html template or an alias to a url registered
-     * using the `ngTableFilterConfigProvider` 
-     * @example
-     * vm.ageFilter = { "age": "number" }
-     * @example
-     * vm.ageFilter = { "age": "my/custom/ageTemplate.html" }
-     * @example
-     * vm.ageFilter = { "age": { id: "number", placeholder: "Age of person"} }
-     */
-    interface IFilterTemplateDefMap {
-        [name: string]: string | IFilterTemplateDef
-    }
-    
-    /**
-     * A fully qualified template definition for a single filter
-     */
-    interface IFilterTemplateDef {
-        /**
-         * A url to a html template of an alias to a url registered using the `ngTableFilterConfigProvider` 
-         */
-        id: string,
-        /**
-         * The text that should be rendered as a prompt to assist the user when entering a filter value
-         */
-        placeholder: string
-    }
-    
-    /**
-     * Exposes configuration values and methods used to return the location of the html
-     * templates used to render the filter row of an ng-table directive
-     */
-    interface IFilterConfig {
-        /**
-         * Readonly copy of the final values used to configure the service.
-         */
-        config: IFilterConfigValues,
-        /**
-         * Return the url of the html filter template for the supplied definition and key.
-         * For more information see the documentation for `IFilterTemplateMap`
-         */
-        getTemplateUrl(filterDef: string | IFilterTemplateDef, filterKey?: string): string,
-        /**
-         * Return the url of the html filter template registered with the alias supplied
-         */
-        getUrlForAlias(aliasName: string, filterKey?: string): string
-    }
-
-    interface InternalTableParams<T> extends NgTableParams<T> {
-        isNullInstance: boolean
-    }
-    
-    /**
-     * A custom object that can be registered with an NgTableParams instance that can be used
-     * to post-process the results (and failures) returned by its `getData` function
-     */
-    interface IInterceptor<T> {
-        response?: <TData>(data: TData, params: NgTableParams<T>) => TData;
-        responseError?: (reason: any, params: NgTableParams<T>) => any;
-    }
-
-    type SelectData = ISelectOption[] | ISelectDataFunc
-
-    interface ISelectOption {
-        id: string | number;
-        title: string;
-    }
-
-    interface ISelectDataFunc {
-        (): ISelectOption[] | ng.IPromise<ISelectOption[]>
-    }    
-        
-    /**
-     * Definition of the constructor function that will construct new instances of `NgTableParams`.
-     * On construction of `NgTableParams` the `ngTableEventsChannel` will fire its `afterCreated` event.
-     */
-    interface ITableParamsConstructor<T> {
-        new (baseParameters?: IParamValues<T>, baseSettings?: ISettings<T>): NgTableParams<T>
-    }
-
-
-    namespace Data {
-
-        type DataResult<T> = T | IDataRowGroup<T>;
-
-        interface IDataRowGroup<T> {
-            data: T[];
-            $hideRows: boolean;
-            value: string;
-        }
-             
-        /**
-         * A default implementation of the getData function that will apply the `filter`, `orderBy` and
-         * paging values from the `NgTableParams` instance supplied to the data array supplied.
-         * 
-         * A call to this function will:
-         * - return the resulting array
-         * - assign the total item count after filtering to the `total` of the `NgTableParams` instance supplied
-         */
-        interface IDefaultGetData<T> {
-            (data: T[], params: NgTableParams<T>): T[];
-            /**
-             * Convenience function that this service will use to apply paging to the data rows.
-             * 
-             * Returns a slice of rows from the `data` array supplied and sets the `NgTableParams.total()`
-             * on the `params` instance supplied to `data.length`
-             */
-            applyPaging(data: T[], params: NgTableParams<T>): T[],
-            /**
-             * Returns a reference to the function that this service will use to filter data rows
-             */
-            getFilterFn(params: NgTableParams<T>): IFilterFunc<T>,
-            /**
-             * Returns a reference to the function that this service will use to sort data rows
-             */
-            getOrderByFn(params?: NgTableParams<T>): void
-        }   
-
-        /**
-         * Allows for the configuration of the ngTableDefaultGetData service.
-         */
-        interface IDefaultGetDataProvider {
-            $get<T>(): IDefaultGetData<T>;
-            /**
-             * The name of a angular filter that knows how to apply the values returned by
-             * `NgTableParams.filter()` to restrict an array of data.
-             * (defaults to the angular `filter` filter service)
-             */
-            filterFilterName: string,
-            /**
-             * The name of a angular filter that knows how to apply the values returned by
-            * `NgTableParams.orderBy()` to sort an array of data.
-            * (defaults to the angular `orderBy` filter service)
-            */
-            sortingFilterName: string
-        }
-
-        interface IGetDataBcShimFunc<T> {
-            (originalFunc: ILegacyGetDataFunc<T>): { (params: NgTableParams<T>): ng.IPromise<T[]> }
-        }
-        
-        /**
-         * Signature of a function that will called whenever NgTable requires to load data rows
-         * into the table.
-         * `params` is the table requesting the data rows
-         */
-        interface IGetDataFunc<T> {
-            (params: NgTableParams<T>): T[] | ng.IPromise<T[]>;
-        }
-
-        interface IGetGroupFunc<T> {
-            (params: NgTableParams<T>): { [name: string]: IDataRowGroup<T>[] }
-        }
-        
-        /**
-         * Variation of the `IGetDataFunc` function signature that allows for flexibility for
-         * the shape of the return value.
-         * Typcially you will use this function signature when you want to configure `NgTableParams` with
-         * interceptors that will return the final data rows array.   
-         */
-        interface IInterceptableGetDataFunc<T> {
-            <TResult>(params: NgTableParams<T>): TResult;
-        }
-
-        interface ILegacyGetDataFunc<T> {
-            ($defer: ng.IDeferred<T[]>, params: NgTableParams<T>): void
-        }
-    }
-
-    namespace Events {
-        interface IEventSelectorFunc {
-            (publisher: NgTableParams<any>): boolean
-        }
-
-        type EventSelector<T> = NgTableParams<T> | IEventSelectorFunc
-
-        interface IDatasetChangedListener<T> {
-            (publisher: NgTableParams<T>, newDataset: T[], oldDataset: T[]): any
-        }
-        interface IAfterCreatedListener {
-            (publisher: NgTableParams<any>): any
-        }
-        interface IAfterReloadDataListener<T> {
-            (publisher: NgTableParams<T>, newData: NgTable.Data.DataResult<T>[], oldData: NgTable.Data.DataResult<T>[]): any
-        }
-        interface IPagesChangedListener {
-            (publisher: NgTableParams<any>, newPages: NgTable.IPageButton[], oldPages: NgTable.IPageButton[]): any
-        }
-        
-        interface IUnregistrationFunc {
-            (): void
-        }
-
-        interface IEventsChannel {
-            /**
-             * Subscribe to receive notification whenever a new `NgTableParams` instance has finished being constructed.
-             * Optionally supply an `eventFilter` to restrict which events that should trigger the `listener` to be called. Supply a
-             * `scope` to have angular automatically unregister the listener when the `scope` is destroyed.
-             * 
-             * @param listener the function that will be called when the event fires
-             * @param scope the angular `$scope` that will limit the lifetime of the event subscription
-             * @param eventFilter a predicate function that should return true to receive the event
-             * @return a unregistration function that when called will unregister the `listener`
-             */
-            onAfterCreated(listener: Events.IAfterCreatedListener, scope: ng.IScope, eventFilter?: Events.IEventSelectorFunc): IUnregistrationFunc;
-            /**
-             * Subscribe to receive notification whenever a new `NgTableParams` instance has finished being constructed.
-             * Optionally supply an `eventFilter` to restrict which events that should trigger the `listener` to be called.
-             * 
-             * @param listener the function that will be called when the event fires
-             * @param eventFilter a predicate function that should return true to receive the event
-             * @return a unregistration function that when called will unregister the `listener`
-             */
-            onAfterCreated(listener: Events.IAfterCreatedListener, eventFilter?: Events.IEventSelectorFunc): IUnregistrationFunc;
-            /**
-             * Subscribe to receive notification whenever the `reload` method of an `NgTableParams` instance has successfully executed
-             * Optionally supply an `eventFilter` to restrict which events that should trigger the `listener` to be called. Supply a
-             * `scope` to have angular automatically unregister the listener when the `scope` is destroyed.
-             * 
-             * @param listener the function that will be called when the event fires
-             * @param scope the angular `$scope` that will limit the lifetime of the event subscription
-             * @param eventFilter either the specific `NgTableParams` instance you want to receive events for or a predicate function that should return true to receive the event
-             * @return a unregistration function that when called will unregister the `listener`
-             */
-            onAfterReloadData<T>(listener: Events.IAfterReloadDataListener<T>, scope: ng.IScope, eventFilter?: Events.EventSelector<T>): IUnregistrationFunc;
-            /**
-             * Subscribe to receive notification whenever the `reload` method of an `NgTableParams` instance has successfully executed
-             * Optionally supply an `eventFilter` to restrict which events that should trigger the `listener` to be called.
-             * 
-             * @param listener the function that will be called when the event fires
-             * @param eventFilter a predicate function that should return true to receive the event
-             * @return a unregistration function that when called will unregister the `listener`
-             */
-            onAfterReloadData<T>(listener: Events.IAfterReloadDataListener<T>, eventFilter?: Events.EventSelector<T>): IUnregistrationFunc;
-            
-            /**
-             * Subscribe to receive notification whenever a new data rows *array* is supplied as a `settings` value to a `NgTableParams` instance.
-             * Optionally supply an `eventFilter` to restrict which events that should trigger the `listener` to be called. Supply a
-             * `scope` to have angular automatically unregister the listener when the `scope` is destroyed.
-             * 
-             * @param listener the function that will be called when the event fires
-             * @param scope the angular `$scope` that will limit the lifetime of the event subscription
-             * @param eventFilter either the specific `NgTableParams` instance you want to receive events for or a predicate function that should return true to receive the event
-             * @return a unregistration function that when called will unregister the `listener`
-             */
-            onDatasetChanged<T>(listener: Events.IDatasetChangedListener<T>, scope: ng.IScope, eventFilter?: Events.EventSelector<T>): IUnregistrationFunc;
-            /**
-             * Subscribe to receive notification whenever a new data rows *array* is supplied as a `settings` value to a `NgTableParams` instance.
-             * Optionally supply an `eventFilter` to restrict which events that should trigger the `listener` to be called.
-             * 
-             * @param listener the function that will be called when the event fires
-             * @param eventFilter either the specific `NgTableParams` instance you want to receive events for or a predicate function that should return true to receive the event
-             * @return a unregistration function that when called will unregister the `listener`
-             */
-            onDatasetChanged<T>(listener: Events.IDatasetChangedListener<T>, eventFilter?: Events.EventSelector<T>): IUnregistrationFunc;
-            
-            /**
-             * Subscribe to receive notification whenever the paging buttons for an `NgTableParams` instance change
-             * Optionally supply an `eventFilter` to restrict which events that should trigger the `listener` to be called. Supply a
-             * `scope` to have angular automatically unregister the listener when the `scope` is destroyed.
-             * 
-             * @param listener the function that will be called when the event fires
-             * @param scope the angular `$scope` that will limit the lifetime of the event subscription
-             * @param eventFilter either the specific `NgTableParams` instance you want to receive events for or a predicate function that should return true to receive the event
-             * @return a unregistration function that when called will unregister the `listener`
-             */
-            onPagesChanged<T>(listener: Events.IPagesChangedListener, scope: ng.IScope, eventFilter?: Events.EventSelector<T>): IUnregistrationFunc;
-            /**
-             * Subscribe to receive notification whenever the paging buttons for an `NgTableParams` instance change
-             * Optionally supply an `eventFilter` to restrict which events that should trigger the `listener` to be called.
-             * 
-             * @param listener the function that will be called when the event fires
-             * @param eventFilter either the specific `NgTableParams` instance you want to receive events for or a predicate function that should return true to receive the event
-             * @return a unregistration function that when called will unregister the `listener`
-             */
-            onPagesChanged<T>(listener: Events.IPagesChangedListener, eventFilter?: Events.EventSelector<T>): IUnregistrationFunc;
-
-            publishAfterCreated<T>(publisher: NgTableParams<T>): void;
-            publishAfterReloadData<T>(publisher: NgTableParams<T>, newData: T[], oldData: T[]): void;
-            publishDatasetChanged<T>(publisher: NgTableParams<T>, newDataset: T[], oldDataset: T[]): void;
-            publishPagesChanged<T>(publisher: NgTableParams<T>, newPages: NgTable.IPageButton[], oldPages: NgTable.IPageButton[]): void;
-        }
-    }
-
-    namespace Columns {
-
-        type ColumnFieldContext = ng.IScope & {
-            $column: IColumnDef;
-            $columns: IColumnDef[];
-        }
-
-        interface IColumnField<T> {
-            (context?: ColumnFieldContext): T;
-            assign($scope: ng.IScope, value: T): void;
-        }
-        
-        /**
-         * The definition of the column within a ngTable.
-         * When using `ng-table` directive a column definition will be parsed from each `td` tag found in the
-         * `tr` data row tag.
-         * 
-         * @example
-         * <tr>
-         *  <td data-title="'Name of User'" filter="{ username: 'text'}" sortable="'username'" />
-         *  <td data-title="'Age of User'" filter="{ age: 'number'}" sortable="'age'" />
-         * </tr>
-         */
-        interface IColumnDef {
-            /**
-             * Custom CSS class that should be added to the `th` tag(s) of this column in the table header
-             * 
-             * To set this on the `td` tag of a html table use the attribute `header-class` or `data-header-class`
-             */
-            class: IColumnField<string>;
-            /**
-             * The `ISelectOption`s that can be used in a html filter template for this colums.
-             */
-            data?: SelectData;
-            /**
-             * The index position of this column within the `$columns` container array 
-             */
-            id: number;
-            /**
-             * The definition of 0 or more html filter templates that should be rendered for this column in
-             * the table header
-             */
-            filter: IColumnField<IFilterTemplateDefMap>;
-            /**
-             * Supplies the `ISelectOption`s that can be used in a html filter template for this colums.
-             * At the creation of the `NgTableParams` this field will be called and the result then assigned
-             * to the `data` field of this column.
-             */
-            filterData: IColumnField<ng.IPromise<SelectData> | SelectData>;
-            /**
-             * The name of the data row field that will be used to group on, or false when this column
-             * does not support grouping
-             */
-            groupable: IColumnField<string | boolean>;
-            /**
-             * The url of a custom html template that should be used to render a table header for this column
-             * 
-             * To set this on the `td` tag for a html table use the attribute `header` or `data-header`
-             */
-            headerTemplateURL: IColumnField<string | boolean>;
-            /**
-             * The text that should be used as a tooltip for this column in the table header
-             */
-            headerTitle: IColumnField<string>;
-            /**
-             * Determines whether this column should be displayed in the table
-             * 
-             * To set this on the `td` tag for a html table use the attribute `ng-if`
-             */
-            show: IColumnField<boolean>;
-            /**
-             * The name of the data row field that will be used to sort on, or false when this column
-             * does not support sorting
-             */
-            sortable: IColumnField<string | boolean>;
-            /**
-             * The title of this column that should be displayed in the table header
-             */
-            title: IColumnField<string>;
-            /**
-             * An alternate column title. Typically this can be used for responsive table layouts
-             * where the titleAlt should be used for small screen sizes
-             */
-            titleAlt: IColumnField<string>;
-        }
-
-        type DynamicTableColField<T> = IDynamicTableColFieldFunc<T> | T;
-
-        interface IDynamicTableColFieldFunc<T> {
-            (context: ColumnFieldContext): T;
-        }
-        
-        /**
-         * The definition of the column supplied to a ngTableDynamic directive.
-         */
-        interface IDynamicTableColDef {
-            /**
-             * Custom CSS class that should be added to the `th` tag(s) of this column in the table header
-             */
-            class?: DynamicTableColField<string>;
-            /**
-             * The definition of 0 or more html filter templates that should be rendered for this column in
-             * the table header
-             */
-            filter?: DynamicTableColField<IFilterTemplateDefMap>;
-            /**
-             * Supplies the `ISelectOption`s that can be used in a html filter template for this colums.
-             * At the creation of the `NgTableParams` this field will be called and the result then assigned
-             * to the `data` field of this column.
-             */
-            filterData?: DynamicTableColField<ng.IPromise<SelectData> | SelectData>;
-            /**
-             * The name of the data row field that will be used to group on, or false when this column
-             * does not support grouping
-             */
-            groupable?: DynamicTableColField<string | boolean>;
-            /**
-             * The url of a custom html template that should be used to render a table header for this column
-             */
-            headerTemplateURL?: DynamicTableColField<string | boolean>;
-            /**
-             * The text that should be used as a tooltip for this column in the table header
-             */
-            headerTitle?: DynamicTableColField<string>;
-            /**
-             * Determines whether this column should be displayed in the table
-             */
-            show?: DynamicTableColField<boolean>;
-            /**
-             * The name of the data row field that will be used to sort on, or false when this column
-             * does not support sorting
-             */
-            sortable?: DynamicTableColField<string|boolean>;
-            /**
-             * The title of this column that should be displayed in the table header
-             */
-            title?: DynamicTableColField<string>;
-            /**
-             * An alternate column title. Typically this can be used for responsive table layouts
-             * where the titleAlt should be used for small screen sizes
-             */
-            titleAlt?: DynamicTableColField<string>;
-        }
-    }
-}
-
diff --git a/ng-table/ng-table-tests.ts b/ng-table/ng-table-tests.ts
deleted file mode 100644
index e8c9c44e4d..0000000000
--- a/ng-table/ng-table-tests.ts
+++ /dev/null
@@ -1,114 +0,0 @@
-
-
-interface IPerson {
-    age: number;
-    name: string;
-}
-
-function printPerson(p: IPerson) {
-    console.log('age: ' + p.age);
-    console.log('name: ' + p.name);
-}
-
-// NgTableParams signature tests
-namespace NgTableParamsTests {
-
-    let initialParams: NgTable.IParamValues<IPerson> = {
-        filter: { name: 'Christian' },
-        sorting: { age: 'asc' }
-    };
-    let settings: NgTable.ISettings<IPerson> = {
-        dataset: [{ age: 1, name: 'Christian' }, { age: 2, name: 'Lee' }, { age: 40, name: 'Christian' }],
-        filterOptions: {
-            filterComparator: true,
-            filterDelay: 100
-        },
-        counts: [10, 20, 50]
-    };
-
-    export let tableParams = new NgTableParams(initialParams, settings);
-
-    // modify parameters
-    tableParams.filter({ name: 'Lee' });
-    tableParams.sorting('age', 'desc');
-    tableParams.count(10);
-    tableParams.group(item => (item.age * 10).toString());
-
-    // modify settings at runtime
-    tableParams.settings({
-        dataset: [{ age: 1, name: 'Brandon' }, { age: 2, name: 'Lee' }]
-    });
-
-    tableParams.reload<IPerson>().then(rows => {
-        rows.forEach(printPerson);
-    });
-}
-
-// Dynamic table column signature tests
-namespace ColumnTests {
-    interface ICustomColFields {
-        field: string;
-    }
-    let dynamicCols: (NgTable.Columns.IDynamicTableColDef & ICustomColFields)[];
-
-    dynamicCols.push({
-        class: () => 'table',
-        field: 'age',
-        filter: { age: 'number' },
-        sortable: true,
-        show: true,
-        title: 'Age of Person',
-        titleAlt: 'Age'
-    });
-}
-
-namespace EventsTests {
-    declare let events: NgTable.Events.IEventsChannel;
-
-    let unregistrationFuncs: NgTable.Events.IUnregistrationFunc[] = [];
-    let x: NgTable.Events.IUnregistrationFunc;
-
-    x = events.onAfterCreated(params => {
-        // do stuff
-    });
-    unregistrationFuncs.push(x);
-
-    x = events.onAfterReloadData((params, newData, oldData) => {
-        newData.forEach(row => {
-            if (isDataGroup(row)) {
-                row.data.forEach(printPerson)
-            } else {
-                printPerson(row);
-            }
-        });
-    }, NgTableParamsTests.tableParams);
-    unregistrationFuncs.push(x);
-
-    x = events.onDatasetChanged((params, newDataset, oldDataset) => {
-        if (newDataset != null) {
-            newDataset.forEach(printPerson);
-        }
-    }, NgTableParamsTests.tableParams);
-    unregistrationFuncs.push(x);
-
-    x = events.onPagesChanged((params, newButtons, oldButtons) => {
-        newButtons.forEach(printPageButton);
-    }, NgTableParamsTests.tableParams);
-    unregistrationFuncs.push(x);
-
-    unregistrationFuncs.forEach(f => {
-        f();
-    });
-
-
-    function printPageButton(btn: NgTable.IPageButton) {
-        console.log('type: ' + btn.type);
-        console.log('number: ' + btn['number']);
-        console.log('current: ' + btn.current);
-        console.log('active: ' + btn.active);
-    }
-
-    function isDataGroup(row: any): row is NgTable.Data.IDataRowGroup<any> {
-        return ('$hideRows' in row);
-    }
-}
\ No newline at end of file
diff --git a/ng-table/tsconfig.json b/ng-table/tsconfig.json
deleted file mode 100644
index c310ef4ece..0000000000
--- a/ng-table/tsconfig.json
+++ /dev/null
@@ -1,19 +0,0 @@
-{
-    "compilerOptions": {
-        "module": "commonjs",
-        "target": "es6",
-        "noImplicitAny": true,
-        "strictNullChecks": false,
-        "baseUrl": "../",
-        "typeRoots": [
-            "../"
-        ],
-        "types": [],
-        "noEmit": true,
-        "forceConsistentCasingInFileNames": true
-    },
-    "files": [
-        "index.d.ts",
-        "ng-table-tests.ts"
-    ]
-}
\ No newline at end of file
diff --git a/notNeededPackages.json b/notNeededPackages.json
index 625683156e..88ede42075 100644
--- a/notNeededPackages.json
+++ b/notNeededPackages.json
@@ -10,6 +10,12 @@
             "typingsPackageName": "moment",
             "sourceRepoURL": "https://github.com/moment/moment",
             "asOfVersion": "2.13.0"
+        },
+        {
+            "libraryName": "ng-table",
+            "typingsPackageName": "ng-table",
+            "sourceRepoURL": "https://github.com/esvit/ng-table",
+            "asOfVersion": "2.0.1"
         }
     ]
 }