@ttsc/factory 0.15.9 → 0.15.10

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeOfExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createTypeOfExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TypeOfExpression}: the `typeof` operator applied to a value.\n *\n * `expression` is the operand. The printer writes the `typeof` keyword followed\n * by a single space and then the operand.\n *\n * With `expression` of `x`, the printer emits:\n *\n * ```ts\n * typeof x;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The operand of `typeof`.\n * @returns The created {@link TypeOfExpression}.\n */\nexport const createTypeOfExpression = (expression) => make(\"TypeOfExpression\", { expression });\n//# sourceMappingURL=createTypeOfExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,kBAAkB,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/expressions/createUnsignedRightShift.mjs

@@ -0,0 +1,23 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * Create an unsigned right-shift expression: `left >>> right`.
+ *
+ * Thin wrapper over {@link createBinaryExpression} with the `>>>` operator.
+ *
+ * With `left` of `a` and `right` of `b`, the printer emits:
+ *
+ * ```ts
+ * a >>> b;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param left The left-hand operand.
+ * @param right The right-hand operand.
+ * @returns The created {@link BinaryExpression}.
+ */
+const createUnsignedRightShift = (left, right) => createBinaryExpression(left, SyntaxKind.GreaterThanGreaterThanGreaterThanToken, right);
+
+export { createUnsignedRightShift };
+//# sourceMappingURL=createUnsignedRightShift.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link VoidExpression}: the `void` operator applied to a value.
+ *
+ * `expression` is the operand, which is evaluated and then discarded so the
+ * whole expression yields `undefined`. The printer writes the `void` keyword, a
+ * single space, and the operand.
+ *
+ * With `expression` of `0`, the printer emits:
+ *
+ * ```ts
+ * void 0;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The operand of `void`.
+ * @returns The created {@link VoidExpression}.
+ */
+const createVoidExpression = (expression) => make("VoidExpression", { expression });
+
+export { createVoidExpression };
+//# sourceMappingURL=createVoidExpression.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,22 @@
+import { createNumericLiteral } from '../literals/createNumericLiteral.mjs';
+import { createVoidExpression } from './createVoidExpression.mjs';
+
+/**
+ * Create the `void 0` expression, the canonical way to spell `undefined`.
+ *
+ * Thin wrapper over {@link createVoidExpression} with the numeric literal `0` as
+ * its operand.
+ *
+ * The printer emits:
+ *
+ * ```ts
+ * void 0;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link VoidExpression}.
+ */
+const createVoidZero = () => createVoidExpression(createNumericLiteral("0"));
+
+export { createVoidZero };
+//# sourceMappingURL=createVoidZero.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,26 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link YieldExpression}: a `yield` inside a generator.
+ *
+ * `asteriskToken`, when present, makes this a delegating `yield*`; otherwise a
+ * plain `yield` is emitted. `expression` is the yielded value and may be
+ * omitted for a bare `yield`. When a value is present the printer separates the
+ * keyword from it with a single space; `yield*` attaches the asterisk directly
+ * to the keyword.
+ *
+ * With no asterisk and `expression` of `x`, the printer emits:
+ *
+ * ```ts
+ * yield x;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param asteriskToken The `*` token for a delegating `yield*`, if any.
+ * @param expression The yielded value, if any.
+ * @returns The created {@link YieldExpression}.
+ */
+const createYieldExpression = (asteriskToken, expression) => make("YieldExpression", { asteriskToken, expression });
+
+export { createYieldExpression };
+//# sourceMappingURL=createYieldExpression.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,29 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link Bundle}: a container that groups several source files so they
+ * can be printed together.
+ *
+ * The `sourceFiles` are emitted in order, each printed as its own file and
+ * joined with a blank line between them. This is a simplified model of the
+ * legacy bundle node: the `prepends` parameter is accepted for signature parity
+ * but ignored, since this package does not model prepended emit helpers.
+ *
+ * Given two source files that each re-export one binding (`a` from `"./a"` and
+ * `b` from `"./b"`), printing the bundle yields:
+ *
+ * ```ts
+ * export { a } from "./a";
+ *
+ * export { b } from "./b";
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param sourceFiles The bundled source files.
+ * @param _prepends Ignored; kept for signature parity.
+ * @returns The created {@link Bundle}.
+ */
+const createBundle = (sourceFiles, _prepends) => make("Bundle", { sourceFiles });
+
+export { createBundle };
+//# sourceMappingURL=createBundle.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,24 @@
+/**
+ * Create a node array from the given elements.
+ *
+ * Unlike the legacy compiler, this package does not wrap the elements in a
+ * dedicated node-array object. It returns the plain readonly array as-is (an
+ * empty array when no elements are passed), so the result has no `kind` and is
+ * not itself a printable node. It exists for signature parity where a node
+ * array is expected.
+ *
+ * Given identifiers `a` and `b`, the result is simply the array holding those
+ * two nodes, equivalent to writing the array literal yourself:
+ *
+ * ```ts
+ * [a, b];
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param elements The elements.
+ * @returns The given elements as a readonly array.
+ */
+const createNodeArray = (elements = []) => elements;
+
+export { createNodeArray };
+//# sourceMappingURL=createNodeArray.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link SourceFile}: the root node of one TypeScript file, holding its
+ * top-level statements.
+ *
+ * The `statements` become the file body in order. Printing the source file
+ * emits each statement on its own line; an empty list yields an empty file.
+ *
+ * Given a single import of `a` from `"./mod"` as the only statement, this
+ * prints:
+ *
+ * ```ts
+ * import { a } from "./mod";
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param statements The statements.
+ * @returns The created {@link SourceFile}.
+ */
+const createSourceFile = (statements) => make("SourceFile", { statements });
+
+export { createSourceFile };
+//# sourceMappingURL=createSourceFile.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,14 @@
+import { createSourceFile } from './createSourceFile.mjs';
+
+/**
+ * Create a {@link SourceFile}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param _source Ignored; present only to mirror the legacy signature.
+ * @param statements The statements.
+ * @returns The created {@link SourceFile}.
+ */
+const updateSourceFile = (_source, statements) => createSourceFile(statements);
+
+export { updateSourceFile };
+//# sourceMappingURL=updateSourceFile.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link ExportAssignment}: an `export default` or `export =`
+ * statement that exports a single expression.
+ *
+ * Set `isExportEquals` to `true` for the CommonJS-style `export =` form;
+ * otherwise the node prints as `export default`. The `expression` is the value
+ * being exported.
+ *
+ * Given the identifier `foo` with `isExportEquals` false, this prints:
+ *
+ * ```ts
+ * export default foo;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param isExportEquals When `true`, emit `export =`; otherwise `export
+ *   default`.
+ * @param expression The expression.
+ * @returns The created {@link ExportAssignment}.
+ */
+const createExportAssignment = (modifiers, isExportEquals, expression) => make("ExportAssignment", { modifiers, isExportEquals, expression });
+
+export { createExportAssignment };
+//# sourceMappingURL=createExportAssignment.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,38 @@
+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.
+ *
+ * The `exportClause` selects what is exported. Pass {@link NamedExports} for
+ * `export { a, b }`, a {@link NamespaceExport} for `export * as ns`, or omit it
+ * (undefined) for a bare `export *`. Set `isTypeOnly` to emit `export type`.
+ * The `moduleSpecifier` is optional: supply it for a re-export with `from`, or
+ * leave it off to export local bindings. A raw string is wrapped in a string
+ * literal.
+ *
+ * Given named exports of `a` re-exported from `"./mod"`, this prints:
+ *
+ * ```ts
+ * export { a } from "./mod";
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param isTypeOnly Whether this is a type-only import/export.
+ * @param exportClause The export clause; omitted for `export *`.
+ * @param moduleSpecifier The module specifier (the `from` target).
+ * @returns The created {@link ExportDeclaration}.
+ */
+const createExportDeclaration = (modifiers, isTypeOnly, exportClause, moduleSpecifier) => make("ExportDeclaration", {
+    modifiers,
+    isTypeOnly,
+    exportClause,
+    moduleSpecifier: typeof moduleSpecifier === "string"
+        ? createStringLiteral(moduleSpecifier)
+        : moduleSpecifier,
+});
+
+export { createExportDeclaration };
+//# sourceMappingURL=createExportDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,23 @@
+import { createExportAssignment } from './createExportAssignment.mjs';
+
+/**
+ * Create an `export default` statement for the given expression.
+ *
+ * This is a convenience wrapper over {@link createExportAssignment} with the
+ * modifiers omitted and `isExportEquals` fixed to `false`, so it always
+ * produces the `export default` form rather than `export =`.
+ *
+ * Given the identifier `foo`, this prints:
+ *
+ * ```ts
+ * export default foo;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The expression.
+ * @returns The created {@link ExportAssignment}.
+ */
+const createExportDefault = (expression) => createExportAssignment(undefined, false, expression);
+
+export { createExportDefault };
+//# sourceMappingURL=createExportDefault.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,32 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link ExportSpecifier}: one entry inside a {@link NamedExports}
+ * brace group.
+ *
+ * Pass `propertyName` to export a local binding under a different name, which
+ * prints as `propertyName as name`; leave it undefined for a plain binding.
+ * Both names accept a raw string and are wrapped in identifiers for you. Set
+ * `isTypeOnly` to prefix the single specifier with `type`.
+ *
+ * Given source name `x` aliased to `y`, this prints:
+ *
+ * ```ts
+ * x as y;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param isTypeOnly Whether this is a type-only import/export.
+ * @param propertyName The original (source) name, when aliased.
+ * @param name The name.
+ * @returns The created {@link ExportSpecifier}.
+ */
+const createExportSpecifier = (isTypeOnly, propertyName, name) => make("ExportSpecifier", {
+    isTypeOnly,
+    propertyName: propertyName === undefined ? undefined : asName(propertyName),
+    name: asName(name),
+});
+
+export { createExportSpecifier };
+//# sourceMappingURL=createExportSpecifier.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,26 @@
+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.
+ *
+ * This is a convenience wrapper that builds an {@link ExportDeclaration} whose
+ * clause is a {@link NamedExports} holding one unaliased {@link ExportSpecifier}
+ * for `exportName`, with no `from` specifier. The name accepts a raw string and
+ * is wrapped in an identifier for you.
+ *
+ * Given the export name `foo`, this prints:
+ *
+ * ```ts
+ * export { foo };
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param exportName The exportName.
+ * @returns The created {@link ExportDeclaration}.
+ */
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link ImportAttribute}: one `name: value` entry inside an
+ * {@link ImportAttributes} clause.
+ *
+ * The `name` is an identifier or string literal key and the `value` is the
+ * attribute expression, almost always a string literal. The printer separates
+ * the two with `: `.
+ *
+ * Given a `"type"` name and a `"json"` string value, this prints:
+ *
+ * ```ts
+ * "type": "json"
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param name The attribute name.
+ * @param value The attribute value.
+ * @returns The created {@link ImportAttribute}.
+ */
+const createImportAttribute = (name, value) => make("ImportAttribute", { name, value });
+
+export { createImportAttribute };
+//# sourceMappingURL=createImportAttribute.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,30 @@
+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
+ * type.
+ *
+ * The `token` selects the introducing keyword: `"with"` (the default, current
+ * syntax) or the legacy `"assert"`. Each element is an {@link ImportAttribute}
+ * key/value entry. An empty list still prints the keyword and braces.
+ *
+ * Note that the printer does not attach this clause to the import or export
+ * statements emitted by this package, so it surfaces only when you print the
+ * attributes node directly. Given a single `"type": "json"` entry under the
+ * `with` keyword, that direct print is:
+ *
+ * ```ts
+ * with { "type": "json" }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param elements The attribute entries.
+ * @param multiLine When `true`, print one entry per line.
+ * @param token The introducing keyword; defaults to `"with"`.
+ * @returns The created {@link ImportAttributes}.
+ */
+const createImportAttributes = (elements, multiLine, token = "with") => make("ImportAttributes", { elements, multiLine, token });
+
+export { createImportAttributes };
+//# sourceMappingURL=createImportAttributes.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link ImportClause}: the part of an import statement between
+ * `import` and `from`.
+ *
+ * The `name` is the default-import binding, if any. The `namedBindings` slot
+ * holds either a {@link NamedImports} brace group or a {@link NamespaceImport}. A
+ * default binding and named bindings can appear together, joined by a comma.
+ * Set `isTypeOnly` to prefix the clause with `type`.
+ *
+ * Given a default binding `Def` plus named import `a`, this prints:
+ *
+ * ```ts
+ * (Def, { a });
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param isTypeOnly Whether this is a type-only import/export.
+ * @param name The name.
+ * @param namedBindings The named or namespace bindings, if any.
+ * @returns The created {@link ImportClause}.
+ */
+const createImportClause = (isTypeOnly, name, namedBindings) => make("ImportClause", { isTypeOnly, name, namedBindings });
+
+export { createImportClause };
+//# sourceMappingURL=createImportClause.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,34 @@
+import { make } from '../internal/make.mjs';
+import { createStringLiteral } from '../literals/createStringLiteral.mjs';
+
+/**
+ * Create an {@link ImportDeclaration}: an `import ... from "..."` statement.
+ *
+ * The `importClause` carries the default binding, namespace binding, and named
+ * bindings. Omit it to emit a side-effect-only import that just runs the module
+ * for its effects. The `moduleSpecifier` is the `from` target; pass a raw
+ * string and it is wrapped in a string literal for you, or pass an expression
+ * node directly.
+ *
+ * Given a named import of `a` from `"./mod"`, this prints:
+ *
+ * ```ts
+ * import { a } from "./mod";
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param importClause The import clause; omitted for a side-effect-only import.
+ * @param moduleSpecifier The module specifier (the `from` target).
+ * @returns The created {@link ImportDeclaration}.
+ */
+const createImportDeclaration = (modifiers, importClause, moduleSpecifier) => make("ImportDeclaration", {
+    modifiers,
+    importClause,
+    moduleSpecifier: typeof moduleSpecifier === "string"
+        ? createStringLiteral(moduleSpecifier)
+        : moduleSpecifier,
+});
+
+export { createImportDeclaration };
+//# sourceMappingURL=createImportDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,28 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link ImportSpecifier}: one entry inside a {@link NamedImports}
+ * brace group.
+ *
+ * Pass `propertyName` to alias an export under a different local name, which
+ * prints as `propertyName as name`; leave it undefined for a plain binding. The
+ * `name` accepts a raw string and is wrapped in an identifier for you. Set
+ * `isTypeOnly` to prefix the single specifier with `type`.
+ *
+ * Given source name `x` aliased to `y`, this prints:
+ *
+ * ```ts
+ * x as y;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param isTypeOnly Whether this is a type-only import/export.
+ * @param propertyName The original (source) name, when aliased.
+ * @param name The name.
+ * @returns The created {@link ImportSpecifier}.
+ */
+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

@@ -0,0 +1 @@
+{"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;;;;"}