@ttsc/factory 0.15.8 → 0.15.9

package/lib/factory/expressions/createShorthandPropertyAssignment.mjs

@@ -1,31 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createShorthandPropertyAssignment = void 0;
-const asName_1 = require("../internal/asName");
-const make_1 = require("../internal/make");
-/**
- * Create a {@link ShorthandPropertyAssignment}: an object member that reuses a
- * variable name as both key and value, like `{ a }`.
- *
- * `name` is the shared property name. `objectAssignmentInitializer` is only
- * valid when the literal is the target of a destructuring assignment; when
- * present the printer appends `=` and the default value, otherwise it emits the
- * name alone.
- *
- * With `name` of `a` and no initializer, the printer emits:
- *
- * ```ts
- * a;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param name The shared property name.
- * @param objectAssignmentInitializer The default value for object
- *   destructuring, if any.
- * @returns The created {@link ShorthandPropertyAssignment}.
- */
-const createShorthandPropertyAssignment = (name, objectAssignmentInitializer) => (0, make_1.make)("ShorthandPropertyAssignment", {
-    name: (0, asName_1.asName)(name),
-    objectAssignmentInitializer,
-});
-exports.createShorthandPropertyAssignment = createShorthandPropertyAssignment;
-//# sourceMappingURL=createShorthandPropertyAssignment.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createShorthandPropertyAssignment.mjs","sources":["createShorthandPropertyAssignment.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createShorthandPropertyAssignment = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ShorthandPropertyAssignment}: an object member that reuses a\n * variable name as both key and value, like `{ a }`.\n *\n * `name` is the shared property name. `objectAssignmentInitializer` is only\n * valid when the literal is the target of a destructuring assignment; when\n * present the printer appends `=` and the default value, otherwise it emits the\n * name alone.\n *\n * With `name` of `a` and no initializer, the printer emits:\n *\n * ```ts\n * a;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The shared property name.\n * @param objectAssignmentInitializer The default value for object\n *   destructuring, if any.\n * @returns The created {@link ShorthandPropertyAssignment}.\n */\nconst createShorthandPropertyAssignment = (name, objectAssignmentInitializer) => (0, make_1.make)(\"ShorthandPropertyAssignment\", {\n    name: (0, asName_1.asName)(name),\n    objectAssignmentInitializer,\n});\nexports.createShorthandPropertyAssignment = createShorthandPropertyAssignment;\n//# sourceMappingURL=createShorthandPropertyAssignment.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,iCAAiC,GAAG,MAAM;AAClD,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,iCAAiC,GAAG,CAAC,IAAI,EAAE,2BAA2B,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,6BAA6B,EAAE;AACjI,IAAI,IAAI,EAAE,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,IAAI,2BAA2B;AAC/B,CAAC,CAAC;AACF,OAAO,CAAC,iCAAiC,GAAG,iCAAiC"}

package/lib/factory/expressions/createSpreadAssignment.mjs

@@ -1,23 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSpreadAssignment = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link SpreadAssignment}: a `...expression` member that spreads one
- * object's properties into an object literal.
- *
- * `expression` is the source object. The printer prefixes it with `...` and no
- * separating space.
- *
- * With `expression` of `a` inside an object literal, the printer emits:
- *
- * ```ts
- * { ...a }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param expression The object expression to spread.
- * @returns The created {@link SpreadAssignment}.
- */
-const createSpreadAssignment = (expression) => (0, make_1.make)("SpreadAssignment", { expression });
-exports.createSpreadAssignment = createSpreadAssignment;
-//# sourceMappingURL=createSpreadAssignment.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createSpreadAssignment.mjs","sources":["createSpreadAssignment.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createSpreadAssignment = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link SpreadAssignment}: a `...expression` member that spreads one\n * object's properties into an object literal.\n *\n * `expression` is the source object. The printer prefixes it with `...` and no\n * separating space.\n *\n * With `expression` of `a` inside an object literal, the printer emits:\n *\n * ```ts\n * { ...a }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The object expression to spread.\n * @returns The created {@link SpreadAssignment}.\n */\nconst createSpreadAssignment = (expression) => (0, make_1.make)(\"SpreadAssignment\", { expression });\nexports.createSpreadAssignment = createSpreadAssignment;\n//# sourceMappingURL=createSpreadAssignment.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,MAAM,sBAAsB,GAAG,CAAC,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,EAAE,UAAU,EAAE,CAAC;AACnG,OAAO,CAAC,sBAAsB,GAAG,sBAAsB"}

package/lib/factory/expressions/createSpreadElement.mjs

@@ -1,23 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSpreadElement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link SpreadElement}: a `...expression` element that spreads an
- * iterable into an array literal or argument list.
- *
- * `expression` is the source iterable. The printer prefixes it with `...` and
- * no separating space.
- *
- * With `expression` of `a` inside an array literal, the printer emits:
- *
- * ```ts
- * [...a];
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param expression The iterable expression to spread.
- * @returns The created {@link SpreadElement}.
- */
-const createSpreadElement = (expression) => (0, make_1.make)("SpreadElement", { expression });
-exports.createSpreadElement = createSpreadElement;
-//# sourceMappingURL=createSpreadElement.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createSpreadElement.mjs","sources":["createSpreadElement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createSpreadElement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link SpreadElement}: a `...expression` element that spreads an\n * iterable into an array literal or argument list.\n *\n * `expression` is the source iterable. The printer prefixes it with `...` and\n * no separating space.\n *\n * With `expression` of `a` inside an array literal, the printer emits:\n *\n * ```ts\n * [...a];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The iterable expression to spread.\n * @returns The created {@link SpreadElement}.\n */\nconst createSpreadElement = (expression) => (0, make_1.make)(\"SpreadElement\", { expression });\nexports.createSpreadElement = createSpreadElement;\n//# sourceMappingURL=createSpreadElement.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,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,mBAAmB,GAAG,CAAC,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,UAAU,EAAE,CAAC;AAC7F,OAAO,CAAC,mBAAmB,GAAG,mBAAmB"}

package/lib/factory/expressions/createStrictEquality.mjs

@@ -1,23 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStrictEquality = void 0;
-const syntax_1 = require("../../syntax");
-const createBinaryExpression_1 = require("./createBinaryExpression");
-/**
- * Create a strict equality 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 createStrictEquality = (left, right) => (0, createBinaryExpression_1.createBinaryExpression)(left, syntax_1.SyntaxKind.EqualsEqualsEqualsToken, right);
-exports.createStrictEquality = createStrictEquality;
-//# sourceMappingURL=createStrictEquality.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createStrictEquality.mjs","sources":["createStrictEquality.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createStrictEquality = void 0;\nconst syntax_1 = require(\"../../syntax\");\nconst createBinaryExpression_1 = require(\"./createBinaryExpression\");\n/**\n * Create a strict equality 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 createStrictEquality = (left, right) => (0, createBinaryExpression_1.createBinaryExpression)(left, syntax_1.SyntaxKind.EqualsEqualsEqualsToken, right);\nexports.createStrictEquality = createStrictEquality;\n//# sourceMappingURL=createStrictEquality.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,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,oBAAoB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,wBAAwB,CAAC,sBAAsB,EAAE,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,uBAAuB,EAAE,KAAK,CAAC;AAC5J,OAAO,CAAC,oBAAoB,GAAG,oBAAoB"}

package/lib/factory/expressions/createStrictInequality.mjs

@@ -1,23 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStrictInequality = void 0;
-const syntax_1 = require("../../syntax");
-const createBinaryExpression_1 = require("./createBinaryExpression");
-/**
- * Create a strict inequality 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 createStrictInequality = (left, right) => (0, createBinaryExpression_1.createBinaryExpression)(left, syntax_1.SyntaxKind.ExclamationEqualsEqualsToken, right);
-exports.createStrictInequality = createStrictInequality;
-//# sourceMappingURL=createStrictInequality.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createStrictInequality.mjs","sources":["createStrictInequality.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createStrictInequality = void 0;\nconst syntax_1 = require(\"../../syntax\");\nconst createBinaryExpression_1 = require(\"./createBinaryExpression\");\n/**\n * Create a strict inequality 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 createStrictInequality = (left, right) => (0, createBinaryExpression_1.createBinaryExpression)(left, syntax_1.SyntaxKind.ExclamationEqualsEqualsToken, right);\nexports.createStrictInequality = createStrictInequality;\n//# sourceMappingURL=createStrictInequality.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,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,sBAAsB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,wBAAwB,CAAC,sBAAsB,EAAE,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,4BAA4B,EAAE,KAAK,CAAC;AACnK,OAAO,CAAC,sBAAsB,GAAG,sBAAsB"}

package/lib/factory/expressions/createSubtract.mjs

@@ -1,23 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSubtract = void 0;
-const syntax_1 = require("../../syntax");
-const createBinaryExpression_1 = require("./createBinaryExpression");
-/**
- * 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) => (0, createBinaryExpression_1.createBinaryExpression)(left, syntax_1.SyntaxKind.MinusToken, right);
-exports.createSubtract = createSubtract;
-//# sourceMappingURL=createSubtract.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createSubtract.mjs","sources":["createSubtract.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createSubtract = void 0;\nconst syntax_1 = require(\"../../syntax\");\nconst createBinaryExpression_1 = require(\"./createBinaryExpression\");\n/**\n * Create a subtraction 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 createSubtract = (left, right) => (0, createBinaryExpression_1.createBinaryExpression)(left, syntax_1.SyntaxKind.MinusToken, right);\nexports.createSubtract = createSubtract;\n//# sourceMappingURL=createSubtract.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,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,cAAc,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,wBAAwB,CAAC,sBAAsB,EAAE,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU,EAAE,KAAK,CAAC;AACzI,OAAO,CAAC,cAAc,GAAG,cAAc"}

package/lib/factory/expressions/createTaggedTemplateExpression.mjs

@@ -1,27 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTaggedTemplateExpression = void 0;
-const make_1 = require("../internal/make");
-/**
- * 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) => (0, make_1.make)("TaggedTemplateExpression", { tag, typeArguments, template });
-exports.createTaggedTemplateExpression = createTaggedTemplateExpression;
-//# sourceMappingURL=createTaggedTemplateExpression.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createTaggedTemplateExpression.mjs","sources":["createTaggedTemplateExpression.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createTaggedTemplateExpression = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link TaggedTemplateExpression}: a template literal invoked by a tag\n * function.\n *\n * `tag` is the function applied to the template, `typeArguments` are its\n * optional generic arguments, and `template` is the template literal itself.\n * The printer writes the tag directly against the template with no space\n * between them.\n *\n * With `tag` of `tag` and a template of ``hi``, the printer emits:\n *\n * ```ts\n * tag`hi`;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tag The tag expression applied to the template.\n * @param typeArguments The generic type arguments, if any.\n * @param template The template literal.\n * @returns The created {@link TaggedTemplateExpression}.\n */\nconst createTaggedTemplateExpression = (tag, typeArguments, template) => (0, make_1.make)(\"TaggedTemplateExpression\", { tag, typeArguments, template });\nexports.createTaggedTemplateExpression = createTaggedTemplateExpression;\n//# sourceMappingURL=createTaggedTemplateExpression.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,8BAA8B,GAAG,MAAM;AAC/C,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,8BAA8B,GAAG,CAAC,GAAG,EAAE,aAAa,EAAE,QAAQ,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,0BAA0B,EAAE,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC;AACvJ,OAAO,CAAC,8BAA8B,GAAG,8BAA8B"}

package/lib/factory/expressions/createTemplateExpression.mjs

@@ -1,27 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTemplateExpression = void 0;
-const make_1 = require("../internal/make");
-/**
- * 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) => (0, make_1.make)("TemplateExpression", { head, templateSpans });
-exports.createTemplateExpression = createTemplateExpression;
-//# sourceMappingURL=createTemplateExpression.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createTemplateExpression.mjs","sources":["createTemplateExpression.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createTemplateExpression = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link TemplateExpression}: a template literal with one or more\n * interpolations.\n *\n * `head` is the leading text up to the first `${`, and each entry in\n * `templateSpans` pairs an interpolated expression with the literal text that\n * follows it. The printer wraps the whole thing in backticks and renders each\n * span as `${expression}` followed by its trailing text.\n *\n * With `head` of `a`, a span interpolating `x` and a tail of `b`, the printer\n * emits:\n *\n * ```ts\n * `a${x}b`;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param head The leading literal text before the first interpolation.\n * @param templateSpans The interpolation spans.\n * @returns The created {@link TemplateExpression}.\n */\nconst createTemplateExpression = (head, templateSpans) => (0, make_1.make)(\"TemplateExpression\", { head, templateSpans });\nexports.createTemplateExpression = createTemplateExpression;\n//# sourceMappingURL=createTemplateExpression.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,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,wBAAwB,GAAG,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,oBAAoB,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;AACzH,OAAO,CAAC,wBAAwB,GAAG,wBAAwB"}

package/lib/factory/expressions/createTemplateSpan.mjs

@@ -1,28 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTemplateSpan = void 0;
-const make_1 = require("../internal/make");
-/**
- * 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) => (0, make_1.make)("TemplateSpan", { expression, literal });
-exports.createTemplateSpan = createTemplateSpan;
-//# sourceMappingURL=createTemplateSpan.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createTemplateSpan.mjs","sources":["createTemplateSpan.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createTemplateSpan = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link TemplateSpan}: one interpolation segment of a template\n * literal.\n *\n * A span pairs `expression`, the interpolated value, with `literal`, the static\n * text that follows it. `literal` is a {@link TemplateMiddle} when more spans\n * follow or a {@link TemplateTail} for the last one. Spans are not standalone\n * expressions; they live inside a {@link TemplateExpression}, which supplies the\n * leading head and the surrounding backticks.\n *\n * With `expression` of `x` and a tail literal of `b`, the printer emits the\n * fragment:\n *\n * ```ts\n * x}b`\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The interpolated expression.\n * @param literal The static text following the interpolation.\n * @returns The created {@link TemplateSpan}.\n */\nconst createTemplateSpan = (expression, literal) => (0, make_1.make)(\"TemplateSpan\", { expression, literal });\nexports.createTemplateSpan = createTemplateSpan;\n//# sourceMappingURL=createTemplateSpan.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;AACA,MAAM,kBAAkB,GAAG,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC;AAC7G,OAAO,CAAC,kBAAkB,GAAG,kBAAkB"}

package/lib/factory/expressions/createTypeAssertion.mjs

@@ -1,25 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTypeAssertion = void 0;
-const make_1 = require("../internal/make");
-/**
- * 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) => (0, make_1.make)("TypeAssertion", { type, expression });
-exports.createTypeAssertion = createTypeAssertion;
-//# sourceMappingURL=createTypeAssertion.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createTypeAssertion.mjs","sources":["createTypeAssertion.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createTypeAssertion = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link TypeAssertion}: the angle-bracket cast form `<Type>expr`.\n *\n * `type` is the asserted type and `expression` is the value being cast. The\n * printer wraps the type in angle brackets and places it before the expression\n * with no space. This is the older cast syntax; the `as` form is a separate\n * node.\n *\n * With `type` of `Foo` and `expression` of `x`, the printer emits:\n *\n * ```ts\n * <Foo>x\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The asserted type.\n * @param expression The expression to cast.\n * @returns The created {@link TypeAssertion}.\n */\nconst createTypeAssertion = (type, expression) => (0, make_1.make)(\"TypeAssertion\", { type, expression });\nexports.createTypeAssertion = createTypeAssertion;\n//# sourceMappingURL=createTypeAssertion.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,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,mBAAmB,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AACzG,OAAO,CAAC,mBAAmB,GAAG,mBAAmB"}

package/lib/factory/expressions/createTypeOfExpression.mjs

@@ -1,22 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTypeOfExpression = void 0;
-const make_1 = require("../internal/make");
-/**
- * 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) => (0, make_1.make)("TypeOfExpression", { expression });
-exports.createTypeOfExpression = createTypeOfExpression;
-//# sourceMappingURL=createTypeOfExpression.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createTypeOfExpression.mjs","sources":["createTypeOfExpression.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createTypeOfExpression = void 0;\nconst make_1 = require(\"../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 */\nconst createTypeOfExpression = (expression) => (0, make_1.make)(\"TypeOfExpression\", { expression });\nexports.createTypeOfExpression = createTypeOfExpression;\n//# sourceMappingURL=createTypeOfExpression.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,MAAM,sBAAsB,GAAG,CAAC,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,EAAE,UAAU,EAAE,CAAC;AACnG,OAAO,CAAC,sBAAsB,GAAG,sBAAsB"}

package/lib/factory/expressions/createUnsignedRightShift.mjs

@@ -1,23 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createUnsignedRightShift = void 0;
-const syntax_1 = require("../../syntax");
-const createBinaryExpression_1 = require("./createBinaryExpression");
-/**
- * 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) => (0, createBinaryExpression_1.createBinaryExpression)(left, syntax_1.SyntaxKind.GreaterThanGreaterThanGreaterThanToken, right);
-exports.createUnsignedRightShift = createUnsignedRightShift;
-//# sourceMappingURL=createUnsignedRightShift.mjs.map

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

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

package/lib/factory/expressions/createVoidExpression.mjs

@@ -1,23 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVoidExpression = void 0;
-const make_1 = require("../internal/make");
-/**
- * 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) => (0, make_1.make)("VoidExpression", { expression });
-exports.createVoidExpression = createVoidExpression;
-//# sourceMappingURL=createVoidExpression.mjs.map

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

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

package/lib/factory/expressions/createVoidZero.mjs

@@ -1,22 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVoidZero = void 0;
-const createNumericLiteral_1 = require("../literals/createNumericLiteral");
-const createVoidExpression_1 = require("./createVoidExpression");
-/**
- * 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 = () => (0, createVoidExpression_1.createVoidExpression)((0, createNumericLiteral_1.createNumericLiteral)("0"));
-exports.createVoidZero = createVoidZero;
-//# sourceMappingURL=createVoidZero.mjs.map

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

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

package/lib/factory/expressions/createYieldExpression.mjs

@@ -1,26 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createYieldExpression = void 0;
-const make_1 = require("../internal/make");
-/**
- * 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) => (0, make_1.make)("YieldExpression", { asteriskToken, expression });
-exports.createYieldExpression = createYieldExpression;
-//# sourceMappingURL=createYieldExpression.mjs.map

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

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

package/lib/factory/file/createBundle.mjs

@@ -1,29 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBundle = void 0;
-const make_1 = require("../internal/make");
-/**
- * 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) => (0, make_1.make)("Bundle", { sourceFiles });
-exports.createBundle = createBundle;
-//# sourceMappingURL=createBundle.mjs.map

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

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

package/lib/factory/file/createNodeArray.mjs

@@ -1,25 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodeArray = void 0;
-/**
- * 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;
-exports.createNodeArray = createNodeArray;
-//# sourceMappingURL=createNodeArray.mjs.map

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

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

package/lib/factory/file/createSourceFile.mjs

@@ -1,24 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSourceFile = void 0;
-const make_1 = require("../internal/make");
-/**
- * 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) => (0, make_1.make)("SourceFile", { statements });
-exports.createSourceFile = createSourceFile;
-//# sourceMappingURL=createSourceFile.mjs.map

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

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

package/lib/factory/file/updateSourceFile.mjs

@@ -1,14 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateSourceFile = void 0;
-const createSourceFile_1 = require("./createSourceFile");
-/**
- * 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) => (0, createSourceFile_1.createSourceFile)(statements);
-exports.updateSourceFile = updateSourceFile;
-//# sourceMappingURL=updateSourceFile.mjs.map

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

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