@ttsc/factory 0.15.9 → 0.15.11

package/lib/factory/expressions/createSubtract.mjs

@@ -0,0 +1,24 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+
+/**
+ * Create a subtraction 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 createSubtract = (left, right) => createBinaryExpression(left, SyntaxKind.MinusToken, right);
+
+export { createSubtract };
+//# sourceMappingURL=createSubtract.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createSubtract.mjs","sources":["../../../src/factory/expressions/createSubtract.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;AAeG;MACU,cAAc,GAAG,CAC5B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,UAAU,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createTaggedTemplateExpression.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TaggedTemplateExpression}: a template literal invoked by a tag
+ * function.
+ *
+ * `tag` is the function applied to the template, `typeArguments` are its
+ * optional generic arguments, and `template` is the template literal itself.
+ * The printer writes the tag directly against the template with no space
+ * between them.
+ *
+ * With `tag` of `tag` and a template of ``hi``, the printer emits:
+ *
+ * ```ts
+ * tag`hi`;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tag The tag expression applied to the template.
+ * @param typeArguments The generic type arguments, if any.
+ * @param template The template literal.
+ * @returns The created {@link TaggedTemplateExpression}.
+ */
+const createTaggedTemplateExpression = (tag, typeArguments, template) => make("TaggedTemplateExpression", { tag, typeArguments, template });
+
+export { createTaggedTemplateExpression };
+//# sourceMappingURL=createTaggedTemplateExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTaggedTemplateExpression.mjs","sources":["../../../src/factory/expressions/createTaggedTemplateExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,8BAA8B,GAAG,CAC5C,GAAe,EACf,aAA8C,EAC9C,QAAyB,KAEzB,IAAI,CAAC,0BAA0B,EAAE,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/expressions/createTemplateExpression.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TemplateExpression}: a template literal with one or more
+ * interpolations.
+ *
+ * `head` is the leading text up to the first `${`, and each entry in
+ * `templateSpans` pairs an interpolated expression with the literal text that
+ * follows it. The printer wraps the whole thing in backticks and renders each
+ * span as `${expression}` followed by its trailing text.
+ *
+ * With `head` of `a`, a span interpolating `x` and a tail of `b`, the printer
+ * emits:
+ *
+ * ```ts
+ * `a${x}b`;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param head The leading literal text before the first interpolation.
+ * @param templateSpans The interpolation spans.
+ * @returns The created {@link TemplateExpression}.
+ */
+const createTemplateExpression = (head, templateSpans) => make("TemplateExpression", { head, templateSpans });
+
+export { createTemplateExpression };
+//# sourceMappingURL=createTemplateExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTemplateExpression.mjs","sources":["../../../src/factory/expressions/createTemplateExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,wBAAwB,GAAG,CACtC,IAAkB,EAClB,aAAsC,KACf,IAAI,CAAC,oBAAoB,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE;;;;"}

package/lib/factory/expressions/createTemplateSpan.mjs

@@ -0,0 +1,28 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TemplateSpan}: one interpolation segment of a template
+ * literal.
+ *
+ * A span pairs `expression`, the interpolated value, with `literal`, the static
+ * text that follows it. `literal` is a {@link TemplateMiddle} when more spans
+ * follow or a {@link TemplateTail} for the last one. Spans are not standalone
+ * expressions; they live inside a {@link TemplateExpression}, which supplies the
+ * leading head and the surrounding backticks.
+ *
+ * With `expression` of `x` and a tail literal of `b`, the printer emits the
+ * fragment:
+ *
+ * ```ts
+ * x}b`
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The interpolated expression.
+ * @param literal The static text following the interpolation.
+ * @returns The created {@link TemplateSpan}.
+ */
+const createTemplateSpan = (expression, literal) => make("TemplateSpan", { expression, literal });
+
+export { createTemplateSpan };
+//# sourceMappingURL=createTemplateSpan.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTemplateSpan.mjs","sources":["../../../src/factory/expressions/createTemplateSpan.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;;AAqBG;MACU,kBAAkB,GAAG,CAChC,UAAsB,EACtB,OAAsC,KACrB,IAAI,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/expressions/createTypeAssertion.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TypeAssertion}: the angle-bracket cast form `<Type>expr`.
+ *
+ * `type` is the asserted type and `expression` is the value being cast. The
+ * printer wraps the type in angle brackets and places it before the expression
+ * with no space. This is the older cast syntax; the `as` form is a separate
+ * node.
+ *
+ * With `type` of `Foo` and `expression` of `x`, the printer emits:
+ *
+ * ```ts
+ * <Foo>x
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The asserted type.
+ * @param expression The expression to cast.
+ * @returns The created {@link TypeAssertion}.
+ */
+const createTypeAssertion = (type, expression) => make("TypeAssertion", { type, expression });
+
+export { createTypeAssertion };
+//# sourceMappingURL=createTypeAssertion.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeAssertion.mjs","sources":["../../../src/factory/expressions/createTypeAssertion.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;MACU,mBAAmB,GAAG,CACjC,IAAc,EACd,UAAsB,KACJ,IAAI,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/expressions/createTypeOfExpression.mjs

@@ -0,0 +1,22 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TypeOfExpression}: the `typeof` operator applied to a value.
+ *
+ * `expression` is the operand. The printer writes the `typeof` keyword followed
+ * by a single space and then the operand.
+ *
+ * With `expression` of `x`, the printer emits:
+ *
+ * ```ts
+ * typeof x;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The operand of `typeof`.
+ * @returns The created {@link TypeOfExpression}.
+ */
+const createTypeOfExpression = (expression) => make("TypeOfExpression", { expression });
+
+export { createTypeOfExpression };
+//# sourceMappingURL=createTypeOfExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeOfExpression.mjs","sources":["../../../src/factory/expressions/createTypeOfExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;AAeG;AACI,MAAM,sBAAsB,GAAG,CACpC,UAAsB,KACD,IAAI,CAAC,kBAAkB,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/expressions/createUnsignedRightShift.mjs

@@ -0,0 +1,24 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.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":["../../../src/factory/expressions/createUnsignedRightShift.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;AAeG;MACU,wBAAwB,GAAG,CACtC,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CACpB,IAAI,EACJ,UAAU,CAAC,sCAAsC,EACjD,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":["../../../src/factory/expressions/createVoidExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,oBAAoB,GAAG,CAAC,UAAsB,KACzD,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":["../../../src/factory/expressions/createVoidZero.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,cAAc,GAAG,MAC5B,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":["../../../src/factory/expressions/createYieldExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;AAmBG;MACU,qBAAqB,GAAG,CACnC,aAAgC,EAChC,UAAkC,KACd,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":["../../../src/factory/file/createBundle.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,YAAY,GAAG,CAC1B,WAAkC,EAClC,SAA8B,KACnB,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":["../../../src/factory/file/createNodeArray.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,eAAe,GAAG,CAC7B,QAAA,GAAyB,EAAE,KACV;;;;"}

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":["../../../src/factory/file/createSourceFile.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,gBAAgB,GAAG,CAC9B,UAAgC,KACjB,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":["../../../src/factory/file/updateSourceFile.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;AAOG;AACI,MAAM,gBAAgB,GAAG,CAC9B,OAAmB,EACnB,UAAgC,KACjB,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":["../../../src/factory/imports/createExportAssignment.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,sBAAsB,GAAG,CACpC,SAA8C,EAC9C,cAAmC,EACnC,UAAsB,KAEtB,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":["../../../src/factory/imports/createExportDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,uBAAuB,GAAG,CACrC,SAA8C,EAC9C,UAAmB,EACnB,YAAwD,EACxD,eAAqC,KAErC,IAAI,CAAC,mBAAmB,EAAE;IACxB,SAAS;IACT,UAAU;IACV,YAAY;AACZ,IAAA,eAAe,EACb,OAAO,eAAe,KAAK;AACzB,UAAE,mBAAmB,CAAC,eAAe;AACrC,UAAE,eAAe;AACtB,CAAA;;;;"}

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":["../../../src/factory/imports/createExportDefault.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,mBAAmB,GAAG,CAAC,UAAsB,KACxD,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":["../../../src/factory/imports/createExportSpecifier.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,qBAAqB,GAAG,CACnC,UAAmB,EACnB,YAA6C,EAC7C,IAAyB,KAEzB,IAAI,CAAC,iBAAiB,EAAE;IACtB,UAAU;AACV,IAAA,YAAY,EAAE,YAAY,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,YAAY,CAAC;AAC3E,IAAA,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;AACnB,CAAA;;;;"}

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":["../../../src/factory/imports/createExternalModuleExport.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,0BAA0B,GAAG,CACxC,UAA+B,KAE/B,uBAAuB,CACrB,SAAS,EACT,KAAK,EACL,kBAAkB,CAAC,CAAC,qBAAqB,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC,EACzE,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":["../../../src/factory/imports/createImportAttribute.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAOA;;;;;;;;;;;;;;;;;;AAkBG;MACU,qBAAqB,GAAG,CACnC,IAAyB,EACzB,KAAiB,KACG,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":["../../../src/factory/imports/createImportAttributes.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,sBAAsB,GAAG,CACpC,QAAoC,EACpC,SAAmB,EACnB,KAAA,GAA2B,MAAM,KACZ,IAAI,CAAC,kBAAkB,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE;;;;"}