@ttsc/factory 0.15.8 → 0.15.10

package/lib/factory/expressions/createUnsignedRightShift.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createUnsignedRightShift.mjs","sources":["createUnsignedRightShift.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createUnsignedRightShift = void 0;\nconst syntax_1 = require(\"../../syntax\");\nconst createBinaryExpression_1 = require(\"./createBinaryExpression\");\n/**\n * Create an unsigned right-shift expression: `left >>> right`.\n *\n * Thin wrapper over {@link createBinaryExpression} with the `>>>` operator.\n *\n * With `left` of `a` and `right` of `b`, the printer emits:\n *\n * ```ts\n * a >>> b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param left The left-hand operand.\n * @param right The right-hand operand.\n * @returns The created {@link BinaryExpression}.\n */\nconst createUnsignedRightShift = (left, right) => (0, createBinaryExpression_1.createBinaryExpression)(left, syntax_1.SyntaxKind.GreaterThanGreaterThanGreaterThanToken, right);\nexports.createUnsignedRightShift = createUnsignedRightShift;\n//# sourceMappingURL=createUnsignedRightShift.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,wBAAwB,GAAG,MAAM;AACzC,MAAM,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC;AACxC,MAAM,wBAAwB,GAAG,OAAO,CAAC,0BAA0B,CAAC;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,wBAAwB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,wBAAwB,CAAC,sBAAsB,EAAE,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,sCAAsC,EAAE,KAAK,CAAC;AAC/K,OAAO,CAAC,wBAAwB,GAAG,wBAAwB"}
+{"version":3,"file":"createUnsignedRightShift.mjs","sources":["../../../esm-tmp/factory/expressions/createUnsignedRightShift.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create an unsigned right-shift expression: `left >>> right`.\n *\n * Thin wrapper over {@link createBinaryExpression} with the `>>>` operator.\n *\n * With `left` of `a` and `right` of `b`, the printer emits:\n *\n * ```ts\n * a >>> b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param left The left-hand operand.\n * @param right The right-hand operand.\n * @returns The created {@link BinaryExpression}.\n */\nexport const createUnsignedRightShift = (left, right) => createBinaryExpression(left, SyntaxKind.GreaterThanGreaterThanGreaterThanToken, right);\n//# sourceMappingURL=createUnsignedRightShift.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,wBAAwB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,sCAAsC,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createVoidExpression.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVoidExpression = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link VoidExpression}: the `void` operator applied to a value.
  *
@@ -18,6 +17,7 @@ const make_1 = require("../internal/make");
  * @param expression The operand of `void`.
  * @returns The created {@link VoidExpression}.
  */
-const createVoidExpression = (expression) => (0, make_1.make)("VoidExpression", { expression });
-exports.createVoidExpression = createVoidExpression;
+const createVoidExpression = (expression) => make("VoidExpression", { expression });
+
+export { createVoidExpression };
 //# sourceMappingURL=createVoidExpression.mjs.map

package/lib/factory/expressions/createVoidExpression.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createVoidExpression.mjs","sources":["createVoidExpression.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createVoidExpression = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link VoidExpression}: the `void` operator applied to a value.\n *\n * `expression` is the operand, which is evaluated and then discarded so the\n * whole expression yields `undefined`. The printer writes the `void` keyword, a\n * single space, and the operand.\n *\n * With `expression` of `0`, the printer emits:\n *\n * ```ts\n * void 0;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The operand of `void`.\n * @returns The created {@link VoidExpression}.\n */\nconst createVoidExpression = (expression) => (0, make_1.make)(\"VoidExpression\", { expression });\nexports.createVoidExpression = createVoidExpression;\n//# sourceMappingURL=createVoidExpression.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,oBAAoB,GAAG,MAAM;AACrC,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,oBAAoB,GAAG,CAAC,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,gBAAgB,EAAE,EAAE,UAAU,EAAE,CAAC;AAC/F,OAAO,CAAC,oBAAoB,GAAG,oBAAoB"}
+{"version":3,"file":"createVoidExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createVoidExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link VoidExpression}: the `void` operator applied to a value.\n *\n * `expression` is the operand, which is evaluated and then discarded so the\n * whole expression yields `undefined`. The printer writes the `void` keyword, a\n * single space, and the operand.\n *\n * With `expression` of `0`, the printer emits:\n *\n * ```ts\n * void 0;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The operand of `void`.\n * @returns The created {@link VoidExpression}.\n */\nexport const createVoidExpression = (expression) => make(\"VoidExpression\", { expression });\n//# sourceMappingURL=createVoidExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,gBAAgB,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/expressions/createVoidZero.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVoidZero = void 0;
-const createNumericLiteral_1 = require("../literals/createNumericLiteral");
-const createVoidExpression_1 = require("./createVoidExpression");
+import { createNumericLiteral } from '../literals/createNumericLiteral.mjs';
+import { createVoidExpression } from './createVoidExpression.mjs';
+
 /**
  * Create the `void 0` expression, the canonical way to spell `undefined`.
  *
@@ -17,6 +16,7 @@ const createVoidExpression_1 = require("./createVoidExpression");
  * @author Jeongho Nam - https://github.com/samchon
  * @returns The created {@link VoidExpression}.
  */
-const createVoidZero = () => (0, createVoidExpression_1.createVoidExpression)((0, createNumericLiteral_1.createNumericLiteral)("0"));
-exports.createVoidZero = createVoidZero;
+const createVoidZero = () => createVoidExpression(createNumericLiteral("0"));
+
+export { createVoidZero };
 //# sourceMappingURL=createVoidZero.mjs.map

package/lib/factory/expressions/createVoidZero.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createVoidZero.mjs","sources":["createVoidZero.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createVoidZero = void 0;\nconst createNumericLiteral_1 = require(\"../literals/createNumericLiteral\");\nconst createVoidExpression_1 = require(\"./createVoidExpression\");\n/**\n * Create the `void 0` expression, the canonical way to spell `undefined`.\n *\n * Thin wrapper over {@link createVoidExpression} with the numeric literal `0` as\n * its operand.\n *\n * The printer emits:\n *\n * ```ts\n * void 0;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link VoidExpression}.\n */\nconst createVoidZero = () => (0, createVoidExpression_1.createVoidExpression)((0, createNumericLiteral_1.createNumericLiteral)(\"0\"));\nexports.createVoidZero = createVoidZero;\n//# sourceMappingURL=createVoidZero.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,cAAc,GAAG,MAAM;AAC/B,MAAM,sBAAsB,GAAG,OAAO,CAAC,kCAAkC,CAAC;AAC1E,MAAM,sBAAsB,GAAG,OAAO,CAAC,wBAAwB,CAAC;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,cAAc,GAAG,MAAM,IAAI,sBAAsB,CAAC,oBAAoB,EAAE,IAAI,sBAAsB,CAAC,oBAAoB,EAAE,GAAG,CAAC,CAAC;AACpI,OAAO,CAAC,cAAc,GAAG,cAAc"}
+{"version":3,"file":"createVoidZero.mjs","sources":["../../../esm-tmp/factory/expressions/createVoidZero.js"],"sourcesContent":["import { createNumericLiteral } from \"../literals/createNumericLiteral\";\nimport { createVoidExpression } from \"./createVoidExpression\";\n/**\n * Create the `void 0` expression, the canonical way to spell `undefined`.\n *\n * Thin wrapper over {@link createVoidExpression} with the numeric literal `0` as\n * its operand.\n *\n * The printer emits:\n *\n * ```ts\n * void 0;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link VoidExpression}.\n */\nexport const createVoidZero = () => createVoidExpression(createNumericLiteral(\"0\"));\n//# sourceMappingURL=createVoidZero.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,cAAc,GAAG,MAAM,oBAAoB,CAAC,oBAAoB,CAAC,GAAG,CAAC;;;;"}

package/lib/factory/expressions/createYieldExpression.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createYieldExpression = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link YieldExpression}: a `yield` inside a generator.
  *
@@ -21,6 +20,7 @@ const make_1 = require("../internal/make");
  * @param expression The yielded value, if any.
  * @returns The created {@link YieldExpression}.
  */
-const createYieldExpression = (asteriskToken, expression) => (0, make_1.make)("YieldExpression", { asteriskToken, expression });
-exports.createYieldExpression = createYieldExpression;
+const createYieldExpression = (asteriskToken, expression) => make("YieldExpression", { asteriskToken, expression });
+
+export { createYieldExpression };
 //# sourceMappingURL=createYieldExpression.mjs.map

package/lib/factory/expressions/createYieldExpression.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createYieldExpression.mjs","sources":["createYieldExpression.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createYieldExpression = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link YieldExpression}: a `yield` inside a generator.\n *\n * `asteriskToken`, when present, makes this a delegating `yield*`; otherwise a\n * plain `yield` is emitted. `expression` is the yielded value and may be\n * omitted for a bare `yield`. When a value is present the printer separates the\n * keyword from it with a single space; `yield*` attaches the asterisk directly\n * to the keyword.\n *\n * With no asterisk and `expression` of `x`, the printer emits:\n *\n * ```ts\n * yield x;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param asteriskToken The `*` token for a delegating `yield*`, if any.\n * @param expression The yielded value, if any.\n * @returns The created {@link YieldExpression}.\n */\nconst createYieldExpression = (asteriskToken, expression) => (0, make_1.make)(\"YieldExpression\", { asteriskToken, expression });\nexports.createYieldExpression = createYieldExpression;\n//# sourceMappingURL=createYieldExpression.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,qBAAqB,GAAG,MAAM;AACtC,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,MAAM,qBAAqB,GAAG,CAAC,aAAa,EAAE,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,aAAa,EAAE,UAAU,EAAE,CAAC;AAC/H,OAAO,CAAC,qBAAqB,GAAG,qBAAqB"}
+{"version":3,"file":"createYieldExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createYieldExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link YieldExpression}: a `yield` inside a generator.\n *\n * `asteriskToken`, when present, makes this a delegating `yield*`; otherwise a\n * plain `yield` is emitted. `expression` is the yielded value and may be\n * omitted for a bare `yield`. When a value is present the printer separates the\n * keyword from it with a single space; `yield*` attaches the asterisk directly\n * to the keyword.\n *\n * With no asterisk and `expression` of `x`, the printer emits:\n *\n * ```ts\n * yield x;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param asteriskToken The `*` token for a delegating `yield*`, if any.\n * @param expression The yielded value, if any.\n * @returns The created {@link YieldExpression}.\n */\nexport const createYieldExpression = (asteriskToken, expression) => make(\"YieldExpression\", { asteriskToken, expression });\n//# sourceMappingURL=createYieldExpression.js.map"],"names":[],"mappings":";;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,aAAa,EAAE,UAAU,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,aAAa,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/file/createBundle.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBundle = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link Bundle}: a container that groups several source files so they
  * can be printed together.
@@ -24,6 +23,7 @@ const make_1 = require("../internal/make");
  * @param _prepends Ignored; kept for signature parity.
  * @returns The created {@link Bundle}.
  */
-const createBundle = (sourceFiles, _prepends) => (0, make_1.make)("Bundle", { sourceFiles });
-exports.createBundle = createBundle;
+const createBundle = (sourceFiles, _prepends) => make("Bundle", { sourceFiles });
+
+export { createBundle };
 //# sourceMappingURL=createBundle.mjs.map

package/lib/factory/file/createBundle.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createBundle.mjs","sources":["createBundle.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createBundle = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link Bundle}: a container that groups several source files so they\n * can be printed together.\n *\n * The `sourceFiles` are emitted in order, each printed as its own file and\n * joined with a blank line between them. This is a simplified model of the\n * legacy bundle node: the `prepends` parameter is accepted for signature parity\n * but ignored, since this package does not model prepended emit helpers.\n *\n * Given two source files that each re-export one binding (`a` from `\"./a\"` and\n * `b` from `\"./b\"`), printing the bundle yields:\n *\n * ```ts\n * export { a } from \"./a\";\n *\n * export { b } from \"./b\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param sourceFiles The bundled source files.\n * @param _prepends Ignored; kept for signature parity.\n * @returns The created {@link Bundle}.\n */\nconst createBundle = (sourceFiles, _prepends) => (0, make_1.make)(\"Bundle\", { sourceFiles });\nexports.createBundle = createBundle;\n//# sourceMappingURL=createBundle.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,YAAY,GAAG,MAAM;AAC7B,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,YAAY,GAAG,CAAC,WAAW,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,CAAC;AAC5F,OAAO,CAAC,YAAY,GAAG,YAAY"}
+{"version":3,"file":"createBundle.mjs","sources":["../../../esm-tmp/factory/file/createBundle.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link Bundle}: a container that groups several source files so they\n * can be printed together.\n *\n * The `sourceFiles` are emitted in order, each printed as its own file and\n * joined with a blank line between them. This is a simplified model of the\n * legacy bundle node: the `prepends` parameter is accepted for signature parity\n * but ignored, since this package does not model prepended emit helpers.\n *\n * Given two source files that each re-export one binding (`a` from `\"./a\"` and\n * `b` from `\"./b\"`), printing the bundle yields:\n *\n * ```ts\n * export { a } from \"./a\";\n *\n * export { b } from \"./b\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param sourceFiles The bundled source files.\n * @param _prepends Ignored; kept for signature parity.\n * @returns The created {@link Bundle}.\n */\nexport const createBundle = (sourceFiles, _prepends) => make(\"Bundle\", { sourceFiles });\n//# sourceMappingURL=createBundle.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;AACA;AACY,MAAC,YAAY,GAAG,CAAC,WAAW,EAAE,SAAS,KAAK,IAAI,CAAC,QAAQ,EAAE,EAAE,WAAW,EAAE;;;;"}

package/lib/factory/file/createNodeArray.mjs

@@ -1,5 +1,3 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodeArray = void 0;
 /**
  * Create a node array from the given elements.
  *
@@ -21,5 +19,6 @@ exports.createNodeArray = void 0;
  * @returns The given elements as a readonly array.
  */
 const createNodeArray = (elements = []) => elements;
-exports.createNodeArray = createNodeArray;
+
+export { createNodeArray };
 //# sourceMappingURL=createNodeArray.mjs.map

package/lib/factory/file/createNodeArray.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createNodeArray.mjs","sources":["createNodeArray.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createNodeArray = void 0;\n/**\n * Create a node array from the given elements.\n *\n * Unlike the legacy compiler, this package does not wrap the elements in a\n * dedicated node-array object. It returns the plain readonly array as-is (an\n * empty array when no elements are passed), so the result has no `kind` and is\n * not itself a printable node. It exists for signature parity where a node\n * array is expected.\n *\n * Given identifiers `a` and `b`, the result is simply the array holding those\n * two nodes, equivalent to writing the array literal yourself:\n *\n * ```ts\n * [a, b];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elements The elements.\n * @returns The given elements as a readonly array.\n */\nconst createNodeArray = (elements = []) => elements;\nexports.createNodeArray = createNodeArray;\n//# sourceMappingURL=createNodeArray.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,eAAe,GAAG,MAAM;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,eAAe,GAAG,CAAC,QAAQ,GAAG,EAAE,KAAK,QAAQ;AACnD,OAAO,CAAC,eAAe,GAAG,eAAe"}
+{"version":3,"file":"createNodeArray.mjs","sources":["../../../esm-tmp/factory/file/createNodeArray.js"],"sourcesContent":["/**\n * Create a node array from the given elements.\n *\n * Unlike the legacy compiler, this package does not wrap the elements in a\n * dedicated node-array object. It returns the plain readonly array as-is (an\n * empty array when no elements are passed), so the result has no `kind` and is\n * not itself a printable node. It exists for signature parity where a node\n * array is expected.\n *\n * Given identifiers `a` and `b`, the result is simply the array holding those\n * two nodes, equivalent to writing the array literal yourself:\n *\n * ```ts\n * [a, b];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elements The elements.\n * @returns The given elements as a readonly array.\n */\nexport const createNodeArray = (elements = []) => elements;\n//# sourceMappingURL=createNodeArray.js.map"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,eAAe,GAAG,CAAC,QAAQ,GAAG,EAAE,KAAK;;;;"}

package/lib/factory/file/createSourceFile.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSourceFile = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link SourceFile}: the root node of one TypeScript file, holding its
  * top-level statements.
@@ -19,6 +18,7 @@ const make_1 = require("../internal/make");
  * @param statements The statements.
  * @returns The created {@link SourceFile}.
  */
-const createSourceFile = (statements) => (0, make_1.make)("SourceFile", { statements });
-exports.createSourceFile = createSourceFile;
+const createSourceFile = (statements) => make("SourceFile", { statements });
+
+export { createSourceFile };
 //# sourceMappingURL=createSourceFile.mjs.map

package/lib/factory/file/createSourceFile.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createSourceFile.mjs","sources":["createSourceFile.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createSourceFile = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link SourceFile}: the root node of one TypeScript file, holding its\n * top-level statements.\n *\n * The `statements` become the file body in order. Printing the source file\n * emits each statement on its own line; an empty list yields an empty file.\n *\n * Given a single import of `a` from `\"./mod\"` as the only statement, this\n * prints:\n *\n * ```ts\n * import { a } from \"./mod\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param statements The statements.\n * @returns The created {@link SourceFile}.\n */\nconst createSourceFile = (statements) => (0, make_1.make)(\"SourceFile\", { statements });\nexports.createSourceFile = createSourceFile;\n//# sourceMappingURL=createSourceFile.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,gBAAgB,GAAG,MAAM;AACjC,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,MAAM,gBAAgB,GAAG,CAAC,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,UAAU,EAAE,CAAC;AACvF,OAAO,CAAC,gBAAgB,GAAG,gBAAgB"}
+{"version":3,"file":"createSourceFile.mjs","sources":["../../../esm-tmp/factory/file/createSourceFile.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link SourceFile}: the root node of one TypeScript file, holding its\n * top-level statements.\n *\n * The `statements` become the file body in order. Printing the source file\n * emits each statement on its own line; an empty list yields an empty file.\n *\n * Given a single import of `a` from `\"./mod\"` as the only statement, this\n * prints:\n *\n * ```ts\n * import { a } from \"./mod\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param statements The statements.\n * @returns The created {@link SourceFile}.\n */\nexport const createSourceFile = (statements) => make(\"SourceFile\", { statements });\n//# sourceMappingURL=createSourceFile.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gBAAgB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,YAAY,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/file/updateSourceFile.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateSourceFile = void 0;
-const createSourceFile_1 = require("./createSourceFile");
+import { createSourceFile } from './createSourceFile.mjs';
+
 /**
  * Create a {@link SourceFile}.
  *
@@ -9,6 +8,7 @@ const createSourceFile_1 = require("./createSourceFile");
  * @param statements The statements.
  * @returns The created {@link SourceFile}.
  */
-const updateSourceFile = (_source, statements) => (0, createSourceFile_1.createSourceFile)(statements);
-exports.updateSourceFile = updateSourceFile;
+const updateSourceFile = (_source, statements) => createSourceFile(statements);
+
+export { updateSourceFile };
 //# sourceMappingURL=updateSourceFile.mjs.map

package/lib/factory/file/updateSourceFile.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"updateSourceFile.mjs","sources":["updateSourceFile.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.updateSourceFile = void 0;\nconst createSourceFile_1 = require(\"./createSourceFile\");\n/**\n * Create a {@link SourceFile}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param _source Ignored; present only to mirror the legacy signature.\n * @param statements The statements.\n * @returns The created {@link SourceFile}.\n */\nconst updateSourceFile = (_source, statements) => (0, createSourceFile_1.createSourceFile)(statements);\nexports.updateSourceFile = updateSourceFile;\n//# sourceMappingURL=updateSourceFile.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,gBAAgB,GAAG,MAAM;AACjC,MAAM,kBAAkB,GAAG,OAAO,CAAC,oBAAoB,CAAC;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,UAAU,KAAK,IAAI,kBAAkB,CAAC,gBAAgB,EAAE,UAAU,CAAC;AACtG,OAAO,CAAC,gBAAgB,GAAG,gBAAgB"}
+{"version":3,"file":"updateSourceFile.mjs","sources":["../../../esm-tmp/factory/file/updateSourceFile.js"],"sourcesContent":["import { createSourceFile } from \"./createSourceFile\";\n/**\n * Create a {@link SourceFile}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param _source Ignored; present only to mirror the legacy signature.\n * @param statements The statements.\n * @returns The created {@link SourceFile}.\n */\nexport const updateSourceFile = (_source, statements) => createSourceFile(statements);\n//# sourceMappingURL=updateSourceFile.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gBAAgB,GAAG,CAAC,OAAO,EAAE,UAAU,KAAK,gBAAgB,CAAC,UAAU;;;;"}

package/lib/factory/imports/createExportAssignment.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExportAssignment = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create an {@link ExportAssignment}: an `export default` or `export =`
  * statement that exports a single expression.
@@ -22,6 +21,7 @@ const make_1 = require("../internal/make");
  * @param expression The expression.
  * @returns The created {@link ExportAssignment}.
  */
-const createExportAssignment = (modifiers, isExportEquals, expression) => (0, make_1.make)("ExportAssignment", { modifiers, isExportEquals, expression });
-exports.createExportAssignment = createExportAssignment;
+const createExportAssignment = (modifiers, isExportEquals, expression) => make("ExportAssignment", { modifiers, isExportEquals, expression });
+
+export { createExportAssignment };
 //# sourceMappingURL=createExportAssignment.mjs.map

package/lib/factory/imports/createExportAssignment.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createExportAssignment.mjs","sources":["createExportAssignment.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createExportAssignment = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link ExportAssignment}: an `export default` or `export =`\n * statement that exports a single expression.\n *\n * Set `isExportEquals` to `true` for the CommonJS-style `export =` form;\n * otherwise the node prints as `export default`. The `expression` is the value\n * being exported.\n *\n * Given the identifier `foo` with `isExportEquals` false, this prints:\n *\n * ```ts\n * export default foo;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param isExportEquals When `true`, emit `export =`; otherwise `export\n *   default`.\n * @param expression The expression.\n * @returns The created {@link ExportAssignment}.\n */\nconst createExportAssignment = (modifiers, isExportEquals, expression) => (0, make_1.make)(\"ExportAssignment\", { modifiers, isExportEquals, expression });\nexports.createExportAssignment = createExportAssignment;\n//# sourceMappingURL=createExportAssignment.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,sBAAsB,GAAG,MAAM;AACvC,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,MAAM,sBAAsB,GAAG,CAAC,SAAS,EAAE,cAAc,EAAE,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,CAAC;AACzJ,OAAO,CAAC,sBAAsB,GAAG,sBAAsB"}
+{"version":3,"file":"createExportAssignment.mjs","sources":["../../../esm-tmp/factory/imports/createExportAssignment.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ExportAssignment}: an `export default` or `export =`\n * statement that exports a single expression.\n *\n * Set `isExportEquals` to `true` for the CommonJS-style `export =` form;\n * otherwise the node prints as `export default`. The `expression` is the value\n * being exported.\n *\n * Given the identifier `foo` with `isExportEquals` false, this prints:\n *\n * ```ts\n * export default foo;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param isExportEquals When `true`, emit `export =`; otherwise `export\n *   default`.\n * @param expression The expression.\n * @returns The created {@link ExportAssignment}.\n */\nexport const createExportAssignment = (modifiers, isExportEquals, expression) => make(\"ExportAssignment\", { modifiers, isExportEquals, expression });\n//# sourceMappingURL=createExportAssignment.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;AACY,MAAC,sBAAsB,GAAG,CAAC,SAAS,EAAE,cAAc,EAAE,UAAU,KAAK,IAAI,CAAC,kBAAkB,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/imports/createExportDeclaration.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExportDeclaration = void 0;
-const make_1 = require("../internal/make");
-const createStringLiteral_1 = require("../literals/createStringLiteral");
+import { make } from '../internal/make.mjs';
+import { createStringLiteral } from '../literals/createStringLiteral.mjs';
+
 /**
  * Create an {@link ExportDeclaration}: an `export { ... }` or `export *`
  * statement, with or without a `from` clause.
@@ -26,13 +25,14 @@ const createStringLiteral_1 = require("../literals/createStringLiteral");
  * @param moduleSpecifier The module specifier (the `from` target).
  * @returns The created {@link ExportDeclaration}.
  */
-const createExportDeclaration = (modifiers, isTypeOnly, exportClause, moduleSpecifier) => (0, make_1.make)("ExportDeclaration", {
+const createExportDeclaration = (modifiers, isTypeOnly, exportClause, moduleSpecifier) => make("ExportDeclaration", {
     modifiers,
     isTypeOnly,
     exportClause,
     moduleSpecifier: typeof moduleSpecifier === "string"
-        ? (0, createStringLiteral_1.createStringLiteral)(moduleSpecifier)
+        ? createStringLiteral(moduleSpecifier)
         : moduleSpecifier,
 });
-exports.createExportDeclaration = createExportDeclaration;
+
+export { createExportDeclaration };
 //# sourceMappingURL=createExportDeclaration.mjs.map

package/lib/factory/imports/createExportDeclaration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createExportDeclaration.mjs","sources":["createExportDeclaration.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createExportDeclaration = void 0;\nconst make_1 = require(\"../internal/make\");\nconst createStringLiteral_1 = require(\"../literals/createStringLiteral\");\n/**\n * Create an {@link ExportDeclaration}: an `export { ... }` or `export *`\n * statement, with or without a `from` clause.\n *\n * The `exportClause` selects what is exported. Pass {@link NamedExports} for\n * `export { a, b }`, a {@link NamespaceExport} for `export * as ns`, or omit it\n * (undefined) for a bare `export *`. Set `isTypeOnly` to emit `export type`.\n * The `moduleSpecifier` is optional: supply it for a re-export with `from`, or\n * leave it off to export local bindings. A raw string is wrapped in a string\n * literal.\n *\n * Given named exports of `a` re-exported from `\"./mod\"`, this prints:\n *\n * ```ts\n * export { a } from \"./mod\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param isTypeOnly Whether this is a type-only import/export.\n * @param exportClause The export clause; omitted for `export *`.\n * @param moduleSpecifier The module specifier (the `from` target).\n * @returns The created {@link ExportDeclaration}.\n */\nconst createExportDeclaration = (modifiers, isTypeOnly, exportClause, moduleSpecifier) => (0, make_1.make)(\"ExportDeclaration\", {\n    modifiers,\n    isTypeOnly,\n    exportClause,\n    moduleSpecifier: typeof moduleSpecifier === \"string\"\n        ? (0, createStringLiteral_1.createStringLiteral)(moduleSpecifier)\n        : moduleSpecifier,\n});\nexports.createExportDeclaration = createExportDeclaration;\n//# sourceMappingURL=createExportDeclaration.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,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C,MAAM,qBAAqB,GAAG,OAAO,CAAC,iCAAiC,CAAC;AACxE;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,UAAU,EAAE,YAAY,EAAE,eAAe,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,mBAAmB,EAAE;AAChI,IAAI,SAAS;AACb,IAAI,UAAU;AACd,IAAI,YAAY;AAChB,IAAI,eAAe,EAAE,OAAO,eAAe,KAAK;AAChD,UAAU,IAAI,qBAAqB,CAAC,mBAAmB,EAAE,eAAe;AACxE,UAAU,eAAe;AACzB,CAAC,CAAC;AACF,OAAO,CAAC,uBAAuB,GAAG,uBAAuB"}
+{"version":3,"file":"createExportDeclaration.mjs","sources":["../../../esm-tmp/factory/imports/createExportDeclaration.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createStringLiteral } from \"../literals/createStringLiteral\";\n/**\n * Create an {@link ExportDeclaration}: an `export { ... }` or `export *`\n * statement, with or without a `from` clause.\n *\n * The `exportClause` selects what is exported. Pass {@link NamedExports} for\n * `export { a, b }`, a {@link NamespaceExport} for `export * as ns`, or omit it\n * (undefined) for a bare `export *`. Set `isTypeOnly` to emit `export type`.\n * The `moduleSpecifier` is optional: supply it for a re-export with `from`, or\n * leave it off to export local bindings. A raw string is wrapped in a string\n * literal.\n *\n * Given named exports of `a` re-exported from `\"./mod\"`, this prints:\n *\n * ```ts\n * export { a } from \"./mod\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param isTypeOnly Whether this is a type-only import/export.\n * @param exportClause The export clause; omitted for `export *`.\n * @param moduleSpecifier The module specifier (the `from` target).\n * @returns The created {@link ExportDeclaration}.\n */\nexport const createExportDeclaration = (modifiers, isTypeOnly, exportClause, moduleSpecifier) => make(\"ExportDeclaration\", {\n    modifiers,\n    isTypeOnly,\n    exportClause,\n    moduleSpecifier: typeof moduleSpecifier === \"string\"\n        ? createStringLiteral(moduleSpecifier)\n        : moduleSpecifier,\n});\n//# sourceMappingURL=createExportDeclaration.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,uBAAuB,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,eAAe,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC3H,IAAI,SAAS;AACb,IAAI,UAAU;AACd,IAAI,YAAY;AAChB,IAAI,eAAe,EAAE,OAAO,eAAe,KAAK;AAChD,UAAU,mBAAmB,CAAC,eAAe;AAC7C,UAAU,eAAe;AACzB,CAAC;;;;"}

package/lib/factory/imports/createExportDefault.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExportDefault = void 0;
-const createExportAssignment_1 = require("./createExportAssignment");
+import { createExportAssignment } from './createExportAssignment.mjs';
+
 /**
  * Create an `export default` statement for the given expression.
  *
@@ -18,6 +17,7 @@ const createExportAssignment_1 = require("./createExportAssignment");
  * @param expression The expression.
  * @returns The created {@link ExportAssignment}.
  */
-const createExportDefault = (expression) => (0, createExportAssignment_1.createExportAssignment)(undefined, false, expression);
-exports.createExportDefault = createExportDefault;
+const createExportDefault = (expression) => createExportAssignment(undefined, false, expression);
+
+export { createExportDefault };
 //# sourceMappingURL=createExportDefault.mjs.map

package/lib/factory/imports/createExportDefault.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createExportDefault.mjs","sources":["createExportDefault.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createExportDefault = void 0;\nconst createExportAssignment_1 = require(\"./createExportAssignment\");\n/**\n * Create an `export default` statement for the given expression.\n *\n * This is a convenience wrapper over {@link createExportAssignment} with the\n * modifiers omitted and `isExportEquals` fixed to `false`, so it always\n * produces the `export default` form rather than `export =`.\n *\n * Given the identifier `foo`, this prints:\n *\n * ```ts\n * export default foo;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @returns The created {@link ExportAssignment}.\n */\nconst createExportDefault = (expression) => (0, createExportAssignment_1.createExportAssignment)(undefined, false, expression);\nexports.createExportDefault = createExportDefault;\n//# sourceMappingURL=createExportDefault.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,mBAAmB,GAAG,MAAM;AACpC,MAAM,wBAAwB,GAAG,OAAO,CAAC,0BAA0B,CAAC;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,mBAAmB,GAAG,CAAC,UAAU,KAAK,IAAI,wBAAwB,CAAC,sBAAsB,EAAE,SAAS,EAAE,KAAK,EAAE,UAAU,CAAC;AAC9H,OAAO,CAAC,mBAAmB,GAAG,mBAAmB"}
+{"version":3,"file":"createExportDefault.mjs","sources":["../../../esm-tmp/factory/imports/createExportDefault.js"],"sourcesContent":["import { createExportAssignment } from \"./createExportAssignment\";\n/**\n * Create an `export default` statement for the given expression.\n *\n * This is a convenience wrapper over {@link createExportAssignment} with the\n * modifiers omitted and `isExportEquals` fixed to `false`, so it always\n * produces the `export default` form rather than `export =`.\n *\n * Given the identifier `foo`, this prints:\n *\n * ```ts\n * export default foo;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @returns The created {@link ExportAssignment}.\n */\nexport const createExportDefault = (expression) => createExportAssignment(undefined, false, expression);\n//# sourceMappingURL=createExportDefault.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,UAAU,KAAK,sBAAsB,CAAC,SAAS,EAAE,KAAK,EAAE,UAAU;;;;"}

package/lib/factory/imports/createExportSpecifier.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExportSpecifier = void 0;
-const asName_1 = require("../internal/asName");
-const make_1 = require("../internal/make");
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
 /**
  * Create an {@link ExportSpecifier}: one entry inside a {@link NamedExports}
  * brace group.
@@ -23,10 +22,11 @@ const make_1 = require("../internal/make");
  * @param name The name.
  * @returns The created {@link ExportSpecifier}.
  */
-const createExportSpecifier = (isTypeOnly, propertyName, name) => (0, make_1.make)("ExportSpecifier", {
+const createExportSpecifier = (isTypeOnly, propertyName, name) => make("ExportSpecifier", {
     isTypeOnly,
-    propertyName: propertyName === undefined ? undefined : (0, asName_1.asName)(propertyName),
-    name: (0, asName_1.asName)(name),
+    propertyName: propertyName === undefined ? undefined : asName(propertyName),
+    name: asName(name),
 });
-exports.createExportSpecifier = createExportSpecifier;
+
+export { createExportSpecifier };
 //# sourceMappingURL=createExportSpecifier.mjs.map

package/lib/factory/imports/createExportSpecifier.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createExportSpecifier.mjs","sources":["createExportSpecifier.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createExportSpecifier = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link ExportSpecifier}: one entry inside a {@link NamedExports}\n * brace group.\n *\n * Pass `propertyName` to export a local binding under a different name, which\n * prints as `propertyName as name`; leave it undefined for a plain binding.\n * Both names accept a raw string and are wrapped in identifiers for you. Set\n * `isTypeOnly` to prefix the single specifier with `type`.\n *\n * Given source name `x` aliased to `y`, this prints:\n *\n * ```ts\n * x as y;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param isTypeOnly Whether this is a type-only import/export.\n * @param propertyName The original (source) name, when aliased.\n * @param name The name.\n * @returns The created {@link ExportSpecifier}.\n */\nconst createExportSpecifier = (isTypeOnly, propertyName, name) => (0, make_1.make)(\"ExportSpecifier\", {\n    isTypeOnly,\n    propertyName: propertyName === undefined ? undefined : (0, asName_1.asName)(propertyName),\n    name: (0, asName_1.asName)(name),\n});\nexports.createExportSpecifier = createExportSpecifier;\n//# sourceMappingURL=createExportSpecifier.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,qBAAqB,GAAG,MAAM;AACtC,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,MAAM,qBAAqB,GAAG,CAAC,UAAU,EAAE,YAAY,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,iBAAiB,EAAE;AACtG,IAAI,UAAU;AACd,IAAI,YAAY,EAAE,YAAY,KAAK,SAAS,GAAG,SAAS,GAAG,IAAI,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;AAC7F,IAAI,IAAI,EAAE,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,CAAC,CAAC;AACF,OAAO,CAAC,qBAAqB,GAAG,qBAAqB"}
+{"version":3,"file":"createExportSpecifier.mjs","sources":["../../../esm-tmp/factory/imports/createExportSpecifier.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create an {@link ExportSpecifier}: one entry inside a {@link NamedExports}\n * brace group.\n *\n * Pass `propertyName` to export a local binding under a different name, which\n * prints as `propertyName as name`; leave it undefined for a plain binding.\n * Both names accept a raw string and are wrapped in identifiers for you. Set\n * `isTypeOnly` to prefix the single specifier with `type`.\n *\n * Given source name `x` aliased to `y`, this prints:\n *\n * ```ts\n * x as y;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param isTypeOnly Whether this is a type-only import/export.\n * @param propertyName The original (source) name, when aliased.\n * @param name The name.\n * @returns The created {@link ExportSpecifier}.\n */\nexport const createExportSpecifier = (isTypeOnly, propertyName, name) => make(\"ExportSpecifier\", {\n    isTypeOnly,\n    propertyName: propertyName === undefined ? undefined : asName(propertyName),\n    name: asName(name),\n});\n//# sourceMappingURL=createExportSpecifier.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;AACY,MAAC,qBAAqB,GAAG,CAAC,UAAU,EAAE,YAAY,EAAE,IAAI,KAAK,IAAI,CAAC,iBAAiB,EAAE;AACjG,IAAI,UAAU;AACd,IAAI,YAAY,EAAE,YAAY,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,YAAY,CAAC;AAC/E,IAAI,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;AACtB,CAAC;;;;"}

package/lib/factory/imports/createExternalModuleExport.mjs

@@ -1,8 +1,7 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExternalModuleExport = void 0;
-const createExportDeclaration_1 = require("./createExportDeclaration");
-const createExportSpecifier_1 = require("./createExportSpecifier");
-const createNamedExports_1 = require("./createNamedExports");
+import { createExportDeclaration } from './createExportDeclaration.mjs';
+import { createExportSpecifier } from './createExportSpecifier.mjs';
+import { createNamedExports } from './createNamedExports.mjs';
+
 /**
  * Create an `export { name }` statement that re-exports a single local binding.
  *
@@ -21,6 +20,7 @@ const createNamedExports_1 = require("./createNamedExports");
  * @param exportName The exportName.
  * @returns The created {@link ExportDeclaration}.
  */
-const createExternalModuleExport = (exportName) => (0, createExportDeclaration_1.createExportDeclaration)(undefined, false, (0, createNamedExports_1.createNamedExports)([(0, createExportSpecifier_1.createExportSpecifier)(false, undefined, exportName)]), undefined);
-exports.createExternalModuleExport = createExternalModuleExport;
+const createExternalModuleExport = (exportName) => createExportDeclaration(undefined, false, createNamedExports([createExportSpecifier(false, undefined, exportName)]), undefined);
+
+export { createExternalModuleExport };
 //# sourceMappingURL=createExternalModuleExport.mjs.map

package/lib/factory/imports/createExternalModuleExport.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createExternalModuleExport.mjs","sources":["createExternalModuleExport.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createExternalModuleExport = void 0;\nconst createExportDeclaration_1 = require(\"./createExportDeclaration\");\nconst createExportSpecifier_1 = require(\"./createExportSpecifier\");\nconst createNamedExports_1 = require(\"./createNamedExports\");\n/**\n * Create an `export { name }` statement that re-exports a single local binding.\n *\n * This is a convenience wrapper that builds an {@link ExportDeclaration} whose\n * clause is a {@link NamedExports} holding one unaliased {@link ExportSpecifier}\n * for `exportName`, with no `from` specifier. The name accepts a raw string and\n * is wrapped in an identifier for you.\n *\n * Given the export name `foo`, this prints:\n *\n * ```ts\n * export { foo };\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param exportName The exportName.\n * @returns The created {@link ExportDeclaration}.\n */\nconst createExternalModuleExport = (exportName) => (0, createExportDeclaration_1.createExportDeclaration)(undefined, false, (0, createNamedExports_1.createNamedExports)([(0, createExportSpecifier_1.createExportSpecifier)(false, undefined, exportName)]), undefined);\nexports.createExternalModuleExport = createExternalModuleExport;\n//# sourceMappingURL=createExternalModuleExport.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,yBAAyB,GAAG,OAAO,CAAC,2BAA2B,CAAC;AACtE,MAAM,uBAAuB,GAAG,OAAO,CAAC,yBAAyB,CAAC;AAClE,MAAM,oBAAoB,GAAG,OAAO,CAAC,sBAAsB,CAAC;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,0BAA0B,GAAG,CAAC,UAAU,KAAK,IAAI,yBAAyB,CAAC,uBAAuB,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,oBAAoB,CAAC,kBAAkB,EAAE,CAAC,IAAI,uBAAuB,CAAC,qBAAqB,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC;AACxQ,OAAO,CAAC,0BAA0B,GAAG,0BAA0B"}
+{"version":3,"file":"createExternalModuleExport.mjs","sources":["../../../esm-tmp/factory/imports/createExternalModuleExport.js"],"sourcesContent":["import { createExportDeclaration } from \"./createExportDeclaration\";\nimport { createExportSpecifier } from \"./createExportSpecifier\";\nimport { createNamedExports } from \"./createNamedExports\";\n/**\n * Create an `export { name }` statement that re-exports a single local binding.\n *\n * This is a convenience wrapper that builds an {@link ExportDeclaration} whose\n * clause is a {@link NamedExports} holding one unaliased {@link ExportSpecifier}\n * for `exportName`, with no `from` specifier. The name accepts a raw string and\n * is wrapped in an identifier for you.\n *\n * Given the export name `foo`, this prints:\n *\n * ```ts\n * export { foo };\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param exportName The exportName.\n * @returns The created {@link ExportDeclaration}.\n */\nexport const createExternalModuleExport = (exportName) => createExportDeclaration(undefined, false, createNamedExports([createExportSpecifier(false, undefined, exportName)]), undefined);\n//# sourceMappingURL=createExternalModuleExport.js.map"],"names":[],"mappings":";;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,0BAA0B,GAAG,CAAC,UAAU,KAAK,uBAAuB,CAAC,SAAS,EAAE,KAAK,EAAE,kBAAkB,CAAC,CAAC,qBAAqB,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS;;;;"}

package/lib/factory/imports/createImportAttribute.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createImportAttribute = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create an {@link ImportAttribute}: one `name: value` entry inside an
  * {@link ImportAttributes} clause.
@@ -20,6 +19,7 @@ const make_1 = require("../internal/make");
  * @param value The attribute value.
  * @returns The created {@link ImportAttribute}.
  */
-const createImportAttribute = (name, value) => (0, make_1.make)("ImportAttribute", { name, value });
-exports.createImportAttribute = createImportAttribute;
+const createImportAttribute = (name, value) => make("ImportAttribute", { name, value });
+
+export { createImportAttribute };
 //# sourceMappingURL=createImportAttribute.mjs.map

package/lib/factory/imports/createImportAttribute.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createImportAttribute.mjs","sources":["createImportAttribute.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createImportAttribute = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link ImportAttribute}: one `name: value` entry inside an\n * {@link ImportAttributes} clause.\n *\n * The `name` is an identifier or string literal key and the `value` is the\n * attribute expression, almost always a string literal. The printer separates\n * the two with `: `.\n *\n * Given a `\"type\"` name and a `\"json\"` string value, this prints:\n *\n * ```ts\n * \"type\": \"json\"\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The attribute name.\n * @param value The attribute value.\n * @returns The created {@link ImportAttribute}.\n */\nconst createImportAttribute = (name, value) => (0, make_1.make)(\"ImportAttribute\", { name, value });\nexports.createImportAttribute = createImportAttribute;\n//# sourceMappingURL=createImportAttribute.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,qBAAqB,GAAG,MAAM;AACtC,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,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;AACnG,OAAO,CAAC,qBAAqB,GAAG,qBAAqB"}
+{"version":3,"file":"createImportAttribute.mjs","sources":["../../../esm-tmp/factory/imports/createImportAttribute.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ImportAttribute}: one `name: value` entry inside an\n * {@link ImportAttributes} clause.\n *\n * The `name` is an identifier or string literal key and the `value` is the\n * attribute expression, almost always a string literal. The printer separates\n * the two with `: `.\n *\n * Given a `\"type\"` name and a `\"json\"` string value, this prints:\n *\n * ```ts\n * \"type\": \"json\"\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The attribute name.\n * @param value The attribute value.\n * @returns The created {@link ImportAttribute}.\n */\nexport const createImportAttribute = (name, value) => make(\"ImportAttribute\", { name, value });\n//# sourceMappingURL=createImportAttribute.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,qBAAqB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE;;;;"}

package/lib/factory/imports/createImportAttributes.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createImportAttributes = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create an {@link ImportAttributes}: the `with { ... }` (or legacy `assert {
  * ... }`) clause that annotates an import with metadata such as the resource
@@ -25,6 +24,7 @@ const make_1 = require("../internal/make");
  * @param token The introducing keyword; defaults to `"with"`.
  * @returns The created {@link ImportAttributes}.
  */
-const createImportAttributes = (elements, multiLine, token = "with") => (0, make_1.make)("ImportAttributes", { elements, multiLine, token });
-exports.createImportAttributes = createImportAttributes;
+const createImportAttributes = (elements, multiLine, token = "with") => make("ImportAttributes", { elements, multiLine, token });
+
+export { createImportAttributes };
 //# sourceMappingURL=createImportAttributes.mjs.map

package/lib/factory/imports/createImportAttributes.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createImportAttributes.mjs","sources":["createImportAttributes.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createImportAttributes = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link ImportAttributes}: the `with { ... }` (or legacy `assert {\n * ... }`) clause that annotates an import with metadata such as the resource\n * type.\n *\n * The `token` selects the introducing keyword: `\"with\"` (the default, current\n * syntax) or the legacy `\"assert\"`. Each element is an {@link ImportAttribute}\n * key/value entry. An empty list still prints the keyword and braces.\n *\n * Note that the printer does not attach this clause to the import or export\n * statements emitted by this package, so it surfaces only when you print the\n * attributes node directly. Given a single `\"type\": \"json\"` entry under the\n * `with` keyword, that direct print is:\n *\n * ```ts\n * with { \"type\": \"json\" }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elements The attribute entries.\n * @param multiLine When `true`, print one entry per line.\n * @param token The introducing keyword; defaults to `\"with\"`.\n * @returns The created {@link ImportAttributes}.\n */\nconst createImportAttributes = (elements, multiLine, token = \"with\") => (0, make_1.make)(\"ImportAttributes\", { elements, multiLine, token });\nexports.createImportAttributes = createImportAttributes;\n//# sourceMappingURL=createImportAttributes.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,sBAAsB,GAAG,MAAM;AACvC,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,MAAM,sBAAsB,GAAG,CAAC,QAAQ,EAAE,SAAS,EAAE,KAAK,GAAG,MAAM,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;AAC5I,OAAO,CAAC,sBAAsB,GAAG,sBAAsB"}
+{"version":3,"file":"createImportAttributes.mjs","sources":["../../../esm-tmp/factory/imports/createImportAttributes.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ImportAttributes}: the `with { ... }` (or legacy `assert {\n * ... }`) clause that annotates an import with metadata such as the resource\n * type.\n *\n * The `token` selects the introducing keyword: `\"with\"` (the default, current\n * syntax) or the legacy `\"assert\"`. Each element is an {@link ImportAttribute}\n * key/value entry. An empty list still prints the keyword and braces.\n *\n * Note that the printer does not attach this clause to the import or export\n * statements emitted by this package, so it surfaces only when you print the\n * attributes node directly. Given a single `\"type\": \"json\"` entry under the\n * `with` keyword, that direct print is:\n *\n * ```ts\n * with { \"type\": \"json\" }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elements The attribute entries.\n * @param multiLine When `true`, print one entry per line.\n * @param token The introducing keyword; defaults to `\"with\"`.\n * @returns The created {@link ImportAttributes}.\n */\nexport const createImportAttributes = (elements, multiLine, token = \"with\") => make(\"ImportAttributes\", { elements, multiLine, token });\n//# sourceMappingURL=createImportAttributes.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;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,QAAQ,EAAE,SAAS,EAAE,KAAK,GAAG,MAAM,KAAK,IAAI,CAAC,kBAAkB,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE;;;;"}

package/lib/factory/imports/createImportClause.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createImportClause = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create an {@link ImportClause}: the part of an import statement between
  * `import` and `from`.
@@ -22,6 +21,7 @@ const make_1 = require("../internal/make");
  * @param namedBindings The named or namespace bindings, if any.
  * @returns The created {@link ImportClause}.
  */
-const createImportClause = (isTypeOnly, name, namedBindings) => (0, make_1.make)("ImportClause", { isTypeOnly, name, namedBindings });
-exports.createImportClause = createImportClause;
+const createImportClause = (isTypeOnly, name, namedBindings) => make("ImportClause", { isTypeOnly, name, namedBindings });
+
+export { createImportClause };
 //# sourceMappingURL=createImportClause.mjs.map

package/lib/factory/imports/createImportClause.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createImportClause.mjs","sources":["createImportClause.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createImportClause = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link ImportClause}: the part of an import statement between\n * `import` and `from`.\n *\n * The `name` is the default-import binding, if any. The `namedBindings` slot\n * holds either a {@link NamedImports} brace group or a {@link NamespaceImport}. A\n * default binding and named bindings can appear together, joined by a comma.\n * Set `isTypeOnly` to prefix the clause with `type`.\n *\n * Given a default binding `Def` plus named import `a`, this prints:\n *\n * ```ts\n * (Def, { a });\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param isTypeOnly Whether this is a type-only import/export.\n * @param name The name.\n * @param namedBindings The named or namespace bindings, if any.\n * @returns The created {@link ImportClause}.\n */\nconst createImportClause = (isTypeOnly, name, namedBindings) => (0, make_1.make)(\"ImportClause\", { isTypeOnly, name, namedBindings });\nexports.createImportClause = createImportClause;\n//# sourceMappingURL=createImportClause.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,kBAAkB,GAAG,MAAM;AACnC,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,MAAM,kBAAkB,GAAG,CAAC,UAAU,EAAE,IAAI,EAAE,aAAa,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;AACrI,OAAO,CAAC,kBAAkB,GAAG,kBAAkB"}
+{"version":3,"file":"createImportClause.mjs","sources":["../../../esm-tmp/factory/imports/createImportClause.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ImportClause}: the part of an import statement between\n * `import` and `from`.\n *\n * The `name` is the default-import binding, if any. The `namedBindings` slot\n * holds either a {@link NamedImports} brace group or a {@link NamespaceImport}. A\n * default binding and named bindings can appear together, joined by a comma.\n * Set `isTypeOnly` to prefix the clause with `type`.\n *\n * Given a default binding `Def` plus named import `a`, this prints:\n *\n * ```ts\n * (Def, { a });\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param isTypeOnly Whether this is a type-only import/export.\n * @param name The name.\n * @param namedBindings The named or namespace bindings, if any.\n * @returns The created {@link ImportClause}.\n */\nexport const createImportClause = (isTypeOnly, name, namedBindings) => make(\"ImportClause\", { isTypeOnly, name, namedBindings });\n//# sourceMappingURL=createImportClause.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;AACY,MAAC,kBAAkB,GAAG,CAAC,UAAU,EAAE,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,aAAa,EAAE;;;;"}

package/lib/factory/imports/createImportDeclaration.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createImportDeclaration = void 0;
-const make_1 = require("../internal/make");
-const createStringLiteral_1 = require("../literals/createStringLiteral");
+import { make } from '../internal/make.mjs';
+import { createStringLiteral } from '../literals/createStringLiteral.mjs';
+
 /**
  * Create an {@link ImportDeclaration}: an `import ... from "..."` statement.
  *
@@ -23,12 +22,13 @@ const createStringLiteral_1 = require("../literals/createStringLiteral");
  * @param moduleSpecifier The module specifier (the `from` target).
  * @returns The created {@link ImportDeclaration}.
  */
-const createImportDeclaration = (modifiers, importClause, moduleSpecifier) => (0, make_1.make)("ImportDeclaration", {
+const createImportDeclaration = (modifiers, importClause, moduleSpecifier) => make("ImportDeclaration", {
     modifiers,
     importClause,
     moduleSpecifier: typeof moduleSpecifier === "string"
-        ? (0, createStringLiteral_1.createStringLiteral)(moduleSpecifier)
+        ? createStringLiteral(moduleSpecifier)
         : moduleSpecifier,
 });
-exports.createImportDeclaration = createImportDeclaration;
+
+export { createImportDeclaration };
 //# sourceMappingURL=createImportDeclaration.mjs.map

package/lib/factory/imports/createImportDeclaration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createImportDeclaration.mjs","sources":["createImportDeclaration.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createImportDeclaration = void 0;\nconst make_1 = require(\"../internal/make\");\nconst createStringLiteral_1 = require(\"../literals/createStringLiteral\");\n/**\n * Create an {@link ImportDeclaration}: an `import ... from \"...\"` statement.\n *\n * The `importClause` carries the default binding, namespace binding, and named\n * bindings. Omit it to emit a side-effect-only import that just runs the module\n * for its effects. The `moduleSpecifier` is the `from` target; pass a raw\n * string and it is wrapped in a string literal for you, or pass an expression\n * node directly.\n *\n * Given a named import of `a` from `\"./mod\"`, this prints:\n *\n * ```ts\n * import { a } from \"./mod\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param importClause The import clause; omitted for a side-effect-only import.\n * @param moduleSpecifier The module specifier (the `from` target).\n * @returns The created {@link ImportDeclaration}.\n */\nconst createImportDeclaration = (modifiers, importClause, moduleSpecifier) => (0, make_1.make)(\"ImportDeclaration\", {\n    modifiers,\n    importClause,\n    moduleSpecifier: typeof moduleSpecifier === \"string\"\n        ? (0, createStringLiteral_1.createStringLiteral)(moduleSpecifier)\n        : moduleSpecifier,\n});\nexports.createImportDeclaration = createImportDeclaration;\n//# sourceMappingURL=createImportDeclaration.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,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C,MAAM,qBAAqB,GAAG,OAAO,CAAC,iCAAiC,CAAC;AACxE;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,YAAY,EAAE,eAAe,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,mBAAmB,EAAE;AACpH,IAAI,SAAS;AACb,IAAI,YAAY;AAChB,IAAI,eAAe,EAAE,OAAO,eAAe,KAAK;AAChD,UAAU,IAAI,qBAAqB,CAAC,mBAAmB,EAAE,eAAe;AACxE,UAAU,eAAe;AACzB,CAAC,CAAC;AACF,OAAO,CAAC,uBAAuB,GAAG,uBAAuB"}
+{"version":3,"file":"createImportDeclaration.mjs","sources":["../../../esm-tmp/factory/imports/createImportDeclaration.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createStringLiteral } from \"../literals/createStringLiteral\";\n/**\n * Create an {@link ImportDeclaration}: an `import ... from \"...\"` statement.\n *\n * The `importClause` carries the default binding, namespace binding, and named\n * bindings. Omit it to emit a side-effect-only import that just runs the module\n * for its effects. The `moduleSpecifier` is the `from` target; pass a raw\n * string and it is wrapped in a string literal for you, or pass an expression\n * node directly.\n *\n * Given a named import of `a` from `\"./mod\"`, this prints:\n *\n * ```ts\n * import { a } from \"./mod\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param importClause The import clause; omitted for a side-effect-only import.\n * @param moduleSpecifier The module specifier (the `from` target).\n * @returns The created {@link ImportDeclaration}.\n */\nexport const createImportDeclaration = (modifiers, importClause, moduleSpecifier) => make(\"ImportDeclaration\", {\n    modifiers,\n    importClause,\n    moduleSpecifier: typeof moduleSpecifier === \"string\"\n        ? createStringLiteral(moduleSpecifier)\n        : moduleSpecifier,\n});\n//# sourceMappingURL=createImportDeclaration.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;AACY,MAAC,uBAAuB,GAAG,CAAC,SAAS,EAAE,YAAY,EAAE,eAAe,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC/G,IAAI,SAAS;AACb,IAAI,YAAY;AAChB,IAAI,eAAe,EAAE,OAAO,eAAe,KAAK;AAChD,UAAU,mBAAmB,CAAC,eAAe;AAC7C,UAAU,eAAe;AACzB,CAAC;;;;"}

package/lib/factory/imports/createImportSpecifier.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createImportSpecifier = void 0;
-const asName_1 = require("../internal/asName");
-const make_1 = require("../internal/make");
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
 /**
  * Create an {@link ImportSpecifier}: one entry inside a {@link NamedImports}
  * brace group.
@@ -23,6 +22,7 @@ const make_1 = require("../internal/make");
  * @param name The name.
  * @returns The created {@link ImportSpecifier}.
  */
-const createImportSpecifier = (isTypeOnly, propertyName, name) => (0, make_1.make)("ImportSpecifier", { isTypeOnly, propertyName, name: (0, asName_1.asName)(name) });
-exports.createImportSpecifier = createImportSpecifier;
+const createImportSpecifier = (isTypeOnly, propertyName, name) => make("ImportSpecifier", { isTypeOnly, propertyName, name: asName(name) });
+
+export { createImportSpecifier };
 //# sourceMappingURL=createImportSpecifier.mjs.map

package/lib/factory/imports/createImportSpecifier.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createImportSpecifier.mjs","sources":["createImportSpecifier.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createImportSpecifier = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link ImportSpecifier}: one entry inside a {@link NamedImports}\n * brace group.\n *\n * Pass `propertyName` to alias an export under a different local name, which\n * prints as `propertyName as name`; leave it undefined for a plain binding. The\n * `name` accepts a raw string and is wrapped in an identifier for you. Set\n * `isTypeOnly` to prefix the single specifier with `type`.\n *\n * Given source name `x` aliased to `y`, this prints:\n *\n * ```ts\n * x as y;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param isTypeOnly Whether this is a type-only import/export.\n * @param propertyName The original (source) name, when aliased.\n * @param name The name.\n * @returns The created {@link ImportSpecifier}.\n */\nconst createImportSpecifier = (isTypeOnly, propertyName, name) => (0, make_1.make)(\"ImportSpecifier\", { isTypeOnly, propertyName, name: (0, asName_1.asName)(name) });\nexports.createImportSpecifier = createImportSpecifier;\n//# sourceMappingURL=createImportSpecifier.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,qBAAqB,GAAG,MAAM;AACtC,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,MAAM,qBAAqB,GAAG,CAAC,UAAU,EAAE,YAAY,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,UAAU,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC;AACrK,OAAO,CAAC,qBAAqB,GAAG,qBAAqB"}
+{"version":3,"file":"createImportSpecifier.mjs","sources":["../../../esm-tmp/factory/imports/createImportSpecifier.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create an {@link ImportSpecifier}: one entry inside a {@link NamedImports}\n * brace group.\n *\n * Pass `propertyName` to alias an export under a different local name, which\n * prints as `propertyName as name`; leave it undefined for a plain binding. The\n * `name` accepts a raw string and is wrapped in an identifier for you. Set\n * `isTypeOnly` to prefix the single specifier with `type`.\n *\n * Given source name `x` aliased to `y`, this prints:\n *\n * ```ts\n * x as y;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param isTypeOnly Whether this is a type-only import/export.\n * @param propertyName The original (source) name, when aliased.\n * @param name The name.\n * @returns The created {@link ImportSpecifier}.\n */\nexport const createImportSpecifier = (isTypeOnly, propertyName, name) => make(\"ImportSpecifier\", { isTypeOnly, propertyName, name: asName(name) });\n//# sourceMappingURL=createImportSpecifier.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;AACY,MAAC,qBAAqB,GAAG,CAAC,UAAU,EAAE,YAAY,EAAE,IAAI,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,UAAU,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;;;;"}