@ttsc/factory 0.15.6 → 0.15.7

package/lib/factory/declarations/createExternalModuleReference.js

@@ -3,7 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createExternalModuleReference = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link ExternalModuleReference}.
+ * Create an {@link ExternalModuleReference}: a `require("...")` reference.
+ *
+ * This is the right-hand side of an `import x = require(...)` statement. The
+ * `expression` is the module specifier, normally a string literal, which the
+ * printer wraps in `require(...)`.
+ *
+ * Given a string literal of `"./app"`, the printed reference is:
+ *
+ * ```ts
+ * require("./app");
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param expression The expression.

package/lib/factory/declarations/createExternalModuleReference.js.map

@@ -1 +1 @@
-{"version":3,"file":"createExternalModuleReference.js","sourceRoot":"","sources":["../../../src/factory/declarations/createExternalModuleReference.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;GAMG;AACI,MAAM,6BAA6B,GAAG,CAC3C,UAAsB,EACG,EAAE,CAAC,IAAA,WAAI,EAAC,yBAAyB,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;AAFjE,QAAA,6BAA6B,GAA7B,6BAA6B,CAEoC"}
+{"version":3,"file":"createExternalModuleReference.js","sourceRoot":"","sources":["../../../src/factory/declarations/createExternalModuleReference.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;;;;;;;;;GAgBG;AACI,MAAM,6BAA6B,GAAG,CAC3C,UAAsB,EACG,EAAE,CAAC,IAAA,WAAI,EAAC,yBAAyB,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;AAFjE,QAAA,6BAA6B,GAA7B,6BAA6B,CAEoC"}

package/lib/factory/declarations/createExternalModuleReference.mjs

@@ -2,7 +2,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createExternalModuleReference = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link ExternalModuleReference}.
+ * Create an {@link ExternalModuleReference}: a `require("...")` reference.
+ *
+ * This is the right-hand side of an `import x = require(...)` statement. The
+ * `expression` is the module specifier, normally a string literal, which the
+ * printer wraps in `require(...)`.
+ *
+ * Given a string literal of `"./app"`, the printed reference is:
+ *
+ * ```ts
+ * require("./app");
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param expression The expression.

package/lib/factory/declarations/createExternalModuleReference.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createExternalModuleReference.mjs","sources":["createExternalModuleReference.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createExternalModuleReference = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ExternalModuleReference}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @returns The created {@link ExternalModuleReference}.\n */\nconst createExternalModuleReference = (expression) => (0, make_1.make)(\"ExternalModuleReference\", { expression });\nexports.createExternalModuleReference = createExternalModuleReference;\n//# sourceMappingURL=createExternalModuleReference.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,6BAA6B,GAAG,MAAM;AAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,6BAA6B,GAAG,CAAC,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,yBAAyB,EAAE,EAAE,UAAU,EAAE,CAAC;AACjH,OAAO,CAAC,6BAA6B,GAAG,6BAA6B"}
+{"version":3,"file":"createExternalModuleReference.mjs","sources":["createExternalModuleReference.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createExternalModuleReference = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link ExternalModuleReference}: a `require(\"...\")` reference.\n *\n * This is the right-hand side of an `import x = require(...)` statement. The\n * `expression` is the module specifier, normally a string literal, which the\n * printer wraps in `require(...)`.\n *\n * Given a string literal of `\"./app\"`, the printed reference is:\n *\n * ```ts\n * require(\"./app\");\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @returns The created {@link ExternalModuleReference}.\n */\nconst createExternalModuleReference = (expression) => (0, make_1.make)(\"ExternalModuleReference\", { expression });\nexports.createExternalModuleReference = createExternalModuleReference;\n//# sourceMappingURL=createExternalModuleReference.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,6BAA6B,GAAG,MAAM;AAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,6BAA6B,GAAG,CAAC,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,yBAAyB,EAAE,EAAE,UAAU,EAAE,CAAC;AACjH,OAAO,CAAC,6BAA6B,GAAG,6BAA6B"}

package/lib/factory/declarations/createFunctionDeclaration.d.ts

@@ -1,6 +1,26 @@
 import type { Block, FunctionDeclaration, Identifier, ModifierLike, ParameterDeclaration, Token, TypeNode, TypeParameterDeclaration } from "../../ast";
 /**
- * Create a {@link FunctionDeclaration}.
+ * Create a {@link FunctionDeclaration}: a `function f(...) { ... }`.
+ *
+ * The `modifiers` precede the `function` keyword, so an `export` modifier
+ * prints `export function` and an `async` modifier prints `async function`. The
+ * `asteriskToken`, when present, marks the function as a generator
+ * (`function*`). The `name` may be omitted for the anonymous form used by
+ * `export default`, and `typeParameters` add the generic `<...>` list.
+ *
+ * The `parameters` print inside the parentheses, the optional return `type`
+ * follows after a colon, and the `body` block holds the statements, indented
+ * one per line.
+ *
+ * Given an `export` modifier, the name `add`, two `number` parameters `a` and
+ * `b`, a `number` return type, and a body returning `a + b`, the printed
+ * declaration is:
+ *
+ * ```ts
+ * export function add(a: number, b: number): number {
+ *   return a + b;
+ * }
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param modifiers The leading modifiers and decorators, if any.

package/lib/factory/declarations/createFunctionDeclaration.js

@@ -4,7 +4,27 @@ exports.createFunctionDeclaration = void 0;
 const asName_1 = require("../internal/asName");
 const make_1 = require("../internal/make");
 /**
- * Create a {@link FunctionDeclaration}.
+ * Create a {@link FunctionDeclaration}: a `function f(...) { ... }`.
+ *
+ * The `modifiers` precede the `function` keyword, so an `export` modifier
+ * prints `export function` and an `async` modifier prints `async function`. The
+ * `asteriskToken`, when present, marks the function as a generator
+ * (`function*`). The `name` may be omitted for the anonymous form used by
+ * `export default`, and `typeParameters` add the generic `<...>` list.
+ *
+ * The `parameters` print inside the parentheses, the optional return `type`
+ * follows after a colon, and the `body` block holds the statements, indented
+ * one per line.
+ *
+ * Given an `export` modifier, the name `add`, two `number` parameters `a` and
+ * `b`, a `number` return type, and a body returning `a + b`, the printed
+ * declaration is:
+ *
+ * ```ts
+ * export function add(a: number, b: number): number {
+ *   return a + b;
+ * }
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param modifiers The leading modifiers and decorators, if any.

package/lib/factory/declarations/createFunctionDeclaration.js.map

@@ -1 +1 @@
-{"version":3,"file":"createFunctionDeclaration.js","sourceRoot":"","sources":["../../../src/factory/declarations/createFunctionDeclaration.ts"],"names":[],"mappings":";;;AAUA,+CAA4C;AAC5C,2CAAwC;AAExC;;;;;;;;;;;;GAYG;AACI,MAAM,yBAAyB,GAAG,CACvC,SAA8C,EAC9C,aAAgC,EAChC,IAAqC,EACrC,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,EAC1B,IAAuB,EACF,EAAE,CACvB,IAAA,WAAI,EAAC,qBAAqB,EAAE;IAC1B,SAAS;IACT,aAAa;IACb,IAAI,EAAE,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAA,eAAM,EAAC,IAAI,CAAC;IACnD,cAAc;IACd,UAAU;IACV,IAAI;IACJ,IAAI;CACL,CAAC,CAAC;AAjBQ,QAAA,yBAAyB,GAAzB,yBAAyB,CAiBjC"}
+{"version":3,"file":"createFunctionDeclaration.js","sourceRoot":"","sources":["../../../src/factory/declarations/createFunctionDeclaration.ts"],"names":[],"mappings":";;;AAUA,+CAA4C;AAC5C,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACI,MAAM,yBAAyB,GAAG,CACvC,SAA8C,EAC9C,aAAgC,EAChC,IAAqC,EACrC,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,EAC1B,IAAuB,EACF,EAAE,CACvB,IAAA,WAAI,EAAC,qBAAqB,EAAE;IAC1B,SAAS;IACT,aAAa;IACb,IAAI,EAAE,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAA,eAAM,EAAC,IAAI,CAAC;IACnD,cAAc;IACd,UAAU;IACV,IAAI;IACJ,IAAI;CACL,CAAC,CAAC;AAjBQ,QAAA,yBAAyB,GAAzB,yBAAyB,CAiBjC"}

package/lib/factory/declarations/createFunctionDeclaration.mjs

@@ -3,7 +3,27 @@ exports.createFunctionDeclaration = void 0;
 const asName_1 = require("../internal/asName");
 const make_1 = require("../internal/make");
 /**
- * Create a {@link FunctionDeclaration}.
+ * Create a {@link FunctionDeclaration}: a `function f(...) { ... }`.
+ *
+ * The `modifiers` precede the `function` keyword, so an `export` modifier
+ * prints `export function` and an `async` modifier prints `async function`. The
+ * `asteriskToken`, when present, marks the function as a generator
+ * (`function*`). The `name` may be omitted for the anonymous form used by
+ * `export default`, and `typeParameters` add the generic `<...>` list.
+ *
+ * The `parameters` print inside the parentheses, the optional return `type`
+ * follows after a colon, and the `body` block holds the statements, indented
+ * one per line.
+ *
+ * Given an `export` modifier, the name `add`, two `number` parameters `a` and
+ * `b`, a `number` return type, and a body returning `a + b`, the printed
+ * declaration is:
+ *
+ * ```ts
+ * export function add(a: number, b: number): number {
+ *   return a + b;
+ * }
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param modifiers The leading modifiers and decorators, if any.

package/lib/factory/declarations/createFunctionDeclaration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createFunctionDeclaration.mjs","sources":["createFunctionDeclaration.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createFunctionDeclaration = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link FunctionDeclaration}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param asteriskToken The generator marker (`*`), if any.\n * @param name The name.\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The type.\n * @param body The body.\n * @returns The created {@link FunctionDeclaration}.\n */\nconst createFunctionDeclaration = (modifiers, asteriskToken, name, typeParameters, parameters, type, body) => (0, make_1.make)(\"FunctionDeclaration\", {\n    modifiers,\n    asteriskToken,\n    name: name === undefined ? undefined : (0, asName_1.asName)(name),\n    typeParameters,\n    parameters,\n    type,\n    body,\n});\nexports.createFunctionDeclaration = createFunctionDeclaration;\n//# sourceMappingURL=createFunctionDeclaration.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,yBAAyB,GAAG,MAAM;AAC1C,MAAM,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC;AAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,yBAAyB,GAAG,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,qBAAqB,EAAE;AACtJ,IAAI,SAAS;AACb,IAAI,aAAa;AACjB,IAAI,IAAI,EAAE,IAAI,KAAK,SAAS,GAAG,SAAS,GAAG,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;AACrE,IAAI,cAAc;AAClB,IAAI,UAAU;AACd,IAAI,IAAI;AACR,IAAI,IAAI;AACR,CAAC,CAAC;AACF,OAAO,CAAC,yBAAyB,GAAG,yBAAyB"}
+{"version":3,"file":"createFunctionDeclaration.mjs","sources":["createFunctionDeclaration.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createFunctionDeclaration = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link FunctionDeclaration}: a `function f(...) { ... }`.\n *\n * The `modifiers` precede the `function` keyword, so an `export` modifier\n * prints `export function` and an `async` modifier prints `async function`. The\n * `asteriskToken`, when present, marks the function as a generator\n * (`function*`). The `name` may be omitted for the anonymous form used by\n * `export default`, and `typeParameters` add the generic `<...>` list.\n *\n * The `parameters` print inside the parentheses, the optional return `type`\n * follows after a colon, and the `body` block holds the statements, indented\n * one per line.\n *\n * Given an `export` modifier, the name `add`, two `number` parameters `a` and\n * `b`, a `number` return type, and a body returning `a + b`, the printed\n * declaration is:\n *\n * ```ts\n * export function add(a: number, b: number): number {\n *   return a + b;\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param asteriskToken The generator marker (`*`), if any.\n * @param name The name.\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The type.\n * @param body The body.\n * @returns The created {@link FunctionDeclaration}.\n */\nconst createFunctionDeclaration = (modifiers, asteriskToken, name, typeParameters, parameters, type, body) => (0, make_1.make)(\"FunctionDeclaration\", {\n    modifiers,\n    asteriskToken,\n    name: name === undefined ? undefined : (0, asName_1.asName)(name),\n    typeParameters,\n    parameters,\n    type,\n    body,\n});\nexports.createFunctionDeclaration = createFunctionDeclaration;\n//# sourceMappingURL=createFunctionDeclaration.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,yBAAyB,GAAG,MAAM;AAC1C,MAAM,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC;AAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,yBAAyB,GAAG,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,qBAAqB,EAAE;AACtJ,IAAI,SAAS;AACb,IAAI,aAAa;AACjB,IAAI,IAAI,EAAE,IAAI,KAAK,SAAS,GAAG,SAAS,GAAG,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;AACrE,IAAI,cAAc;AAClB,IAAI,UAAU;AACd,IAAI,IAAI;AACR,IAAI,IAAI;AACR,CAAC,CAAC;AACF,OAAO,CAAC,yBAAyB,GAAG,yBAAyB"}

package/lib/factory/declarations/createGetAccessorDeclaration.d.ts

@@ -1,6 +1,21 @@
 import type { Block, GetAccessorDeclaration, ModifierLike, ParameterDeclaration, PropertyName, TypeNode } from "../../ast";
 /**
- * Create a {@link GetAccessorDeclaration}.
+ * Create a {@link GetAccessorDeclaration}: a `get x() { ... }` accessor.
+ *
+ * The `modifiers` precede the `get` keyword, so a `public` modifier prints
+ * `public get`. The `name` is the accessor key. A getter takes no value
+ * parameter, so `parameters` is normally empty; the optional `type` is the
+ * return type printed after the colon, and the `body` block holds the
+ * statements, indented one per line.
+ *
+ * Given a `public` modifier, the name `value`, a `number` return type, and a
+ * body returning `this._value`, the printed accessor is:
+ *
+ * ```ts
+ * public get value(): number {
+ *   return this._value;
+ * }
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param modifiers The leading modifiers and decorators, if any.

package/lib/factory/declarations/createGetAccessorDeclaration.js

@@ -4,7 +4,22 @@ exports.createGetAccessorDeclaration = void 0;
 const asPropertyName_1 = require("../internal/asPropertyName");
 const make_1 = require("../internal/make");
 /**
- * Create a {@link GetAccessorDeclaration}.
+ * Create a {@link GetAccessorDeclaration}: a `get x() { ... }` accessor.
+ *
+ * The `modifiers` precede the `get` keyword, so a `public` modifier prints
+ * `public get`. The `name` is the accessor key. A getter takes no value
+ * parameter, so `parameters` is normally empty; the optional `type` is the
+ * return type printed after the colon, and the `body` block holds the
+ * statements, indented one per line.
+ *
+ * Given a `public` modifier, the name `value`, a `number` return type, and a
+ * body returning `this._value`, the printed accessor is:
+ *
+ * ```ts
+ * public get value(): number {
+ *   return this._value;
+ * }
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param modifiers The leading modifiers and decorators, if any.

package/lib/factory/declarations/createGetAccessorDeclaration.js.map

@@ -1 +1 @@
-{"version":3,"file":"createGetAccessorDeclaration.js","sourceRoot":"","sources":["../../../src/factory/declarations/createGetAccessorDeclaration.ts"],"names":[],"mappings":";;;AAQA,+DAA4D;AAC5D,2CAAwC;AAExC;;;;;;;;;;GAUG;AACI,MAAM,4BAA4B,GAAG,CAC1C,SAA8C,EAC9C,IAA2B,EAC3B,UAA2C,EAC3C,IAA0B,EAC1B,IAAuB,EACC,EAAE,CAC1B,IAAA,WAAI,EAAC,wBAAwB,EAAE;IAC7B,SAAS;IACT,IAAI,EAAE,IAAA,+BAAc,EAAC,IAAI,CAAC;IAC1B,UAAU;IACV,IAAI;IACJ,IAAI;CACL,CAAC,CAAC;AAbQ,QAAA,4BAA4B,GAA5B,4BAA4B,CAapC"}
+{"version":3,"file":"createGetAccessorDeclaration.js","sourceRoot":"","sources":["../../../src/factory/declarations/createGetAccessorDeclaration.ts"],"names":[],"mappings":";;;AAQA,+DAA4D;AAC5D,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACI,MAAM,4BAA4B,GAAG,CAC1C,SAA8C,EAC9C,IAA2B,EAC3B,UAA2C,EAC3C,IAA0B,EAC1B,IAAuB,EACC,EAAE,CAC1B,IAAA,WAAI,EAAC,wBAAwB,EAAE;IAC7B,SAAS;IACT,IAAI,EAAE,IAAA,+BAAc,EAAC,IAAI,CAAC;IAC1B,UAAU;IACV,IAAI;IACJ,IAAI;CACL,CAAC,CAAC;AAbQ,QAAA,4BAA4B,GAA5B,4BAA4B,CAapC"}

package/lib/factory/declarations/createGetAccessorDeclaration.mjs

@@ -3,7 +3,22 @@ exports.createGetAccessorDeclaration = void 0;
 const asPropertyName_1 = require("../internal/asPropertyName");
 const make_1 = require("../internal/make");
 /**
- * Create a {@link GetAccessorDeclaration}.
+ * Create a {@link GetAccessorDeclaration}: a `get x() { ... }` accessor.
+ *
+ * The `modifiers` precede the `get` keyword, so a `public` modifier prints
+ * `public get`. The `name` is the accessor key. A getter takes no value
+ * parameter, so `parameters` is normally empty; the optional `type` is the
+ * return type printed after the colon, and the `body` block holds the
+ * statements, indented one per line.
+ *
+ * Given a `public` modifier, the name `value`, a `number` return type, and a
+ * body returning `this._value`, the printed accessor is:
+ *
+ * ```ts
+ * public get value(): number {
+ *   return this._value;
+ * }
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param modifiers The leading modifiers and decorators, if any.

package/lib/factory/declarations/createGetAccessorDeclaration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createGetAccessorDeclaration.mjs","sources":["createGetAccessorDeclaration.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createGetAccessorDeclaration = void 0;\nconst asPropertyName_1 = require(\"../internal/asPropertyName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link GetAccessorDeclaration}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The name.\n * @param parameters The parameters.\n * @param type The type.\n * @param body The body.\n * @returns The created {@link GetAccessorDeclaration}.\n */\nconst createGetAccessorDeclaration = (modifiers, name, parameters, type, body) => (0, make_1.make)(\"GetAccessorDeclaration\", {\n    modifiers,\n    name: (0, asPropertyName_1.asPropertyName)(name),\n    parameters,\n    type,\n    body,\n});\nexports.createGetAccessorDeclaration = createGetAccessorDeclaration;\n//# sourceMappingURL=createGetAccessorDeclaration.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,4BAA4B,GAAG,MAAM;AAC7C,MAAM,gBAAgB,GAAG,OAAO,CAAC,4BAA4B,CAAC;AAC9D,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,4BAA4B,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,wBAAwB,EAAE;AAC7H,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,IAAI,gBAAgB,CAAC,cAAc,EAAE,IAAI,CAAC;AACpD,IAAI,UAAU;AACd,IAAI,IAAI;AACR,IAAI,IAAI;AACR,CAAC,CAAC;AACF,OAAO,CAAC,4BAA4B,GAAG,4BAA4B"}
+{"version":3,"file":"createGetAccessorDeclaration.mjs","sources":["createGetAccessorDeclaration.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createGetAccessorDeclaration = void 0;\nconst asPropertyName_1 = require(\"../internal/asPropertyName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link GetAccessorDeclaration}: a `get x() { ... }` accessor.\n *\n * The `modifiers` precede the `get` keyword, so a `public` modifier prints\n * `public get`. The `name` is the accessor key. A getter takes no value\n * parameter, so `parameters` is normally empty; the optional `type` is the\n * return type printed after the colon, and the `body` block holds the\n * statements, indented one per line.\n *\n * Given a `public` modifier, the name `value`, a `number` return type, and a\n * body returning `this._value`, the printed accessor is:\n *\n * ```ts\n * public get value(): number {\n *   return this._value;\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The name.\n * @param parameters The parameters.\n * @param type The type.\n * @param body The body.\n * @returns The created {@link GetAccessorDeclaration}.\n */\nconst createGetAccessorDeclaration = (modifiers, name, parameters, type, body) => (0, make_1.make)(\"GetAccessorDeclaration\", {\n    modifiers,\n    name: (0, asPropertyName_1.asPropertyName)(name),\n    parameters,\n    type,\n    body,\n});\nexports.createGetAccessorDeclaration = createGetAccessorDeclaration;\n//# sourceMappingURL=createGetAccessorDeclaration.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,4BAA4B,GAAG,MAAM;AAC7C,MAAM,gBAAgB,GAAG,OAAO,CAAC,4BAA4B,CAAC;AAC9D,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,4BAA4B,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,wBAAwB,EAAE;AAC7H,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,IAAI,gBAAgB,CAAC,cAAc,EAAE,IAAI,CAAC;AACpD,IAAI,UAAU;AACd,IAAI,IAAI;AACR,IAAI,IAAI;AACR,CAAC,CAAC;AACF,OAAO,CAAC,4BAA4B,GAAG,4BAA4B"}

package/lib/factory/declarations/createImportEqualsDeclaration.d.ts

@@ -1,12 +1,25 @@
 import type { Identifier, ImportEqualsDeclaration, ModifierLike, ModuleReference } from "../../ast";
 /**
- * Create a {@link ImportEqualsDeclaration}.
+ * Create an {@link ImportEqualsDeclaration}: an `import x = ...` statement.
+ *
+ * The `modifiers` precede the `import` keyword, so an `export` modifier prints
+ * `export import`. When `isTypeOnly` is true the printer inserts the `type`
+ * keyword to make it a type-only import. The `name` is the local binding, and
+ * `moduleReference` is the right-hand side, either an external module reference
+ * such as `require("...")` or an entity name for an aliased namespace.
+ *
+ * Given an `export` modifier, `isTypeOnly` of false, the name `app`, and a
+ * `require("./app")` module reference, the printed statement is:
+ *
+ * ```ts
+ * export import app = require("./app");
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
- * @param modifiers The modifiers.
- * @param isTypeOnly The isTypeOnly.
- * @param name The name.
- * @param moduleReference The moduleReference.
+ * @param modifiers The leading modifiers, if any.
+ * @param isTypeOnly Whether the import is type-only (`import type`).
+ * @param name The local binding name.
+ * @param moduleReference The right-hand side module or entity reference.
  * @returns The created {@link ImportEqualsDeclaration}.
  */
 export declare const createImportEqualsDeclaration: (modifiers: readonly ModifierLike[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference) => ImportEqualsDeclaration;

package/lib/factory/declarations/createImportEqualsDeclaration.js

@@ -4,13 +4,26 @@ exports.createImportEqualsDeclaration = void 0;
 const asName_1 = require("../internal/asName");
 const make_1 = require("../internal/make");
 /**
- * Create a {@link ImportEqualsDeclaration}.
+ * Create an {@link ImportEqualsDeclaration}: an `import x = ...` statement.
+ *
+ * The `modifiers` precede the `import` keyword, so an `export` modifier prints
+ * `export import`. When `isTypeOnly` is true the printer inserts the `type`
+ * keyword to make it a type-only import. The `name` is the local binding, and
+ * `moduleReference` is the right-hand side, either an external module reference
+ * such as `require("...")` or an entity name for an aliased namespace.
+ *
+ * Given an `export` modifier, `isTypeOnly` of false, the name `app`, and a
+ * `require("./app")` module reference, the printed statement is:
+ *
+ * ```ts
+ * export import app = require("./app");
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
- * @param modifiers The modifiers.
- * @param isTypeOnly The isTypeOnly.
- * @param name The name.
- * @param moduleReference The moduleReference.
+ * @param modifiers The leading modifiers, if any.
+ * @param isTypeOnly Whether the import is type-only (`import type`).
+ * @param name The local binding name.
+ * @param moduleReference The right-hand side module or entity reference.
  * @returns The created {@link ImportEqualsDeclaration}.
  */
 const createImportEqualsDeclaration = (modifiers, isTypeOnly, name, moduleReference) => (0, make_1.make)("ImportEqualsDeclaration", {

package/lib/factory/declarations/createImportEqualsDeclaration.js.map

@@ -1 +1 @@
-{"version":3,"file":"createImportEqualsDeclaration.js","sourceRoot":"","sources":["../../../src/factory/declarations/createImportEqualsDeclaration.ts"],"names":[],"mappings":";;;AAMA,+CAA4C;AAC5C,2CAAwC;AAExC;;;;;;;;;GASG;AACI,MAAM,6BAA6B,GAAG,CAC3C,SAA8C,EAC9C,UAAmB,EACnB,IAAyB,EACzB,eAAgC,EACP,EAAE,CAC3B,IAAA,WAAI,EAAC,yBAAyB,EAAE;IAC9B,SAAS;IACT,UAAU;IACV,IAAI,EAAE,IAAA,eAAM,EAAC,IAAI,CAAC;IAClB,eAAe;CAChB,CAAC,CAAC;AAXQ,QAAA,6BAA6B,GAA7B,6BAA6B,CAWrC"}
+{"version":3,"file":"createImportEqualsDeclaration.js","sourceRoot":"","sources":["../../../src/factory/declarations/createImportEqualsDeclaration.ts"],"names":[],"mappings":";;;AAMA,+CAA4C;AAC5C,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACI,MAAM,6BAA6B,GAAG,CAC3C,SAA8C,EAC9C,UAAmB,EACnB,IAAyB,EACzB,eAAgC,EACP,EAAE,CAC3B,IAAA,WAAI,EAAC,yBAAyB,EAAE;IAC9B,SAAS;IACT,UAAU;IACV,IAAI,EAAE,IAAA,eAAM,EAAC,IAAI,CAAC;IAClB,eAAe;CAChB,CAAC,CAAC;AAXQ,QAAA,6BAA6B,GAA7B,6BAA6B,CAWrC"}

package/lib/factory/declarations/createImportEqualsDeclaration.mjs

@@ -3,13 +3,26 @@ exports.createImportEqualsDeclaration = void 0;
 const asName_1 = require("../internal/asName");
 const make_1 = require("../internal/make");
 /**
- * Create a {@link ImportEqualsDeclaration}.
+ * Create an {@link ImportEqualsDeclaration}: an `import x = ...` statement.
+ *
+ * The `modifiers` precede the `import` keyword, so an `export` modifier prints
+ * `export import`. When `isTypeOnly` is true the printer inserts the `type`
+ * keyword to make it a type-only import. The `name` is the local binding, and
+ * `moduleReference` is the right-hand side, either an external module reference
+ * such as `require("...")` or an entity name for an aliased namespace.
+ *
+ * Given an `export` modifier, `isTypeOnly` of false, the name `app`, and a
+ * `require("./app")` module reference, the printed statement is:
+ *
+ * ```ts
+ * export import app = require("./app");
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
- * @param modifiers The modifiers.
- * @param isTypeOnly The isTypeOnly.
- * @param name The name.
- * @param moduleReference The moduleReference.
+ * @param modifiers The leading modifiers, if any.
+ * @param isTypeOnly Whether the import is type-only (`import type`).
+ * @param name The local binding name.
+ * @param moduleReference The right-hand side module or entity reference.
  * @returns The created {@link ImportEqualsDeclaration}.
  */
 const createImportEqualsDeclaration = (modifiers, isTypeOnly, name, moduleReference) => (0, make_1.make)("ImportEqualsDeclaration", {

package/lib/factory/declarations/createImportEqualsDeclaration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createImportEqualsDeclaration.mjs","sources":["createImportEqualsDeclaration.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createImportEqualsDeclaration = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ImportEqualsDeclaration}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The modifiers.\n * @param isTypeOnly The isTypeOnly.\n * @param name The name.\n * @param moduleReference The moduleReference.\n * @returns The created {@link ImportEqualsDeclaration}.\n */\nconst createImportEqualsDeclaration = (modifiers, isTypeOnly, name, moduleReference) => (0, make_1.make)(\"ImportEqualsDeclaration\", {\n    modifiers,\n    isTypeOnly,\n    name: (0, asName_1.asName)(name),\n    moduleReference,\n});\nexports.createImportEqualsDeclaration = createImportEqualsDeclaration;\n//# sourceMappingURL=createImportEqualsDeclaration.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,6BAA6B,GAAG,MAAM;AAC9C,MAAM,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC;AAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,6BAA6B,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,yBAAyB,EAAE;AACpI,IAAI,SAAS;AACb,IAAI,UAAU;AACd,IAAI,IAAI,EAAE,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,IAAI,eAAe;AACnB,CAAC,CAAC;AACF,OAAO,CAAC,6BAA6B,GAAG,6BAA6B"}
+{"version":3,"file":"createImportEqualsDeclaration.mjs","sources":["createImportEqualsDeclaration.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createImportEqualsDeclaration = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link ImportEqualsDeclaration}: an `import x = ...` statement.\n *\n * The `modifiers` precede the `import` keyword, so an `export` modifier prints\n * `export import`. When `isTypeOnly` is true the printer inserts the `type`\n * keyword to make it a type-only import. The `name` is the local binding, and\n * `moduleReference` is the right-hand side, either an external module reference\n * such as `require(\"...\")` or an entity name for an aliased namespace.\n *\n * Given an `export` modifier, `isTypeOnly` of false, the name `app`, and a\n * `require(\"./app\")` module reference, the printed statement is:\n *\n * ```ts\n * export import app = require(\"./app\");\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers, if any.\n * @param isTypeOnly Whether the import is type-only (`import type`).\n * @param name The local binding name.\n * @param moduleReference The right-hand side module or entity reference.\n * @returns The created {@link ImportEqualsDeclaration}.\n */\nconst createImportEqualsDeclaration = (modifiers, isTypeOnly, name, moduleReference) => (0, make_1.make)(\"ImportEqualsDeclaration\", {\n    modifiers,\n    isTypeOnly,\n    name: (0, asName_1.asName)(name),\n    moduleReference,\n});\nexports.createImportEqualsDeclaration = createImportEqualsDeclaration;\n//# sourceMappingURL=createImportEqualsDeclaration.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,6BAA6B,GAAG,MAAM;AAC9C,MAAM,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC;AAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,6BAA6B,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,yBAAyB,EAAE;AACpI,IAAI,SAAS;AACb,IAAI,UAAU;AACd,IAAI,IAAI,EAAE,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,IAAI,eAAe;AACnB,CAAC,CAAC;AACF,OAAO,CAAC,6BAA6B,GAAG,6BAA6B"}

package/lib/factory/declarations/createInterfaceDeclaration.d.ts

@@ -1,6 +1,22 @@
 import type { HeritageClause, Identifier, InterfaceDeclaration, ModifierLike, TypeElement, TypeParameterDeclaration } from "../../ast";
 /**
- * Create a {@link InterfaceDeclaration}.
+ * Create an {@link InterfaceDeclaration}: an `interface X { ... }`.
+ *
+ * The `modifiers` are printed in front of the `interface` keyword, so passing
+ * an `export` modifier yields `export interface`. The `name` accepts a plain
+ * string or a prebuilt identifier, and `typeParameters` add the `<...>` generic
+ * list when present. The `heritageClauses` carry the `extends` clauses, while
+ * `members` become the body. The printer wraps the members in a brace block,
+ * one member per line, and emits an empty `{}` when there are none.
+ *
+ * Given an `export` modifier, the name `IBox`, and a single `value: number`
+ * member, the printed declaration is:
+ *
+ * ```ts
+ * export interface IBox {
+ *   value: number;
+ * }
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param modifiers The leading modifiers and decorators, if any.

package/lib/factory/declarations/createInterfaceDeclaration.js

@@ -4,7 +4,23 @@ exports.createInterfaceDeclaration = void 0;
 const asName_1 = require("../internal/asName");
 const make_1 = require("../internal/make");
 /**
- * Create a {@link InterfaceDeclaration}.
+ * Create an {@link InterfaceDeclaration}: an `interface X { ... }`.
+ *
+ * The `modifiers` are printed in front of the `interface` keyword, so passing
+ * an `export` modifier yields `export interface`. The `name` accepts a plain
+ * string or a prebuilt identifier, and `typeParameters` add the `<...>` generic
+ * list when present. The `heritageClauses` carry the `extends` clauses, while
+ * `members` become the body. The printer wraps the members in a brace block,
+ * one member per line, and emits an empty `{}` when there are none.
+ *
+ * Given an `export` modifier, the name `IBox`, and a single `value: number`
+ * member, the printed declaration is:
+ *
+ * ```ts
+ * export interface IBox {
+ *   value: number;
+ * }
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param modifiers The leading modifiers and decorators, if any.

package/lib/factory/declarations/createInterfaceDeclaration.js.map

@@ -1 +1 @@
-{"version":3,"file":"createInterfaceDeclaration.js","sourceRoot":"","sources":["../../../src/factory/declarations/createInterfaceDeclaration.ts"],"names":[],"mappings":";;;AAQA,+CAA4C;AAC5C,2CAAwC;AAExC;;;;;;;;;;GAUG;AACI,MAAM,0BAA0B,GAAG,CACxC,SAA8C,EAC9C,IAAyB,EACzB,cAA+D,EAC/D,eAAsD,EACtD,OAA+B,EACT,EAAE,CACxB,IAAA,WAAI,EAAC,sBAAsB,EAAE;IAC3B,SAAS;IACT,IAAI,EAAE,IAAA,eAAM,EAAC,IAAI,CAAC;IAClB,cAAc;IACd,eAAe;IACf,OAAO;CACR,CAAC,CAAC;AAbQ,QAAA,0BAA0B,GAA1B,0BAA0B,CAalC"}
+{"version":3,"file":"createInterfaceDeclaration.js","sourceRoot":"","sources":["../../../src/factory/declarations/createInterfaceDeclaration.ts"],"names":[],"mappings":";;;AAQA,+CAA4C;AAC5C,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACI,MAAM,0BAA0B,GAAG,CACxC,SAA8C,EAC9C,IAAyB,EACzB,cAA+D,EAC/D,eAAsD,EACtD,OAA+B,EACT,EAAE,CACxB,IAAA,WAAI,EAAC,sBAAsB,EAAE;IAC3B,SAAS;IACT,IAAI,EAAE,IAAA,eAAM,EAAC,IAAI,CAAC;IAClB,cAAc;IACd,eAAe;IACf,OAAO;CACR,CAAC,CAAC;AAbQ,QAAA,0BAA0B,GAA1B,0BAA0B,CAalC"}

package/lib/factory/declarations/createInterfaceDeclaration.mjs

@@ -3,7 +3,23 @@ exports.createInterfaceDeclaration = void 0;
 const asName_1 = require("../internal/asName");
 const make_1 = require("../internal/make");
 /**
- * Create a {@link InterfaceDeclaration}.
+ * Create an {@link InterfaceDeclaration}: an `interface X { ... }`.
+ *
+ * The `modifiers` are printed in front of the `interface` keyword, so passing
+ * an `export` modifier yields `export interface`. The `name` accepts a plain
+ * string or a prebuilt identifier, and `typeParameters` add the `<...>` generic
+ * list when present. The `heritageClauses` carry the `extends` clauses, while
+ * `members` become the body. The printer wraps the members in a brace block,
+ * one member per line, and emits an empty `{}` when there are none.
+ *
+ * Given an `export` modifier, the name `IBox`, and a single `value: number`
+ * member, the printed declaration is:
+ *
+ * ```ts
+ * export interface IBox {
+ *   value: number;
+ * }
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param modifiers The leading modifiers and decorators, if any.

package/lib/factory/declarations/createInterfaceDeclaration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createInterfaceDeclaration.mjs","sources":["createInterfaceDeclaration.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createInterfaceDeclaration = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link InterfaceDeclaration}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The name.\n * @param typeParameters The generic type parameters, if any.\n * @param heritageClauses The `extends` / `implements` clauses, if any.\n * @param members The members.\n * @returns The created {@link InterfaceDeclaration}.\n */\nconst createInterfaceDeclaration = (modifiers, name, typeParameters, heritageClauses, members) => (0, make_1.make)(\"InterfaceDeclaration\", {\n    modifiers,\n    name: (0, asName_1.asName)(name),\n    typeParameters,\n    heritageClauses,\n    members,\n});\nexports.createInterfaceDeclaration = createInterfaceDeclaration;\n//# sourceMappingURL=createInterfaceDeclaration.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,0BAA0B,GAAG,MAAM;AAC3C,MAAM,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC;AAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,0BAA0B,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,sBAAsB,EAAE;AAC3I,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,IAAI,cAAc;AAClB,IAAI,eAAe;AACnB,IAAI,OAAO;AACX,CAAC,CAAC;AACF,OAAO,CAAC,0BAA0B,GAAG,0BAA0B"}
+{"version":3,"file":"createInterfaceDeclaration.mjs","sources":["createInterfaceDeclaration.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createInterfaceDeclaration = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link InterfaceDeclaration}: an `interface X { ... }`.\n *\n * The `modifiers` are printed in front of the `interface` keyword, so passing\n * an `export` modifier yields `export interface`. The `name` accepts a plain\n * string or a prebuilt identifier, and `typeParameters` add the `<...>` generic\n * list when present. The `heritageClauses` carry the `extends` clauses, while\n * `members` become the body. The printer wraps the members in a brace block,\n * one member per line, and emits an empty `{}` when there are none.\n *\n * Given an `export` modifier, the name `IBox`, and a single `value: number`\n * member, the printed declaration is:\n *\n * ```ts\n * export interface IBox {\n *   value: number;\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The name.\n * @param typeParameters The generic type parameters, if any.\n * @param heritageClauses The `extends` / `implements` clauses, if any.\n * @param members The members.\n * @returns The created {@link InterfaceDeclaration}.\n */\nconst createInterfaceDeclaration = (modifiers, name, typeParameters, heritageClauses, members) => (0, make_1.make)(\"InterfaceDeclaration\", {\n    modifiers,\n    name: (0, asName_1.asName)(name),\n    typeParameters,\n    heritageClauses,\n    members,\n});\nexports.createInterfaceDeclaration = createInterfaceDeclaration;\n//# sourceMappingURL=createInterfaceDeclaration.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,0BAA0B,GAAG,MAAM;AAC3C,MAAM,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC;AAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,0BAA0B,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,sBAAsB,EAAE;AAC3I,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,IAAI,cAAc;AAClB,IAAI,eAAe;AACnB,IAAI,OAAO;AACX,CAAC,CAAC;AACF,OAAO,CAAC,0BAA0B,GAAG,0BAA0B"}

package/lib/factory/declarations/createMethodDeclaration.d.ts

@@ -1,6 +1,26 @@
 import type { Block, MethodDeclaration, ModifierLike, ParameterDeclaration, PropertyName, Token, TypeNode, TypeParameterDeclaration } from "../../ast";
 /**
- * Create a {@link MethodDeclaration}.
+ * Create a {@link MethodDeclaration}: a class method `m(...) { ... }`.
+ *
+ * The `modifiers` precede the method name, so a `public` modifier prints
+ * `public m`, and `static` or `async` print likewise. Any decorators among the
+ * modifiers are hoisted onto their own lines above the method. The
+ * `asteriskToken` marks a generator method (`*m`), and the `questionToken`
+ * marks an optional method (`m?`). The `name` is the method key, and
+ * `typeParameters` add the generic `<...>` list.
+ *
+ * The `parameters` print inside the parentheses, the optional return `type`
+ * follows after a colon, and the `body` block holds the statements, indented
+ * one per line.
+ *
+ * Given a `public` modifier, the name `greet`, a `name: string` parameter, a
+ * `string` return type, and a body returning `name`, the printed method is:
+ *
+ * ```ts
+ * public greet(name: string): string {
+ *   return name;
+ * }
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param modifiers The leading modifiers and decorators, if any.

package/lib/factory/declarations/createMethodDeclaration.js

@@ -4,7 +4,27 @@ exports.createMethodDeclaration = void 0;
 const asPropertyName_1 = require("../internal/asPropertyName");
 const make_1 = require("../internal/make");
 /**
- * Create a {@link MethodDeclaration}.
+ * Create a {@link MethodDeclaration}: a class method `m(...) { ... }`.
+ *
+ * The `modifiers` precede the method name, so a `public` modifier prints
+ * `public m`, and `static` or `async` print likewise. Any decorators among the
+ * modifiers are hoisted onto their own lines above the method. The
+ * `asteriskToken` marks a generator method (`*m`), and the `questionToken`
+ * marks an optional method (`m?`). The `name` is the method key, and
+ * `typeParameters` add the generic `<...>` list.
+ *
+ * The `parameters` print inside the parentheses, the optional return `type`
+ * follows after a colon, and the `body` block holds the statements, indented
+ * one per line.
+ *
+ * Given a `public` modifier, the name `greet`, a `name: string` parameter, a
+ * `string` return type, and a body returning `name`, the printed method is:
+ *
+ * ```ts
+ * public greet(name: string): string {
+ *   return name;
+ * }
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param modifiers The leading modifiers and decorators, if any.

package/lib/factory/declarations/createMethodDeclaration.js.map

@@ -1 +1 @@
-{"version":3,"file":"createMethodDeclaration.js","sourceRoot":"","sources":["../../../src/factory/declarations/createMethodDeclaration.ts"],"names":[],"mappings":";;;AAUA,+DAA4D;AAC5D,2CAAwC;AAExC;;;;;;;;;;;;;GAaG;AACI,MAAM,uBAAuB,GAAG,CACrC,SAA8C,EAC9C,aAAgC,EAChC,IAA2B,EAC3B,aAAgC,EAChC,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,EAC1B,IAAuB,EACJ,EAAE,CACrB,IAAA,WAAI,EAAC,mBAAmB,EAAE;IACxB,SAAS;IACT,aAAa;IACb,IAAI,EAAE,IAAA,+BAAc,EAAC,IAAI,CAAC;IAC1B,aAAa;IACb,cAAc;IACd,UAAU;IACV,IAAI;IACJ,IAAI;CACL,CAAC,CAAC;AAnBQ,QAAA,uBAAuB,GAAvB,uBAAuB,CAmB/B"}
+{"version":3,"file":"createMethodDeclaration.js","sourceRoot":"","sources":["../../../src/factory/declarations/createMethodDeclaration.ts"],"names":[],"mappings":";;;AAUA,+DAA4D;AAC5D,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACI,MAAM,uBAAuB,GAAG,CACrC,SAA8C,EAC9C,aAAgC,EAChC,IAA2B,EAC3B,aAAgC,EAChC,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,EAC1B,IAAuB,EACJ,EAAE,CACrB,IAAA,WAAI,EAAC,mBAAmB,EAAE;IACxB,SAAS;IACT,aAAa;IACb,IAAI,EAAE,IAAA,+BAAc,EAAC,IAAI,CAAC;IAC1B,aAAa;IACb,cAAc;IACd,UAAU;IACV,IAAI;IACJ,IAAI;CACL,CAAC,CAAC;AAnBQ,QAAA,uBAAuB,GAAvB,uBAAuB,CAmB/B"}

package/lib/factory/declarations/createMethodDeclaration.mjs

@@ -3,7 +3,27 @@ exports.createMethodDeclaration = void 0;
 const asPropertyName_1 = require("../internal/asPropertyName");
 const make_1 = require("../internal/make");
 /**
- * Create a {@link MethodDeclaration}.
+ * Create a {@link MethodDeclaration}: a class method `m(...) { ... }`.
+ *
+ * The `modifiers` precede the method name, so a `public` modifier prints
+ * `public m`, and `static` or `async` print likewise. Any decorators among the
+ * modifiers are hoisted onto their own lines above the method. The
+ * `asteriskToken` marks a generator method (`*m`), and the `questionToken`
+ * marks an optional method (`m?`). The `name` is the method key, and
+ * `typeParameters` add the generic `<...>` list.
+ *
+ * The `parameters` print inside the parentheses, the optional return `type`
+ * follows after a colon, and the `body` block holds the statements, indented
+ * one per line.
+ *
+ * Given a `public` modifier, the name `greet`, a `name: string` parameter, a
+ * `string` return type, and a body returning `name`, the printed method is:
+ *
+ * ```ts
+ * public greet(name: string): string {
+ *   return name;
+ * }
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param modifiers The leading modifiers and decorators, if any.

package/lib/factory/declarations/createMethodDeclaration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createMethodDeclaration.mjs","sources":["createMethodDeclaration.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createMethodDeclaration = void 0;\nconst asPropertyName_1 = require(\"../internal/asPropertyName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link MethodDeclaration}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param asteriskToken The generator marker (`*`), if any.\n * @param name The name.\n * @param questionToken The optional marker (`?`), if any.\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The type.\n * @param body The body.\n * @returns The created {@link MethodDeclaration}.\n */\nconst createMethodDeclaration = (modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) => (0, make_1.make)(\"MethodDeclaration\", {\n    modifiers,\n    asteriskToken,\n    name: (0, asPropertyName_1.asPropertyName)(name),\n    questionToken,\n    typeParameters,\n    parameters,\n    type,\n    body,\n});\nexports.createMethodDeclaration = createMethodDeclaration;\n//# sourceMappingURL=createMethodDeclaration.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,uBAAuB,GAAG,MAAM;AACxC,MAAM,gBAAgB,GAAG,OAAO,CAAC,4BAA4B,CAAC;AAC9D,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,uBAAuB,GAAG,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,EAAE,aAAa,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,mBAAmB,EAAE;AACjK,IAAI,SAAS;AACb,IAAI,aAAa;AACjB,IAAI,IAAI,EAAE,IAAI,gBAAgB,CAAC,cAAc,EAAE,IAAI,CAAC;AACpD,IAAI,aAAa;AACjB,IAAI,cAAc;AAClB,IAAI,UAAU;AACd,IAAI,IAAI;AACR,IAAI,IAAI;AACR,CAAC,CAAC;AACF,OAAO,CAAC,uBAAuB,GAAG,uBAAuB"}
+{"version":3,"file":"createMethodDeclaration.mjs","sources":["createMethodDeclaration.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createMethodDeclaration = void 0;\nconst asPropertyName_1 = require(\"../internal/asPropertyName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link MethodDeclaration}: a class method `m(...) { ... }`.\n *\n * The `modifiers` precede the method name, so a `public` modifier prints\n * `public m`, and `static` or `async` print likewise. Any decorators among the\n * modifiers are hoisted onto their own lines above the method. The\n * `asteriskToken` marks a generator method (`*m`), and the `questionToken`\n * marks an optional method (`m?`). The `name` is the method key, and\n * `typeParameters` add the generic `<...>` list.\n *\n * The `parameters` print inside the parentheses, the optional return `type`\n * follows after a colon, and the `body` block holds the statements, indented\n * one per line.\n *\n * Given a `public` modifier, the name `greet`, a `name: string` parameter, a\n * `string` return type, and a body returning `name`, the printed method is:\n *\n * ```ts\n * public greet(name: string): string {\n *   return name;\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param asteriskToken The generator marker (`*`), if any.\n * @param name The name.\n * @param questionToken The optional marker (`?`), if any.\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The type.\n * @param body The body.\n * @returns The created {@link MethodDeclaration}.\n */\nconst createMethodDeclaration = (modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) => (0, make_1.make)(\"MethodDeclaration\", {\n    modifiers,\n    asteriskToken,\n    name: (0, asPropertyName_1.asPropertyName)(name),\n    questionToken,\n    typeParameters,\n    parameters,\n    type,\n    body,\n});\nexports.createMethodDeclaration = createMethodDeclaration;\n//# sourceMappingURL=createMethodDeclaration.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,uBAAuB,GAAG,MAAM;AACxC,MAAM,gBAAgB,GAAG,OAAO,CAAC,4BAA4B,CAAC;AAC9D,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,uBAAuB,GAAG,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,EAAE,aAAa,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,mBAAmB,EAAE;AACjK,IAAI,SAAS;AACb,IAAI,aAAa;AACjB,IAAI,IAAI,EAAE,IAAI,gBAAgB,CAAC,cAAc,EAAE,IAAI,CAAC;AACpD,IAAI,aAAa;AACjB,IAAI,cAAc;AAClB,IAAI,UAAU;AACd,IAAI,IAAI;AACR,IAAI,IAAI;AACR,CAAC,CAAC;AACF,OAAO,CAAC,uBAAuB,GAAG,uBAAuB"}

package/lib/factory/declarations/createModuleBlock.d.ts

@@ -1,6 +1,18 @@
 import type { ModuleBlock, Statement } from "../../ast";
 /**
- * Create a {@link ModuleBlock}.
+ * Create a {@link ModuleBlock}: the `{ ... }` body of a namespace or module.
+ *
+ * This is the body that a {@link ModuleDeclaration} wraps in braces. The
+ * `statements` become its contents, which the printer indents one per line
+ * inside the braces.
+ *
+ * Given a single `export type ID = string;` statement, the printed block is:
+ *
+ * ```ts
+ * {
+ *   export type ID = string;
+ * }
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param statements The statements.

package/lib/factory/declarations/createModuleBlock.js

@@ -3,7 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createModuleBlock = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link ModuleBlock}.
+ * Create a {@link ModuleBlock}: the `{ ... }` body of a namespace or module.
+ *
+ * This is the body that a {@link ModuleDeclaration} wraps in braces. The
+ * `statements` become its contents, which the printer indents one per line
+ * inside the braces.
+ *
+ * Given a single `export type ID = string;` statement, the printed block is:
+ *
+ * ```ts
+ * {
+ *   export type ID = string;
+ * }
+ * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param statements The statements.

package/lib/factory/declarations/createModuleBlock.js.map

@@ -1 +1 @@
-{"version":3,"file":"createModuleBlock.js","sourceRoot":"","sources":["../../../src/factory/declarations/createModuleBlock.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;GAMG;AACI,MAAM,iBAAiB,GAAG,CAC/B,UAAgC,EACnB,EAAE,CAAC,IAAA,WAAI,EAAC,aAAa,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;AAFzC,QAAA,iBAAiB,GAAjB,iBAAiB,CAEwB"}
+{"version":3,"file":"createModuleBlock.js","sourceRoot":"","sources":["../../../src/factory/declarations/createModuleBlock.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;GAkBG;AACI,MAAM,iBAAiB,GAAG,CAC/B,UAAgC,EACnB,EAAE,CAAC,IAAA,WAAI,EAAC,aAAa,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;AAFzC,QAAA,iBAAiB,GAAjB,iBAAiB,CAEwB"}