@ttsc/factory 0.15.10 → 0.16.0

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

@@ -1 +1 @@
-{"version":3,"file":"createLogicalOr.mjs","sources":["../../../esm-tmp/factory/expressions/createLogicalOr.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `||` operator: logical OR with\n * short-circuit evaluation.\n *\n * Shorthand for {@link createBinaryExpression} with the `BarBarToken` operator.\n * The printer surrounds the operator with a single space on each side.\n *\n * Given operands `a` and `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 createLogicalOr = (left, right) => createBinaryExpression(left, SyntaxKind.BarBarToken, right);\n//# sourceMappingURL=createLogicalOr.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,eAAe,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,EAAE,KAAK;;;;"}
+{"version":3,"file":"createLogicalOr.mjs","sources":["../../../src/factory/expressions/createLogicalOr.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;MACU,eAAe,GAAG,CAC7B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,EAAE,KAAK;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createMetaProperty.mjs","sources":["../../../esm-tmp/factory/expressions/createMetaProperty.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link MetaProperty}: a meta-property reference like `new.target` or\n * `import.meta`.\n *\n * `keywordToken` selects the leading keyword (`NewKeyword` for `new.target`,\n * `ImportKeyword` for `import.meta`) and `name` is the member that follows the\n * dot. The printer emits the keyword, a dot, and the name with no surrounding\n * whitespace.\n *\n * With `keywordToken` of `NewKeyword` and `name` of `target`, the printer\n * emits:\n *\n * ```ts\n * new.target;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param keywordToken The leading keyword token (`NewKeyword` or\n *   `ImportKeyword`).\n * @param name The member name following the dot.\n * @returns The created {@link MetaProperty}.\n */\nexport const createMetaProperty = (keywordToken, name) => make(\"MetaProperty\", { keywordToken, name: asName(name) });\n//# sourceMappingURL=createMetaProperty.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;AACY,MAAC,kBAAkB,GAAG,CAAC,YAAY,EAAE,IAAI,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;;;;"}
+{"version":3,"file":"createMetaProperty.mjs","sources":["../../../src/factory/expressions/createMetaProperty.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,kBAAkB,GAAG,CAChC,YAAwB,EACxB,IAAyB,KACR,IAAI,CAAC,cAAc,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;;;;"}

package/lib/factory/expressions/createModulo.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a remainder expression: `left % right`.

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

@@ -1 +1 @@
-{"version":3,"file":"createModulo.mjs","sources":["../../../esm-tmp/factory/expressions/createModulo.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a remainder 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 createModulo = (left, right) => createBinaryExpression(left, SyntaxKind.PercentToken, right);\n//# sourceMappingURL=createModulo.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,YAAY,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,YAAY,EAAE,KAAK;;;;"}
+{"version":3,"file":"createModulo.mjs","sources":["../../../src/factory/expressions/createModulo.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;AAeG;MACU,YAAY,GAAG,CAC1B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,YAAY,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createMultiply.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a multiplication expression: `left * right`.

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

@@ -1 +1 @@
-{"version":3,"file":"createMultiply.mjs","sources":["../../../esm-tmp/factory/expressions/createMultiply.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a multiplication 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 createMultiply = (left, right) => createBinaryExpression(left, SyntaxKind.AsteriskToken, right);\n//# sourceMappingURL=createMultiply.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,cAAc,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,aAAa,EAAE,KAAK;;;;"}
+{"version":3,"file":"createMultiply.mjs","sources":["../../../src/factory/expressions/createMultiply.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;AAeG;MACU,cAAc,GAAG,CAC5B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,aAAa,EAAE,KAAK;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createNewExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createNewExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link NewExpression}: a constructor call with `new`.\n *\n * `expression` is the constructor being invoked. `typeArguments`, when present,\n * are printed in angle brackets after the constructor. `argumentsArray` holds\n * the call arguments; an empty array still prints the parentheses, so `new\n * Foo()` is emitted rather than `new Foo`.\n *\n * With `expression` of `Foo` and a single argument `a`, the printer emits:\n *\n * ```ts\n * new Foo(a);\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The constructor expression.\n * @param typeArguments The generic type arguments, if any.\n * @param argumentsArray The constructor arguments.\n * @returns The created {@link NewExpression}.\n */\nexport const createNewExpression = (expression, typeArguments, argumentsArray) => make(\"NewExpression\", {\n    expression,\n    typeArguments,\n    arguments: argumentsArray,\n});\n//# sourceMappingURL=createNewExpression.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,mBAAmB,GAAG,CAAC,UAAU,EAAE,aAAa,EAAE,cAAc,KAAK,IAAI,CAAC,eAAe,EAAE;AACxG,IAAI,UAAU;AACd,IAAI,aAAa;AACjB,IAAI,SAAS,EAAE,cAAc;AAC7B,CAAC;;;;"}
+{"version":3,"file":"createNewExpression.mjs","sources":["../../../src/factory/expressions/createNewExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,mBAAmB,GAAG,CACjC,UAAsB,EACtB,aAA8C,EAC9C,cAAiD,KAEjD,IAAI,CAAC,eAAe,EAAE;IACpB,UAAU;IACV,aAAa;AACb,IAAA,SAAS,EAAE,cAAc;AAC1B,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createNonNullChain.mjs","sources":["../../../esm-tmp/factory/expressions/createNonNullChain.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link NonNullChain}: a non-null assertion `!` that participates in\n * an optional chain.\n *\n * This is the chain-aware variant of {@link createNonNullExpression}. It marks\n * `expression` as non-null inside an optional chain so the chain context is\n * preserved. The printed form is the same single `!` suffix.\n *\n * With `expression` of `a`, the printer emits:\n *\n * ```ts\n * a!;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression to assert as non-null.\n * @returns The created {@link NonNullChain}.\n */\nexport const createNonNullChain = (expression) => make(\"NonNullChain\", { expression });\n//# sourceMappingURL=createNonNullChain.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE;;;;"}
+{"version":3,"file":"createNonNullChain.mjs","sources":["../../../src/factory/expressions/createNonNullChain.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,kBAAkB,GAAG,CAAC,UAAsB,KACvD,IAAI,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createNonNullExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createNonNullExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link NonNullExpression}: a non-null assertion that suffixes\n * `expression` with `!`.\n *\n * The assertion strips `null` and `undefined` from the operand's type at\n * compile time. The printer appends a single `!` directly after the operand\n * with no space.\n *\n * With `expression` of `a`, the printer emits:\n *\n * ```ts\n * a!;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression to assert as non-null.\n * @returns The created {@link NonNullExpression}.\n */\nexport const createNonNullExpression = (expression) => make(\"NonNullExpression\", { expression });\n//# sourceMappingURL=createNonNullExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,mBAAmB,EAAE,EAAE,UAAU,EAAE;;;;"}
+{"version":3,"file":"createNonNullExpression.mjs","sources":["../../../src/factory/expressions/createNonNullExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,uBAAuB,GAAG,CACrC,UAAsB,KACA,IAAI,CAAC,mBAAmB,EAAE,EAAE,UAAU,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createObjectBindingPattern.mjs","sources":["../../../esm-tmp/factory/expressions/createObjectBindingPattern.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ObjectBindingPattern}: the `{ ... }` binding form used to\n * destructure an object.\n *\n * `elements` are the binding elements, each naming a property to bind and\n * optionally a default or rest. The printer wraps the elements in braces and\n * separates them with commas, with a single space inside the braces.\n *\n * With binding elements `a` and `b`, the printer emits:\n *\n * ```ts\n * { a, b }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elements The binding elements.\n * @returns The created {@link ObjectBindingPattern}.\n */\nexport const createObjectBindingPattern = (elements) => make(\"ObjectBindingPattern\", { elements });\n//# sourceMappingURL=createObjectBindingPattern.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,0BAA0B,GAAG,CAAC,QAAQ,KAAK,IAAI,CAAC,sBAAsB,EAAE,EAAE,QAAQ,EAAE;;;;"}
+{"version":3,"file":"createObjectBindingPattern.mjs","sources":["../../../src/factory/expressions/createObjectBindingPattern.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,0BAA0B,GAAG,CACxC,QAAmC,KACV,IAAI,CAAC,sBAAsB,EAAE,EAAE,QAAQ,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createObjectLiteralExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createObjectLiteralExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ObjectLiteralExpression}: a `{ ... }` object literal.\n *\n * `properties` are the members (assignments, shorthands, spreads, methods).\n * `multiLine` controls layout. When `true`, each property is printed on its own\n * line and a trailing comma is added; when falsy, the whole literal is printed\n * inline with a single space inside the braces.\n *\n * With a single property `a: 1` and `multiLine` of `true`, the printer emits:\n *\n * ```ts\n * {\n *   \"a\": 1\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param properties The object members.\n * @param multiLine When `true`, print one entry per line.\n * @returns The created {@link ObjectLiteralExpression}.\n */\nexport const createObjectLiteralExpression = (properties = [], multiLine) => make(\"ObjectLiteralExpression\", { properties, multiLine });\n//# sourceMappingURL=createObjectLiteralExpression.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,6BAA6B,GAAG,CAAC,UAAU,GAAG,EAAE,EAAE,SAAS,KAAK,IAAI,CAAC,yBAAyB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}
+{"version":3,"file":"createObjectLiteralExpression.mjs","sources":["../../../src/factory/expressions/createObjectLiteralExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,6BAA6B,GAAG,CAC3C,UAAA,GAA8C,EAAE,EAChD,SAAmB,KAEnB,IAAI,CAAC,yBAAyB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createOmittedExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createOmittedExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link OmittedExpression}: an elided element, the hole left by a\n * missing entry in an array literal or binding pattern.\n *\n * The node carries no operand. The printer emits nothing for it; the\n * surrounding list still prints its comma separator, which is what produces the\n * visible gap.\n *\n * Placed before `a` in an array literal, the printer emits:\n *\n * ```ts\n * [, a];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link OmittedExpression}.\n */\nexport const createOmittedExpression = () => make(\"OmittedExpression\", {});\n//# sourceMappingURL=createOmittedExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,MAAM,IAAI,CAAC,mBAAmB,EAAE,EAAE;;;;"}
+{"version":3,"file":"createOmittedExpression.mjs","sources":["../../../src/factory/expressions/createOmittedExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,uBAAuB,GAAG,MACrC,IAAI,CAAC,mBAAmB,EAAE,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createParenthesizedExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createParenthesizedExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ParenthesizedExpression}: an explicit `( ... )` grouping\n * around `expression`.\n *\n * This is an explicit grouping node that is always present in the tree; the\n * printer emits the parentheses unconditionally rather than inferring them from\n * precedence.\n *\n * With `expression` of `a % b`, the printer emits:\n *\n * ```ts\n * a % b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The inner expression to wrap in parentheses.\n * @returns The created {@link ParenthesizedExpression}.\n */\nexport const createParenthesizedExpression = (expression) => make(\"ParenthesizedExpression\", { expression });\n//# sourceMappingURL=createParenthesizedExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,6BAA6B,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,yBAAyB,EAAE,EAAE,UAAU,EAAE;;;;"}
+{"version":3,"file":"createParenthesizedExpression.mjs","sources":["../../../src/factory/expressions/createParenthesizedExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,6BAA6B,GAAG,CAC3C,UAAsB,KACM,IAAI,CAAC,yBAAyB,EAAE,EAAE,UAAU,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createPartiallyEmittedExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createPartiallyEmittedExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link PartiallyEmittedExpression}: a transform wrapper that prints\n * only its inner `expression`.\n *\n * This node exists to carry transform bookkeeping such as the `original` source\n * node while the surrounding syntax (for example a stripped type assertion) is\n * dropped. The printer emits the inner expression alone; the wrapper itself\n * adds nothing to the output.\n *\n * With `expression` of `a`, the printer emits:\n *\n * ```ts\n * a;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression to emit.\n * @param original The original node this was derived from, if any.\n * @returns The created {@link PartiallyEmittedExpression}.\n */\nexport const createPartiallyEmittedExpression = (expression, original) => make(\"PartiallyEmittedExpression\", { expression, original });\n//# sourceMappingURL=createPartiallyEmittedExpression.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,gCAAgC,GAAG,CAAC,UAAU,EAAE,QAAQ,KAAK,IAAI,CAAC,4BAA4B,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;;;;"}
+{"version":3,"file":"createPartiallyEmittedExpression.mjs","sources":["../../../src/factory/expressions/createPartiallyEmittedExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;AAmBG;MACU,gCAAgC,GAAG,CAC9C,UAAsB,EACtB,QAAe,KAEf,IAAI,CAAC,4BAA4B,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/expressions/createPostfixDecrement.mjs

@@ -1,5 +1,6 @@
-import { createPostfixUnaryExpression } from './createPostfixUnaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPostfixUnaryExpression } from './createPostfixUnaryExpression.mjs';
 
 /**
  * Create a postfix decrement expression: `operand--`.

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

@@ -1 +1 @@
-{"version":3,"file":"createPostfixDecrement.mjs","sources":["../../../esm-tmp/factory/expressions/createPostfixDecrement.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createPostfixUnaryExpression } from \"./createPostfixUnaryExpression\";\n/**\n * Create a postfix decrement expression: `operand--`.\n *\n * Thin wrapper over {@link createPostfixUnaryExpression} with the `--` operator.\n *\n * With `operand` of `a`, the printer emits:\n *\n * ```ts\n * a--;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param operand The operand to decrement.\n * @returns The created {@link PostfixUnaryExpression}.\n */\nexport const createPostfixDecrement = (operand) => createPostfixUnaryExpression(operand, SyntaxKind.MinusMinusToken);\n//# sourceMappingURL=createPostfixDecrement.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,OAAO,KAAK,4BAA4B,CAAC,OAAO,EAAE,UAAU,CAAC,eAAe;;;;"}
+{"version":3,"file":"createPostfixDecrement.mjs","sources":["../../../src/factory/expressions/createPostfixDecrement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,sBAAsB,GAAG,CACpC,OAAmB,KAEnB,4BAA4B,CAAC,OAAO,EAAE,UAAU,CAAC,eAAe;;;;"}

package/lib/factory/expressions/createPostfixIncrement.mjs

@@ -1,5 +1,6 @@
-import { createPostfixUnaryExpression } from './createPostfixUnaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPostfixUnaryExpression } from './createPostfixUnaryExpression.mjs';
 
 /**
  * Create a postfix increment expression: `operand++`.

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

@@ -1 +1 @@
-{"version":3,"file":"createPostfixIncrement.mjs","sources":["../../../esm-tmp/factory/expressions/createPostfixIncrement.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createPostfixUnaryExpression } from \"./createPostfixUnaryExpression\";\n/**\n * Create a postfix increment expression: `operand++`.\n *\n * Thin wrapper over {@link createPostfixUnaryExpression} with the `++` operator.\n *\n * With `operand` of `a`, the printer emits:\n *\n * ```ts\n * a++;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param operand The operand to increment.\n * @returns The created {@link PostfixUnaryExpression}.\n */\nexport const createPostfixIncrement = (operand) => createPostfixUnaryExpression(operand, SyntaxKind.PlusPlusToken);\n//# sourceMappingURL=createPostfixIncrement.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,OAAO,KAAK,4BAA4B,CAAC,OAAO,EAAE,UAAU,CAAC,aAAa;;;;"}
+{"version":3,"file":"createPostfixIncrement.mjs","sources":["../../../src/factory/expressions/createPostfixIncrement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,sBAAsB,GAAG,CACpC,OAAmB,KAEnB,4BAA4B,CAAC,OAAO,EAAE,UAAU,CAAC,aAAa;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createPostfixUnaryExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createPostfixUnaryExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link PostfixUnaryExpression}: a unary operator that follows its\n * operand.\n *\n * `operand` is the target and `operator` is the trailing token, one of `++` or\n * `--`. The printer appends the operator directly after the operand with no\n * space.\n *\n * With `operand` of `a` and `operator` of `++`, the printer emits:\n *\n * ```ts\n * a++;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param operand The operand.\n * @param operator The trailing operator token (`++` or `--`).\n * @returns The created {@link PostfixUnaryExpression}.\n */\nexport const createPostfixUnaryExpression = (operand, operator) => make(\"PostfixUnaryExpression\", { operand, operator });\n//# sourceMappingURL=createPostfixUnaryExpression.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,4BAA4B,GAAG,CAAC,OAAO,EAAE,QAAQ,KAAK,IAAI,CAAC,wBAAwB,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE;;;;"}
+{"version":3,"file":"createPostfixUnaryExpression.mjs","sources":["../../../src/factory/expressions/createPostfixUnaryExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;AAkBG;MACU,4BAA4B,GAAG,CAC1C,OAAmB,EACnB,QAAoB,KAEpB,IAAI,CAAC,wBAAwB,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/expressions/createPrefixDecrement.mjs

@@ -1,5 +1,6 @@
-import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
 
 /**
  * Create a prefix decrement expression: `--operand`.

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

@@ -1 +1 @@
-{"version":3,"file":"createPrefixDecrement.mjs","sources":["../../../esm-tmp/factory/expressions/createPrefixDecrement.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createPrefixUnaryExpression } from \"./createPrefixUnaryExpression\";\n/**\n * Create a prefix decrement expression: `--operand`.\n *\n * Thin wrapper over {@link createPrefixUnaryExpression} with the `--` operator.\n *\n * With `operand` of `a`, the printer emits:\n *\n * ```ts\n * --a;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param operand The operand to decrement.\n * @returns The created {@link PrefixUnaryExpression}.\n */\nexport const createPrefixDecrement = (operand) => createPrefixUnaryExpression(SyntaxKind.MinusMinusToken, operand);\n//# sourceMappingURL=createPrefixDecrement.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,OAAO,KAAK,2BAA2B,CAAC,UAAU,CAAC,eAAe,EAAE,OAAO;;;;"}
+{"version":3,"file":"createPrefixDecrement.mjs","sources":["../../../src/factory/expressions/createPrefixDecrement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,qBAAqB,GAAG,CACnC,OAAmB,KAEnB,2BAA2B,CAAC,UAAU,CAAC,eAAe,EAAE,OAAO;;;;"}

package/lib/factory/expressions/createPrefixIncrement.mjs

@@ -1,5 +1,6 @@
-import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
 
 /**
  * Create a prefix increment expression: `++operand`.

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

@@ -1 +1 @@
-{"version":3,"file":"createPrefixIncrement.mjs","sources":["../../../esm-tmp/factory/expressions/createPrefixIncrement.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createPrefixUnaryExpression } from \"./createPrefixUnaryExpression\";\n/**\n * Create a prefix increment expression: `++operand`.\n *\n * Thin wrapper over {@link createPrefixUnaryExpression} with the `++` operator.\n *\n * With `operand` of `a`, the printer emits:\n *\n * ```ts\n * ++a;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param operand The operand to increment.\n * @returns The created {@link PrefixUnaryExpression}.\n */\nexport const createPrefixIncrement = (operand) => createPrefixUnaryExpression(SyntaxKind.PlusPlusToken, operand);\n//# sourceMappingURL=createPrefixIncrement.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,OAAO,KAAK,2BAA2B,CAAC,UAAU,CAAC,aAAa,EAAE,OAAO;;;;"}
+{"version":3,"file":"createPrefixIncrement.mjs","sources":["../../../src/factory/expressions/createPrefixIncrement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,qBAAqB,GAAG,CACnC,OAAmB,KAEnB,2BAA2B,CAAC,UAAU,CAAC,aAAa,EAAE,OAAO;;;;"}

package/lib/factory/expressions/createPrefixMinus.mjs

@@ -1,5 +1,6 @@
-import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
 
 /**
  * Create a unary minus expression: `-operand`.

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

@@ -1 +1 @@
-{"version":3,"file":"createPrefixMinus.mjs","sources":["../../../esm-tmp/factory/expressions/createPrefixMinus.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createPrefixUnaryExpression } from \"./createPrefixUnaryExpression\";\n/**\n * Create a unary minus expression: `-operand`.\n *\n * Thin wrapper over {@link createPrefixUnaryExpression} with the `-` operator.\n *\n * With `operand` of `1`, the printer emits:\n *\n * ```ts\n * -1;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param operand The operand to negate.\n * @returns The created {@link PrefixUnaryExpression}.\n */\nexport const createPrefixMinus = (operand) => createPrefixUnaryExpression(SyntaxKind.MinusToken, operand);\n//# sourceMappingURL=createPrefixMinus.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,iBAAiB,GAAG,CAAC,OAAO,KAAK,2BAA2B,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO;;;;"}
+{"version":3,"file":"createPrefixMinus.mjs","sources":["../../../src/factory/expressions/createPrefixMinus.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,iBAAiB,GAAG,CAAC,OAAmB,KACnD,2BAA2B,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO;;;;"}

package/lib/factory/expressions/createPrefixPlus.mjs

@@ -1,5 +1,6 @@
-import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
 
 /**
  * Create a unary plus expression: `+operand`.

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

@@ -1 +1 @@
-{"version":3,"file":"createPrefixPlus.mjs","sources":["../../../esm-tmp/factory/expressions/createPrefixPlus.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createPrefixUnaryExpression } from \"./createPrefixUnaryExpression\";\n/**\n * Create a unary plus expression: `+operand`.\n *\n * Thin wrapper over {@link createPrefixUnaryExpression} with the `+` operator.\n *\n * With `operand` of `a`, the printer emits:\n *\n * ```ts\n * +a;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param operand The operand.\n * @returns The created {@link PrefixUnaryExpression}.\n */\nexport const createPrefixPlus = (operand) => createPrefixUnaryExpression(SyntaxKind.PlusToken, operand);\n//# sourceMappingURL=createPrefixPlus.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gBAAgB,GAAG,CAAC,OAAO,KAAK,2BAA2B,CAAC,UAAU,CAAC,SAAS,EAAE,OAAO;;;;"}
+{"version":3,"file":"createPrefixPlus.mjs","sources":["../../../src/factory/expressions/createPrefixPlus.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,gBAAgB,GAAG,CAAC,OAAmB,KAClD,2BAA2B,CAAC,UAAU,CAAC,SAAS,EAAE,OAAO;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createPrefixUnaryExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createPrefixUnaryExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link PrefixUnaryExpression}: a unary operator that precedes its\n * operand.\n *\n * `operator` is the leading token, one of `+`, `-`, `~`, `!`, `++`, or `--`,\n * and `operand` is the target. The printer writes the operator immediately\n * before the operand with no space.\n *\n * With `operator` of `-` and `operand` of `1`, the printer emits:\n *\n * ```ts\n * -1;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param operator The leading operator token.\n * @param operand The operand.\n * @returns The created {@link PrefixUnaryExpression}.\n */\nexport const createPrefixUnaryExpression = (operator, operand) => make(\"PrefixUnaryExpression\", { operator, operand });\n//# sourceMappingURL=createPrefixUnaryExpression.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,2BAA2B,GAAG,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC,uBAAuB,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE;;;;"}
+{"version":3,"file":"createPrefixUnaryExpression.mjs","sources":["../../../src/factory/expressions/createPrefixUnaryExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;AAkBG;MACU,2BAA2B,GAAG,CACzC,QAAoB,EACpB,OAAmB,KAEnB,IAAI,CAAC,uBAAuB,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createPropertyAccessChain.mjs","sources":["../../../esm-tmp/factory/expressions/createPropertyAccessChain.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link PropertyAccessChain}: a member access that participates in an\n * optional chain, such as `a?.b`.\n *\n * `expression` is the receiver and `name` is the accessed member; a string\n * `name` is wrapped in an identifier. `questionDotToken`, when present, makes\n * this link optional and prints as `?.`; when omitted the printer emits a plain\n * `.` while the node still carries chain context.\n *\n * With `expression` of `a`, a `?.` token, and `name` of `b`, the printer emits:\n *\n * ```ts\n * a?.b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The receiver expression.\n * @param questionDotToken The optional `?.` token, if this link is optional.\n * @param name The accessed member name.\n * @returns The created {@link PropertyAccessChain}.\n */\nexport const createPropertyAccessChain = (expression, questionDotToken, name) => make(\"PropertyAccessChain\", {\n    expression,\n    questionDotToken,\n    name: typeof name === \"string\" ? createIdentifier(name) : name,\n});\n//# sourceMappingURL=createPropertyAccessChain.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,yBAAyB,GAAG,CAAC,UAAU,EAAE,gBAAgB,EAAE,IAAI,KAAK,IAAI,CAAC,qBAAqB,EAAE;AAC7G,IAAI,UAAU;AACd,IAAI,gBAAgB;AACpB,IAAI,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;AAClE,CAAC;;;;"}
+{"version":3,"file":"createPropertyAccessChain.mjs","sources":["../../../src/factory/expressions/createPropertyAccessChain.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,yBAAyB,GAAG,CACvC,UAAsB,EACtB,gBAAmC,EACnC,IAA6C,KAE7C,IAAI,CAAC,qBAAqB,EAAE;IAC1B,UAAU;IACV,gBAAgB;AAChB,IAAA,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;AAC/D,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createPropertyAccessExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createPropertyAccessExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link PropertyAccessExpression}: a dotted member access like `a.b`.\n *\n * `expression` is the receiver and `name` is the accessed member; a string\n * `name` is wrapped in an identifier. The printer joins them with a single dot\n * and no surrounding space.\n *\n * With `expression` of `a` and `name` of `b`, the printer emits:\n *\n * ```ts\n * a.b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The receiver expression.\n * @param name The accessed member name.\n * @returns The created {@link PropertyAccessExpression}.\n */\nexport const createPropertyAccessExpression = (expression, name) => make(\"PropertyAccessExpression\", {\n    expression,\n    name: typeof name === \"string\" ? createIdentifier(name) : name,\n});\n//# sourceMappingURL=createPropertyAccessExpression.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,8BAA8B,GAAG,CAAC,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,0BAA0B,EAAE;AACrG,IAAI,UAAU;AACd,IAAI,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;AAClE,CAAC;;;;"}
+{"version":3,"file":"createPropertyAccessExpression.mjs","sources":["../../../src/factory/expressions/createPropertyAccessExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,8BAA8B,GAAG,CAC5C,UAAsB,EACtB,IAA6C,KAE7C,IAAI,CAAC,0BAA0B,EAAE;IAC/B,UAAU;AACV,IAAA,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;AAC/D,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createPropertyAssignment.mjs","sources":["../../../esm-tmp/factory/expressions/createPropertyAssignment.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link PropertyAssignment}: a `name: value` member of an object\n * literal.\n *\n * `name` is the property key; a string is converted to a property name node.\n * `initializer` is the assigned value. The printer joins them with a colon and\n * a single space.\n *\n * With `name` of `a` and `initializer` of `1`, the printer emits:\n *\n * ```ts\n * a: 1;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The property name.\n * @param initializer The assigned value.\n * @returns The created {@link PropertyAssignment}.\n */\nexport const createPropertyAssignment = (name, initializer) => make(\"PropertyAssignment\", { name: asPropertyName(name), initializer });\n//# sourceMappingURL=createPropertyAssignment.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,wBAAwB,GAAG,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC,oBAAoB,EAAE,EAAE,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE;;;;"}
+{"version":3,"file":"createPropertyAssignment.mjs","sources":["../../../src/factory/expressions/createPropertyAssignment.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,wBAAwB,GAAG,CACtC,IAA2B,EAC3B,WAAuB,KAEvB,IAAI,CAAC,oBAAoB,EAAE,EAAE,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createRegularExpressionLiteral.mjs","sources":["../../../esm-tmp/factory/expressions/createRegularExpressionLiteral.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link RegularExpressionLiteral}: a regex literal.\n *\n * `text` is the complete literal source, including the slash delimiters and any\n * trailing flags. The printer emits `text` verbatim; it does not validate or\n * re-escape the pattern.\n *\n * With `text` of `/ab+c/i`, the printer emits:\n *\n * ```ts\n * /ab+c/i;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The full regex literal source, including delimiters and flags.\n * @returns The created {@link RegularExpressionLiteral}.\n */\nexport const createRegularExpressionLiteral = (text) => make(\"RegularExpressionLiteral\", { text });\n//# sourceMappingURL=createRegularExpressionLiteral.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,8BAA8B,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,0BAA0B,EAAE,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createRegularExpressionLiteral.mjs","sources":["../../../src/factory/expressions/createRegularExpressionLiteral.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,8BAA8B,GAAG,CAC5C,IAAY,KACiB,IAAI,CAAC,0BAA0B,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/expressions/createRightShift.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a signed right-shift expression: `left >> right`.

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

@@ -1 +1 @@
-{"version":3,"file":"createRightShift.mjs","sources":["../../../esm-tmp/factory/expressions/createRightShift.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a signed 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 createRightShift = (left, right) => createBinaryExpression(left, SyntaxKind.GreaterThanGreaterThanToken, right);\n//# sourceMappingURL=createRightShift.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gBAAgB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,2BAA2B,EAAE,KAAK;;;;"}
+{"version":3,"file":"createRightShift.mjs","sources":["../../../src/factory/expressions/createRightShift.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;AAeG;MACU,gBAAgB,GAAG,CAC9B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,2BAA2B,EAAE,KAAK;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createSatisfiesExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createSatisfiesExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link SatisfiesExpression}: an expression checked against a type\n * with `satisfies`.\n *\n * `expression` is the value and `type` is the type it must conform to without\n * widening or narrowing its inferred type. The printer joins them with the\n * `satisfies` keyword surrounded by single spaces.\n *\n * With `expression` of `x` and `type` of `Foo`, the printer emits:\n *\n * ```ts\n * x satisfies Foo;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression to check.\n * @param type The type the expression must satisfy.\n * @returns The created {@link SatisfiesExpression}.\n */\nexport const createSatisfiesExpression = (expression, type) => make(\"SatisfiesExpression\", { expression, type });\n//# sourceMappingURL=createSatisfiesExpression.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,yBAAyB,GAAG,CAAC,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,qBAAqB,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createSatisfiesExpression.mjs","sources":["../../../src/factory/expressions/createSatisfiesExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;MACU,yBAAyB,GAAG,CACvC,UAAsB,EACtB,IAAc,KACU,IAAI,CAAC,qBAAqB,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createShorthandPropertyAssignment.mjs","sources":["../../../esm-tmp/factory/expressions/createShorthandPropertyAssignment.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../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 */\nexport const createShorthandPropertyAssignment = (name, objectAssignmentInitializer) => make(\"ShorthandPropertyAssignment\", {\n    name: asName(name),\n    objectAssignmentInitializer,\n});\n//# sourceMappingURL=createShorthandPropertyAssignment.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,iCAAiC,GAAG,CAAC,IAAI,EAAE,2BAA2B,KAAK,IAAI,CAAC,6BAA6B,EAAE;AAC5H,IAAI,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;AACtB,IAAI,2BAA2B;AAC/B,CAAC;;;;"}
+{"version":3,"file":"createShorthandPropertyAssignment.mjs","sources":["../../../src/factory/expressions/createShorthandPropertyAssignment.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAQA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,iCAAiC,GAAG,CAC/C,IAAyB,EACzB,2BAAwC,KAExC,IAAI,CAAC,6BAA6B,EAAE;AAClC,IAAA,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;IAClB,2BAA2B;AAC5B,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createSpreadAssignment.mjs","sources":["../../../esm-tmp/factory/expressions/createSpreadAssignment.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createSpreadAssignment = (expression) => make(\"SpreadAssignment\", { expression });\n//# sourceMappingURL=createSpreadAssignment.js.map"],"names":[],"mappings":";;AACA;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;;;;"}
+{"version":3,"file":"createSpreadAssignment.mjs","sources":["../../../src/factory/expressions/createSpreadAssignment.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,sBAAsB,GAAG,CACpC,UAAsB,KACD,IAAI,CAAC,kBAAkB,EAAE,EAAE,UAAU,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createSpreadElement.mjs","sources":["../../../esm-tmp/factory/expressions/createSpreadElement.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createSpreadElement = (expression) => make(\"SpreadElement\", { expression });\n//# sourceMappingURL=createSpreadElement.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,IAAI,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE;;;;"}
+{"version":3,"file":"createSpreadElement.mjs","sources":["../../../src/factory/expressions/createSpreadElement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,mBAAmB,GAAG,CAAC,UAAsB,KACxD,IAAI,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/expressions/createStrictEquality.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a strict equality expression: `left === right`.

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

@@ -1 +1 @@
-{"version":3,"file":"createStrictEquality.mjs","sources":["../../../esm-tmp/factory/expressions/createStrictEquality.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./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 */\nexport const createStrictEquality = (left, right) => createBinaryExpression(left, SyntaxKind.EqualsEqualsEqualsToken, right);\n//# sourceMappingURL=createStrictEquality.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,uBAAuB,EAAE,KAAK;;;;"}
+{"version":3,"file":"createStrictEquality.mjs","sources":["../../../src/factory/expressions/createStrictEquality.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;AAeG;MACU,oBAAoB,GAAG,CAClC,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,uBAAuB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createStrictInequality.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a strict inequality expression: `left !== right`.

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

@@ -1 +1 @@
-{"version":3,"file":"createStrictInequality.mjs","sources":["../../../esm-tmp/factory/expressions/createStrictInequality.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./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 */\nexport const createStrictInequality = (left, right) => createBinaryExpression(left, SyntaxKind.ExclamationEqualsEqualsToken, right);\n//# sourceMappingURL=createStrictInequality.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,4BAA4B,EAAE,KAAK;;;;"}
+{"version":3,"file":"createStrictInequality.mjs","sources":["../../../src/factory/expressions/createStrictInequality.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;AAeG;MACU,sBAAsB,GAAG,CACpC,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,4BAA4B,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createSubtract.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a subtraction expression: `left - right`.

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

@@ -1 +1 @@
-{"version":3,"file":"createSubtract.mjs","sources":["../../../esm-tmp/factory/expressions/createSubtract.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./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 */\nexport const createSubtract = (left, right) => createBinaryExpression(left, SyntaxKind.MinusToken, right);\n//# sourceMappingURL=createSubtract.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,cAAc,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,UAAU,EAAE,KAAK;;;;"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"createTaggedTemplateExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createTaggedTemplateExpression.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createTaggedTemplateExpression = (tag, typeArguments, template) => make(\"TaggedTemplateExpression\", { tag, typeArguments, template });\n//# sourceMappingURL=createTaggedTemplateExpression.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,8BAA8B,GAAG,CAAC,GAAG,EAAE,aAAa,EAAE,QAAQ,KAAK,IAAI,CAAC,0BAA0B,EAAE,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE;;;;"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"createTemplateExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createTemplateExpression.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createTemplateExpression = (head, templateSpans) => make(\"TemplateExpression\", { head, templateSpans });\n//# sourceMappingURL=createTemplateExpression.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,wBAAwB,GAAG,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC,oBAAoB,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE;;;;"}
+{"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.map

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

@@ -1 +1 @@
-{"version":3,"file":"createTypeAssertion.mjs","sources":["../../../esm-tmp/factory/expressions/createTypeAssertion.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createTypeAssertion = (type, expression) => make(\"TypeAssertion\", { type, expression });\n//# sourceMappingURL=createTypeAssertion.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,mBAAmB,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;;;;"}
+{"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.map

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

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create an unsigned right-shift expression: `left >>> right`.

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

@@ -1 +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;;;;"}
+{"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.map

@@ -1 +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;;;;"}
+{"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.map

@@ -1 +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;;;;"}
+{"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.map

@@ -1 +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;;;;"}
+{"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.map

@@ -1 +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;;;;"}
+{"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.map

@@ -1 +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;;;;"}
+{"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.map

@@ -1 +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;;;;"}
+{"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.map

@@ -1 +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;;;;"}
+{"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.map

@@ -1 +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;;;;"}
+{"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.map

@@ -1 +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;;;;"}
+{"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.map

@@ -1 +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;;;;"}
+{"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.map

@@ -1 +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;;;;"}
+{"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.map

@@ -1 +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;;;;"}
+{"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.map

@@ -1 +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;;;;"}
+{"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.map

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

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createImportClause.mjs","sources":["../../../src/factory/imports/createImportClause.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,kBAAkB,GAAG,CAChC,UAAmB,EACnB,IAA4B,EAC5B,aAAyD,KACxC,IAAI,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,aAAa,EAAE;;;;"}