@ttsc/factory 0.15.9 → 0.15.10

package/lib/factory/declarations/createClassStaticBlockDeclaration.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ClassStaticBlockDeclaration}: a `static { ... }` block.
+ *
+ * This is a class member that runs initialization code when the class is
+ * evaluated. The `body` block holds the statements, which the printer indents
+ * one per line after the `static` keyword.
+ *
+ * Given a body that assigns `count = 0`, the printed member is:
+ *
+ * ```ts
+ * static {
+ *   count = 0;
+ * }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param body The body.
+ * @returns The created {@link ClassStaticBlockDeclaration}.
+ */
+const createClassStaticBlockDeclaration = (body) => make("ClassStaticBlockDeclaration", { body });
+
+export { createClassStaticBlockDeclaration };
+//# sourceMappingURL=createClassStaticBlockDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createClassStaticBlockDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createClassStaticBlockDeclaration.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ClassStaticBlockDeclaration}: a `static { ... }` block.\n *\n * This is a class member that runs initialization code when the class is\n * evaluated. The `body` block holds the statements, which the printer indents\n * one per line after the `static` keyword.\n *\n * Given a body that assigns `count = 0`, the printed member is:\n *\n * ```ts\n * static {\n *   count = 0;\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param body The body.\n * @returns The created {@link ClassStaticBlockDeclaration}.\n */\nexport const createClassStaticBlockDeclaration = (body) => make(\"ClassStaticBlockDeclaration\", { body });\n//# sourceMappingURL=createClassStaticBlockDeclaration.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,iCAAiC,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,6BAA6B,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/declarations/createConstructorDeclaration.mjs

@@ -0,0 +1,28 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ConstructorDeclaration}: a class `constructor(...) { ... }`.
+ *
+ * The `modifiers` precede the `constructor` keyword. The `parameters` print
+ * inside the parentheses, and a parameter that carries accessibility modifiers
+ * such as `private readonly` becomes a parameter property. The `body` block is
+ * the constructor body; when it holds no statements the printer collapses it to
+ * `{}` on the same line.
+ *
+ * Given a single `private readonly value: number` parameter and an empty body,
+ * the printed constructor is:
+ *
+ * ```ts
+ * constructor(private readonly value: number) {}
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param parameters The parameters.
+ * @param body The body.
+ * @returns The created {@link ConstructorDeclaration}.
+ */
+const createConstructorDeclaration = (modifiers, parameters, body) => make("ConstructorDeclaration", { modifiers, parameters, body });
+
+export { createConstructorDeclaration };
+//# sourceMappingURL=createConstructorDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createConstructorDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createConstructorDeclaration.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ConstructorDeclaration}: a class `constructor(...) { ... }`.\n *\n * The `modifiers` precede the `constructor` keyword. The `parameters` print\n * inside the parentheses, and a parameter that carries accessibility modifiers\n * such as `private readonly` becomes a parameter property. The `body` block is\n * the constructor body; when it holds no statements the printer collapses it to\n * `{}` on the same line.\n *\n * Given a single `private readonly value: number` parameter and an empty body,\n * the printed constructor is:\n *\n * ```ts\n * constructor(private readonly value: number) {}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param parameters The parameters.\n * @param body The body.\n * @returns The created {@link ConstructorDeclaration}.\n */\nexport const createConstructorDeclaration = (modifiers, parameters, body) => make(\"ConstructorDeclaration\", { modifiers, parameters, body });\n//# sourceMappingURL=createConstructorDeclaration.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,4BAA4B,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,wBAAwB,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/declarations/createEnumDeclaration.mjs

@@ -0,0 +1,31 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link EnumDeclaration}: an `enum X { ... }`.
+ *
+ * The `modifiers` precede the `enum` keyword, so an `export` modifier prints
+ * `export enum`, and a `const` modifier prints `const enum`. The `name` accepts
+ * a string or identifier. The `members` form the body, printed one per line and
+ * each terminated with a trailing comma.
+ *
+ * Given an `export` modifier, the name `Color`, and the members `Red` and
+ * `Green`, the printed declaration is:
+ *
+ * ```ts
+ * export enum Color {
+ *   Red,
+ *   Green,
+ * }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param name The name.
+ * @param members The members.
+ * @returns The created {@link EnumDeclaration}.
+ */
+const createEnumDeclaration = (modifiers, name, members) => make("EnumDeclaration", { modifiers, name: asName(name), members });
+
+export { createEnumDeclaration };
+//# sourceMappingURL=createEnumDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createEnumDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createEnumDeclaration.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create an {@link EnumDeclaration}: an `enum X { ... }`.\n *\n * The `modifiers` precede the `enum` keyword, so an `export` modifier prints\n * `export enum`, and a `const` modifier prints `const enum`. The `name` accepts\n * a string or identifier. The `members` form the body, printed one per line and\n * each terminated with a trailing comma.\n *\n * Given an `export` modifier, the name `Color`, and the members `Red` and\n * `Green`, the printed declaration is:\n *\n * ```ts\n * export enum Color {\n *   Red,\n *   Green,\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 members The members.\n * @returns The created {@link EnumDeclaration}.\n */\nexport const createEnumDeclaration = (modifiers, name, members) => make(\"EnumDeclaration\", { modifiers, name: asName(name), members });\n//# sourceMappingURL=createEnumDeclaration.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/declarations/createEnumMember.mjs

@@ -0,0 +1,26 @@
+import { asPropertyName } from '../internal/asPropertyName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link EnumMember}: a single member of an `enum` body.
+ *
+ * The `name` is the member key and accepts a string or property name. The
+ * optional `initializer` assigns an explicit value; when present the printer
+ * emits it after an `=`, and when omitted the member prints as the bare name
+ * and TypeScript assigns the value implicitly.
+ *
+ * Given the name `Red` and a numeric initializer of `1`, the printed member is:
+ *
+ * ```ts
+ * Red = 1;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param name The name.
+ * @param initializer The initializer, if any.
+ * @returns The created {@link EnumMember}.
+ */
+const createEnumMember = (name, initializer) => make("EnumMember", { name: asPropertyName(name), initializer });
+
+export { createEnumMember };
+//# sourceMappingURL=createEnumMember.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createEnumMember.mjs","sources":["../../../esm-tmp/factory/declarations/createEnumMember.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../internal/make\";\n/**\n * Create an {@link EnumMember}: a single member of an `enum` body.\n *\n * The `name` is the member key and accepts a string or property name. The\n * optional `initializer` assigns an explicit value; when present the printer\n * emits it after an `=`, and when omitted the member prints as the bare name\n * and TypeScript assigns the value implicitly.\n *\n * Given the name `Red` and a numeric initializer of `1`, the printed member is:\n *\n * ```ts\n * Red = 1;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The name.\n * @param initializer The initializer, if any.\n * @returns The created {@link EnumMember}.\n */\nexport const createEnumMember = (name, initializer) => make(\"EnumMember\", { name: asPropertyName(name), initializer });\n//# sourceMappingURL=createEnumMember.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gBAAgB,GAAG,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC,YAAY,EAAE,EAAE,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE;;;;"}

package/lib/factory/declarations/createExternalModuleReference.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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.
+ * @returns The created {@link ExternalModuleReference}.
+ */
+const createExternalModuleReference = (expression) => make("ExternalModuleReference", { expression });
+
+export { createExternalModuleReference };
+//# sourceMappingURL=createExternalModuleReference.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createExternalModuleReference.mjs","sources":["../../../esm-tmp/factory/declarations/createExternalModuleReference.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createExternalModuleReference = (expression) => make(\"ExternalModuleReference\", { expression });\n//# sourceMappingURL=createExternalModuleReference.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,6BAA6B,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,yBAAyB,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/declarations/createFunctionDeclaration.mjs

@@ -0,0 +1,48 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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.
+ * @param asteriskToken The generator marker (`*`), if any.
+ * @param name The name.
+ * @param typeParameters The generic type parameters, if any.
+ * @param parameters The parameters.
+ * @param type The type.
+ * @param body The body.
+ * @returns The created {@link FunctionDeclaration}.
+ */
+const createFunctionDeclaration = (modifiers, asteriskToken, name, typeParameters, parameters, type, body) => make("FunctionDeclaration", {
+    modifiers,
+    asteriskToken,
+    name: name === undefined ? undefined : asName(name),
+    typeParameters,
+    parameters,
+    type,
+    body,
+});
+
+export { createFunctionDeclaration };
+//# sourceMappingURL=createFunctionDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createFunctionDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createFunctionDeclaration.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../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 */\nexport const createFunctionDeclaration = (modifiers, asteriskToken, name, typeParameters, parameters, type, body) => make(\"FunctionDeclaration\", {\n    modifiers,\n    asteriskToken,\n    name: name === undefined ? undefined : asName(name),\n    typeParameters,\n    parameters,\n    type,\n    body,\n});\n//# sourceMappingURL=createFunctionDeclaration.js.map"],"names":[],"mappings":";;;AAEA;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;AACY,MAAC,yBAAyB,GAAG,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC,qBAAqB,EAAE;AACjJ,IAAI,SAAS;AACb,IAAI,aAAa;AACjB,IAAI,IAAI,EAAE,IAAI,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC;AACvD,IAAI,cAAc;AAClB,IAAI,UAAU;AACd,IAAI,IAAI;AACR,IAAI,IAAI;AACR,CAAC;;;;"}

package/lib/factory/declarations/createGetAccessorDeclaration.mjs

@@ -0,0 +1,39 @@
+import { asPropertyName } from '../internal/asPropertyName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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.
+ * @param name The name.
+ * @param parameters The parameters.
+ * @param type The type.
+ * @param body The body.
+ * @returns The created {@link GetAccessorDeclaration}.
+ */
+const createGetAccessorDeclaration = (modifiers, name, parameters, type, body) => make("GetAccessorDeclaration", {
+    modifiers,
+    name: asPropertyName(name),
+    parameters,
+    type,
+    body,
+});
+
+export { createGetAccessorDeclaration };
+//# sourceMappingURL=createGetAccessorDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createGetAccessorDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createGetAccessorDeclaration.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../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 */\nexport const createGetAccessorDeclaration = (modifiers, name, parameters, type, body) => make(\"GetAccessorDeclaration\", {\n    modifiers,\n    name: asPropertyName(name),\n    parameters,\n    type,\n    body,\n});\n//# sourceMappingURL=createGetAccessorDeclaration.js.map"],"names":[],"mappings":";;;AAEA;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;AACY,MAAC,4BAA4B,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC,wBAAwB,EAAE;AACxH,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;AAC9B,IAAI,UAAU;AACd,IAAI,IAAI;AACR,IAAI,IAAI;AACR,CAAC;;;;"}

package/lib/factory/declarations/createImportEqualsDeclaration.mjs

@@ -0,0 +1,35 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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 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) => make("ImportEqualsDeclaration", {
+    modifiers,
+    isTypeOnly,
+    name: asName(name),
+    moduleReference,
+});
+
+export { createImportEqualsDeclaration };
+//# sourceMappingURL=createImportEqualsDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createImportEqualsDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createImportEqualsDeclaration.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../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 */\nexport const createImportEqualsDeclaration = (modifiers, isTypeOnly, name, moduleReference) => make(\"ImportEqualsDeclaration\", {\n    modifiers,\n    isTypeOnly,\n    name: asName(name),\n    moduleReference,\n});\n//# sourceMappingURL=createImportEqualsDeclaration.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,6BAA6B,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,KAAK,IAAI,CAAC,yBAAyB,EAAE;AAC/H,IAAI,SAAS;AACb,IAAI,UAAU;AACd,IAAI,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;AACtB,IAAI,eAAe;AACnB,CAAC;;;;"}

package/lib/factory/declarations/createInterfaceDeclaration.mjs

@@ -0,0 +1,40 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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.
+ * @param name The name.
+ * @param typeParameters The generic type parameters, if any.
+ * @param heritageClauses The `extends` / `implements` clauses, if any.
+ * @param members The members.
+ * @returns The created {@link InterfaceDeclaration}.
+ */
+const createInterfaceDeclaration = (modifiers, name, typeParameters, heritageClauses, members) => make("InterfaceDeclaration", {
+    modifiers,
+    name: asName(name),
+    typeParameters,
+    heritageClauses,
+    members,
+});
+
+export { createInterfaceDeclaration };
+//# sourceMappingURL=createInterfaceDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createInterfaceDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createInterfaceDeclaration.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../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 */\nexport const createInterfaceDeclaration = (modifiers, name, typeParameters, heritageClauses, members) => make(\"InterfaceDeclaration\", {\n    modifiers,\n    name: asName(name),\n    typeParameters,\n    heritageClauses,\n    members,\n});\n//# sourceMappingURL=createInterfaceDeclaration.js.map"],"names":[],"mappings":";;;AAEA;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;AACY,MAAC,0BAA0B,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,KAAK,IAAI,CAAC,sBAAsB,EAAE;AACtI,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;AACtB,IAAI,cAAc;AAClB,IAAI,eAAe;AACnB,IAAI,OAAO;AACX,CAAC;;;;"}

package/lib/factory/declarations/createMethodDeclaration.mjs

@@ -0,0 +1,50 @@
+import { asPropertyName } from '../internal/asPropertyName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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.
+ * @param asteriskToken The generator marker (`*`), if any.
+ * @param name The name.
+ * @param questionToken The optional marker (`?`), if any.
+ * @param typeParameters The generic type parameters, if any.
+ * @param parameters The parameters.
+ * @param type The type.
+ * @param body The body.
+ * @returns The created {@link MethodDeclaration}.
+ */
+const createMethodDeclaration = (modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) => make("MethodDeclaration", {
+    modifiers,
+    asteriskToken,
+    name: asPropertyName(name),
+    questionToken,
+    typeParameters,
+    parameters,
+    type,
+    body,
+});
+
+export { createMethodDeclaration };
+//# sourceMappingURL=createMethodDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createMethodDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createMethodDeclaration.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../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 */\nexport const createMethodDeclaration = (modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) => make(\"MethodDeclaration\", {\n    modifiers,\n    asteriskToken,\n    name: asPropertyName(name),\n    questionToken,\n    typeParameters,\n    parameters,\n    type,\n    body,\n});\n//# sourceMappingURL=createMethodDeclaration.js.map"],"names":[],"mappings":";;;AAEA;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;AACY,MAAC,uBAAuB,GAAG,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,EAAE,aAAa,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC5J,IAAI,SAAS;AACb,IAAI,aAAa;AACjB,IAAI,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;AAC9B,IAAI,aAAa;AACjB,IAAI,cAAc;AAClB,IAAI,UAAU;AACd,IAAI,IAAI;AACR,IAAI,IAAI;AACR,CAAC;;;;"}

package/lib/factory/declarations/createModuleBlock.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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.
+ * @returns The created {@link ModuleBlock}.
+ */
+const createModuleBlock = (statements) => make("ModuleBlock", { statements });
+
+export { createModuleBlock };
+//# sourceMappingURL=createModuleBlock.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createModuleBlock.mjs","sources":["../../../esm-tmp/factory/declarations/createModuleBlock.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ModuleBlock}: the `{ ... }` body of a namespace or module.\n *\n * This is the body that a {@link ModuleDeclaration} wraps in braces. The\n * `statements` become its contents, which the printer indents one per line\n * inside the braces.\n *\n * Given a single `export type ID = string;` statement, the printed block is:\n *\n * ```ts\n * {\n *   export type ID = string;\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param statements The statements.\n * @returns The created {@link ModuleBlock}.\n */\nexport const createModuleBlock = (statements) => make(\"ModuleBlock\", { statements });\n//# sourceMappingURL=createModuleBlock.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,iBAAiB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,aAAa,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/declarations/createModuleDeclaration.mjs

@@ -0,0 +1,42 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+import { NodeFlags } from '../../syntax/NodeFlags.mjs';
+
+/**
+ * Create a {@link ModuleDeclaration}: a `namespace X { ... }` or `module X { ...
+ * }`.
+ *
+ * The `modifiers` precede the keyword, so an `export` modifier prints `export
+ * namespace`. The `name` accepts a string, which is wrapped in an identifier,
+ * or a prebuilt module name. The `body` is the brace block, normally a
+ * {@link ModuleBlock}, whose statements the printer indents one per line.
+ *
+ * The `flags` decide the keyword the printer emits: the `Namespace` flag prints
+ * `namespace`, while the default prints `module`. This is the one input that
+ * does not show up as text directly but changes the rendered keyword.
+ *
+ * Given an `export` modifier, the name `app`, a body holding `export type ID =
+ * string;`, and the `Namespace` flag, the printed declaration is:
+ *
+ * ```ts
+ * export namespace app {
+ *   export type ID = string;
+ * }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers, if any.
+ * @param name The name.
+ * @param body The body.
+ * @param flags The node flags that select the `namespace` or `module` keyword.
+ * @returns The created {@link ModuleDeclaration}.
+ */
+const createModuleDeclaration = (modifiers, name, body, flags = NodeFlags.None) => make("ModuleDeclaration", {
+    modifiers,
+    name: typeof name === "string" ? createIdentifier(name) : name,
+    body,
+    flags,
+});
+
+export { createModuleDeclaration };
+//# sourceMappingURL=createModuleDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createModuleDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createModuleDeclaration.js"],"sourcesContent":["import { NodeFlags } from \"../../syntax\";\nimport { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link ModuleDeclaration}: a `namespace X { ... }` or `module X { ...\n * }`.\n *\n * The `modifiers` precede the keyword, so an `export` modifier prints `export\n * namespace`. The `name` accepts a string, which is wrapped in an identifier,\n * or a prebuilt module name. The `body` is the brace block, normally a\n * {@link ModuleBlock}, whose statements the printer indents one per line.\n *\n * The `flags` decide the keyword the printer emits: the `Namespace` flag prints\n * `namespace`, while the default prints `module`. This is the one input that\n * does not show up as text directly but changes the rendered keyword.\n *\n * Given an `export` modifier, the name `app`, a body holding `export type ID =\n * string;`, and the `Namespace` flag, the printed declaration is:\n *\n * ```ts\n * export namespace app {\n *   export type ID = string;\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers, if any.\n * @param name The name.\n * @param body The body.\n * @param flags The node flags that select the `namespace` or `module` keyword.\n * @returns The created {@link ModuleDeclaration}.\n */\nexport const createModuleDeclaration = (modifiers, name, body, flags = NodeFlags.None) => make(\"ModuleDeclaration\", {\n    modifiers,\n    name: typeof name === \"string\" ? createIdentifier(name) : name,\n    body,\n    flags,\n});\n//# sourceMappingURL=createModuleDeclaration.js.map"],"names":[],"mappings":";;;;AAGA;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;AACY,MAAC,uBAAuB,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,GAAG,SAAS,CAAC,IAAI,KAAK,IAAI,CAAC,mBAAmB,EAAE;AACpH,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;AAClE,IAAI,IAAI;AACR,IAAI,KAAK;AACT,CAAC;;;;"}

package/lib/factory/declarations/createNamespaceExportDeclaration.mjs

@@ -0,0 +1,24 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link NamespaceExportDeclaration}: an `export as namespace X;`.
+ *
+ * This is the UMD global declaration used in `.d.ts` files to state the global
+ * variable name under which the module is exposed in a script context. The
+ * `name` is that global identifier.
+ *
+ * Given the name `App`, the printed declaration is:
+ *
+ * ```ts
+ * export as namespace App;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param name The name.
+ * @returns The created {@link NamespaceExportDeclaration}.
+ */
+const createNamespaceExportDeclaration = (name) => make("NamespaceExportDeclaration", { name: asName(name) });
+
+export { createNamespaceExportDeclaration };
+//# sourceMappingURL=createNamespaceExportDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createNamespaceExportDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createNamespaceExportDeclaration.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link NamespaceExportDeclaration}: an `export as namespace X;`.\n *\n * This is the UMD global declaration used in `.d.ts` files to state the global\n * variable name under which the module is exposed in a script context. The\n * `name` is that global identifier.\n *\n * Given the name `App`, the printed declaration is:\n *\n * ```ts\n * export as namespace App;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The name.\n * @returns The created {@link NamespaceExportDeclaration}.\n */\nexport const createNamespaceExportDeclaration = (name) => make(\"NamespaceExportDeclaration\", { name: asName(name) });\n//# sourceMappingURL=createNamespaceExportDeclaration.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gCAAgC,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,4BAA4B,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;;;;"}

package/lib/factory/declarations/createPropertyDeclaration.mjs

@@ -0,0 +1,41 @@
+import { asPropertyName } from '../internal/asPropertyName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link PropertyDeclaration}: a class field such as `x: number;`.
+ *
+ * The `modifiers` precede the property name, so `public readonly` prints in
+ * that order. Any decorators among the modifiers are hoisted onto their own
+ * lines above the property. The `name` is the field key, and the
+ * `questionOrExclamationToken` appends either the optional marker (`?`) or the
+ * definite-assignment marker (`!`) after the name.
+ *
+ * The optional `type` prints after a colon, and the optional `initializer`
+ * prints after an `=`. The printer terminates the field with a semicolon.
+ *
+ * Given `public readonly` modifiers, the name `id`, a `string` type, and a
+ * string-literal initializer of `"x"`, the printed field is:
+ *
+ * ```ts
+ * public readonly id: string = "x";
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param name The name.
+ * @param questionOrExclamationToken The optional (`?`) or definite-assignment
+ *   (`!`) marker, if any.
+ * @param type The type.
+ * @param initializer The initializer, if any.
+ * @returns The created {@link PropertyDeclaration}.
+ */
+const createPropertyDeclaration = (modifiers, name, questionOrExclamationToken, type, initializer) => make("PropertyDeclaration", {
+    modifiers,
+    name: asPropertyName(name),
+    questionOrExclamationToken,
+    type,
+    initializer,
+});
+
+export { createPropertyDeclaration };
+//# sourceMappingURL=createPropertyDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPropertyDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createPropertyDeclaration.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link PropertyDeclaration}: a class field such as `x: number;`.\n *\n * The `modifiers` precede the property name, so `public readonly` prints in\n * that order. Any decorators among the modifiers are hoisted onto their own\n * lines above the property. The `name` is the field key, and the\n * `questionOrExclamationToken` appends either the optional marker (`?`) or the\n * definite-assignment marker (`!`) after the name.\n *\n * The optional `type` prints after a colon, and the optional `initializer`\n * prints after an `=`. The printer terminates the field with a semicolon.\n *\n * Given `public readonly` modifiers, the name `id`, a `string` type, and a\n * string-literal initializer of `\"x\"`, the printed field is:\n *\n * ```ts\n * public readonly id: string = \"x\";\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 questionOrExclamationToken The optional (`?`) or definite-assignment\n *   (`!`) marker, if any.\n * @param type The type.\n * @param initializer The initializer, if any.\n * @returns The created {@link PropertyDeclaration}.\n */\nexport const createPropertyDeclaration = (modifiers, name, questionOrExclamationToken, type, initializer) => make(\"PropertyDeclaration\", {\n    modifiers,\n    name: asPropertyName(name),\n    questionOrExclamationToken,\n    type,\n    initializer,\n});\n//# sourceMappingURL=createPropertyDeclaration.js.map"],"names":[],"mappings":";;;AAEA;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;AACY,MAAC,yBAAyB,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,0BAA0B,EAAE,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC,qBAAqB,EAAE;AACzI,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;AAC9B,IAAI,0BAA0B;AAC9B,IAAI,IAAI;AACR,IAAI,WAAW;AACf,CAAC;;;;"}

package/lib/factory/declarations/createSemicolonClassElement.mjs

@@ -0,0 +1,20 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link SemicolonClassElement}: a stray `;` in a class body.
+ *
+ * This is an empty class member, a lone semicolon that TypeScript permits
+ * between real members. It carries no name or body. Placed inside a class, the
+ * printer emits it as a single semicolon on its own line:
+ *
+ * ```ts
+ * class C {}
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link SemicolonClassElement}.
+ */
+const createSemicolonClassElement = () => make("SemicolonClassElement", {});
+
+export { createSemicolonClassElement };
+//# sourceMappingURL=createSemicolonClassElement.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createSemicolonClassElement.mjs","sources":["../../../esm-tmp/factory/declarations/createSemicolonClassElement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link SemicolonClassElement}: a stray `;` in a class body.\n *\n * This is an empty class member, a lone semicolon that TypeScript permits\n * between real members. It carries no name or body. Placed inside a class, the\n * printer emits it as a single semicolon on its own line:\n *\n * ```ts\n * class C {}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link SemicolonClassElement}.\n */\nexport const createSemicolonClassElement = () => make(\"SemicolonClassElement\", {});\n//# sourceMappingURL=createSemicolonClassElement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,2BAA2B,GAAG,MAAM,IAAI,CAAC,uBAAuB,EAAE,EAAE;;;;"}