@ttsc/factory 0.15.8 → 0.15.10

package/lib/factory/expressions/createMetaProperty.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMetaProperty = void 0;
-const asName_1 = require("../internal/asName");
-const make_1 = require("../internal/make");
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link MetaProperty}: a meta-property reference like `new.target` or
  * `import.meta`.
@@ -24,6 +23,7 @@ const make_1 = require("../internal/make");
  * @param name The member name following the dot.
  * @returns The created {@link MetaProperty}.
  */
-const createMetaProperty = (keywordToken, name) => (0, make_1.make)("MetaProperty", { keywordToken, name: (0, asName_1.asName)(name) });
-exports.createMetaProperty = createMetaProperty;
+const createMetaProperty = (keywordToken, name) => make("MetaProperty", { keywordToken, name: asName(name) });
+
+export { createMetaProperty };
 //# sourceMappingURL=createMetaProperty.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createMetaProperty.mjs","sources":["createMetaProperty.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createMetaProperty = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../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 */\nconst createMetaProperty = (keywordToken, name) => (0, make_1.make)(\"MetaProperty\", { keywordToken, name: (0, asName_1.asName)(name) });\nexports.createMetaProperty = createMetaProperty;\n//# sourceMappingURL=createMetaProperty.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,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;AACA,MAAM,kBAAkB,GAAG,CAAC,YAAY,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC;AACvI,OAAO,CAAC,kBAAkB,GAAG,kBAAkB"}
+{"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;;;;"}

package/lib/factory/expressions/createModulo.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createModulo = void 0;
-const syntax_1 = require("../../syntax");
-const createBinaryExpression_1 = require("./createBinaryExpression");
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
 /**
  * Create a remainder expression: `left % right`.
  *
@@ -18,6 +17,7 @@ const createBinaryExpression_1 = require("./createBinaryExpression");
  * @param right The right-hand operand.
  * @returns The created {@link BinaryExpression}.
  */
-const createModulo = (left, right) => (0, createBinaryExpression_1.createBinaryExpression)(left, syntax_1.SyntaxKind.PercentToken, right);
-exports.createModulo = createModulo;
+const createModulo = (left, right) => createBinaryExpression(left, SyntaxKind.PercentToken, right);
+
+export { createModulo };
 //# sourceMappingURL=createModulo.mjs.map

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

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

package/lib/factory/expressions/createMultiply.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMultiply = void 0;
-const syntax_1 = require("../../syntax");
-const createBinaryExpression_1 = require("./createBinaryExpression");
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
 /**
  * Create a multiplication expression: `left * right`.
  *
@@ -18,6 +17,7 @@ const createBinaryExpression_1 = require("./createBinaryExpression");
  * @param right The right-hand operand.
  * @returns The created {@link BinaryExpression}.
  */
-const createMultiply = (left, right) => (0, createBinaryExpression_1.createBinaryExpression)(left, syntax_1.SyntaxKind.AsteriskToken, right);
-exports.createMultiply = createMultiply;
+const createMultiply = (left, right) => createBinaryExpression(left, SyntaxKind.AsteriskToken, right);
+
+export { createMultiply };
 //# sourceMappingURL=createMultiply.mjs.map

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

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

package/lib/factory/expressions/createNewExpression.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNewExpression = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link NewExpression}: a constructor call with `new`.
  *
@@ -21,10 +20,11 @@ const make_1 = require("../internal/make");
  * @param argumentsArray The constructor arguments.
  * @returns The created {@link NewExpression}.
  */
-const createNewExpression = (expression, typeArguments, argumentsArray) => (0, make_1.make)("NewExpression", {
+const createNewExpression = (expression, typeArguments, argumentsArray) => make("NewExpression", {
     expression,
     typeArguments,
     arguments: argumentsArray,
 });
-exports.createNewExpression = createNewExpression;
+
+export { createNewExpression };
 //# sourceMappingURL=createNewExpression.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createNewExpression.mjs","sources":["createNewExpression.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createNewExpression = void 0;\nconst make_1 = require(\"../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 */\nconst createNewExpression = (expression, typeArguments, argumentsArray) => (0, make_1.make)(\"NewExpression\", {\n    expression,\n    typeArguments,\n    arguments: argumentsArray,\n});\nexports.createNewExpression = createNewExpression;\n//# sourceMappingURL=createNewExpression.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;AACA,MAAM,mBAAmB,GAAG,CAAC,UAAU,EAAE,aAAa,EAAE,cAAc,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE;AAC7G,IAAI,UAAU;AACd,IAAI,aAAa;AACjB,IAAI,SAAS,EAAE,cAAc;AAC7B,CAAC,CAAC;AACF,OAAO,CAAC,mBAAmB,GAAG,mBAAmB"}
+{"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;;;;"}

package/lib/factory/expressions/createNonNullChain.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNonNullChain = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link NonNullChain}: a non-null assertion `!` that participates in
  * an optional chain.
@@ -19,6 +18,7 @@ const make_1 = require("../internal/make");
  * @param expression The expression to assert as non-null.
  * @returns The created {@link NonNullChain}.
  */
-const createNonNullChain = (expression) => (0, make_1.make)("NonNullChain", { expression });
-exports.createNonNullChain = createNonNullChain;
+const createNonNullChain = (expression) => make("NonNullChain", { expression });
+
+export { createNonNullChain };
 //# sourceMappingURL=createNonNullChain.mjs.map

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

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

package/lib/factory/expressions/createNonNullExpression.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNonNullExpression = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link NonNullExpression}: a non-null assertion that suffixes
  * `expression` with `!`.
@@ -19,6 +18,7 @@ const make_1 = require("../internal/make");
  * @param expression The expression to assert as non-null.
  * @returns The created {@link NonNullExpression}.
  */
-const createNonNullExpression = (expression) => (0, make_1.make)("NonNullExpression", { expression });
-exports.createNonNullExpression = createNonNullExpression;
+const createNonNullExpression = (expression) => make("NonNullExpression", { expression });
+
+export { createNonNullExpression };
 //# sourceMappingURL=createNonNullExpression.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createNonNullExpression.mjs","sources":["createNonNullExpression.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createNonNullExpression = void 0;\nconst make_1 = require(\"../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 */\nconst createNonNullExpression = (expression) => (0, make_1.make)(\"NonNullExpression\", { expression });\nexports.createNonNullExpression = createNonNullExpression;\n//# sourceMappingURL=createNonNullExpression.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,uBAAuB,GAAG,MAAM;AACxC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,uBAAuB,GAAG,CAAC,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,mBAAmB,EAAE,EAAE,UAAU,EAAE,CAAC;AACrG,OAAO,CAAC,uBAAuB,GAAG,uBAAuB"}
+{"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;;;;"}

package/lib/factory/expressions/createObjectBindingPattern.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createObjectBindingPattern = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link ObjectBindingPattern}: the `{ ... }` binding form used to
  * destructure an object.
@@ -19,6 +18,7 @@ const make_1 = require("../internal/make");
  * @param elements The binding elements.
  * @returns The created {@link ObjectBindingPattern}.
  */
-const createObjectBindingPattern = (elements) => (0, make_1.make)("ObjectBindingPattern", { elements });
-exports.createObjectBindingPattern = createObjectBindingPattern;
+const createObjectBindingPattern = (elements) => make("ObjectBindingPattern", { elements });
+
+export { createObjectBindingPattern };
 //# sourceMappingURL=createObjectBindingPattern.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createObjectBindingPattern.mjs","sources":["createObjectBindingPattern.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createObjectBindingPattern = void 0;\nconst make_1 = require(\"../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 */\nconst createObjectBindingPattern = (elements) => (0, make_1.make)(\"ObjectBindingPattern\", { elements });\nexports.createObjectBindingPattern = createObjectBindingPattern;\n//# sourceMappingURL=createObjectBindingPattern.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,0BAA0B,GAAG,MAAM;AAC3C,MAAM,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,0BAA0B,GAAG,CAAC,QAAQ,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,sBAAsB,EAAE,EAAE,QAAQ,EAAE,CAAC;AACvG,OAAO,CAAC,0BAA0B,GAAG,0BAA0B"}
+{"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;;;;"}

package/lib/factory/expressions/createObjectLiteralExpression.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createObjectLiteralExpression = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link ObjectLiteralExpression}: a `{ ... }` object literal.
  *
@@ -22,6 +21,7 @@ const make_1 = require("../internal/make");
  * @param multiLine When `true`, print one entry per line.
  * @returns The created {@link ObjectLiteralExpression}.
  */
-const createObjectLiteralExpression = (properties = [], multiLine) => (0, make_1.make)("ObjectLiteralExpression", { properties, multiLine });
-exports.createObjectLiteralExpression = createObjectLiteralExpression;
+const createObjectLiteralExpression = (properties = [], multiLine) => make("ObjectLiteralExpression", { properties, multiLine });
+
+export { createObjectLiteralExpression };
 //# sourceMappingURL=createObjectLiteralExpression.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createObjectLiteralExpression.mjs","sources":["createObjectLiteralExpression.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createObjectLiteralExpression = void 0;\nconst make_1 = require(\"../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 */\nconst createObjectLiteralExpression = (properties = [], multiLine) => (0, make_1.make)(\"ObjectLiteralExpression\", { properties, multiLine });\nexports.createObjectLiteralExpression = createObjectLiteralExpression;\n//# sourceMappingURL=createObjectLiteralExpression.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,6BAA6B,GAAG,MAAM;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,6BAA6B,GAAG,CAAC,UAAU,GAAG,EAAE,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,yBAAyB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;AAC5I,OAAO,CAAC,6BAA6B,GAAG,6BAA6B"}
+{"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;;;;"}

package/lib/factory/expressions/createOmittedExpression.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOmittedExpression = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link OmittedExpression}: an elided element, the hole left by a
  * missing entry in an array literal or binding pattern.
@@ -18,6 +17,7 @@ const make_1 = require("../internal/make");
  * @author Jeongho Nam - https://github.com/samchon
  * @returns The created {@link OmittedExpression}.
  */
-const createOmittedExpression = () => (0, make_1.make)("OmittedExpression", {});
-exports.createOmittedExpression = createOmittedExpression;
+const createOmittedExpression = () => make("OmittedExpression", {});
+
+export { createOmittedExpression };
 //# sourceMappingURL=createOmittedExpression.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createOmittedExpression.mjs","sources":["createOmittedExpression.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createOmittedExpression = void 0;\nconst make_1 = require(\"../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 */\nconst createOmittedExpression = () => (0, make_1.make)(\"OmittedExpression\", {});\nexports.createOmittedExpression = createOmittedExpression;\n//# sourceMappingURL=createOmittedExpression.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,uBAAuB,GAAG,MAAM;AACxC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,uBAAuB,GAAG,MAAM,IAAI,MAAM,CAAC,IAAI,EAAE,mBAAmB,EAAE,EAAE,CAAC;AAC/E,OAAO,CAAC,uBAAuB,GAAG,uBAAuB"}
+{"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;;;;"}

package/lib/factory/expressions/createParenthesizedExpression.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createParenthesizedExpression = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link ParenthesizedExpression}: an explicit `( ... )` grouping
  * around `expression`.
@@ -19,6 +18,7 @@ const make_1 = require("../internal/make");
  * @param expression The inner expression to wrap in parentheses.
  * @returns The created {@link ParenthesizedExpression}.
  */
-const createParenthesizedExpression = (expression) => (0, make_1.make)("ParenthesizedExpression", { expression });
-exports.createParenthesizedExpression = createParenthesizedExpression;
+const createParenthesizedExpression = (expression) => make("ParenthesizedExpression", { expression });
+
+export { createParenthesizedExpression };
 //# sourceMappingURL=createParenthesizedExpression.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createParenthesizedExpression.mjs","sources":["createParenthesizedExpression.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createParenthesizedExpression = void 0;\nconst make_1 = require(\"../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 */\nconst createParenthesizedExpression = (expression) => (0, make_1.make)(\"ParenthesizedExpression\", { expression });\nexports.createParenthesizedExpression = createParenthesizedExpression;\n//# sourceMappingURL=createParenthesizedExpression.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,6BAA6B,GAAG,MAAM;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,MAAM,6BAA6B,GAAG,CAAC,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,yBAAyB,EAAE,EAAE,UAAU,EAAE,CAAC;AACjH,OAAO,CAAC,6BAA6B,GAAG,6BAA6B"}
+{"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;;;;"}

package/lib/factory/expressions/createPartiallyEmittedExpression.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPartiallyEmittedExpression = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link PartiallyEmittedExpression}: a transform wrapper that prints
  * only its inner `expression`.
@@ -21,6 +20,7 @@ const make_1 = require("../internal/make");
  * @param original The original node this was derived from, if any.
  * @returns The created {@link PartiallyEmittedExpression}.
  */
-const createPartiallyEmittedExpression = (expression, original) => (0, make_1.make)("PartiallyEmittedExpression", { expression, original });
-exports.createPartiallyEmittedExpression = createPartiallyEmittedExpression;
+const createPartiallyEmittedExpression = (expression, original) => make("PartiallyEmittedExpression", { expression, original });
+
+export { createPartiallyEmittedExpression };
 //# sourceMappingURL=createPartiallyEmittedExpression.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createPartiallyEmittedExpression.mjs","sources":["createPartiallyEmittedExpression.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createPartiallyEmittedExpression = void 0;\nconst make_1 = require(\"../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 */\nconst createPartiallyEmittedExpression = (expression, original) => (0, make_1.make)(\"PartiallyEmittedExpression\", { expression, original });\nexports.createPartiallyEmittedExpression = createPartiallyEmittedExpression;\n//# sourceMappingURL=createPartiallyEmittedExpression.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,gCAAgC,GAAG,MAAM;AACjD,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,gCAAgC,GAAG,CAAC,UAAU,EAAE,QAAQ,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,4BAA4B,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC;AAC3I,OAAO,CAAC,gCAAgC,GAAG,gCAAgC"}
+{"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;;;;"}

package/lib/factory/expressions/createPostfixDecrement.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPostfixDecrement = void 0;
-const syntax_1 = require("../../syntax");
-const createPostfixUnaryExpression_1 = require("./createPostfixUnaryExpression");
+import { createPostfixUnaryExpression } from './createPostfixUnaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
 /**
  * Create a postfix decrement expression: `operand--`.
  *
@@ -17,6 +16,7 @@ const createPostfixUnaryExpression_1 = require("./createPostfixUnaryExpression")
  * @param operand The operand to decrement.
  * @returns The created {@link PostfixUnaryExpression}.
  */
-const createPostfixDecrement = (operand) => (0, createPostfixUnaryExpression_1.createPostfixUnaryExpression)(operand, syntax_1.SyntaxKind.MinusMinusToken);
-exports.createPostfixDecrement = createPostfixDecrement;
+const createPostfixDecrement = (operand) => createPostfixUnaryExpression(operand, SyntaxKind.MinusMinusToken);
+
+export { createPostfixDecrement };
 //# sourceMappingURL=createPostfixDecrement.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createPostfixDecrement.mjs","sources":["createPostfixDecrement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createPostfixDecrement = void 0;\nconst syntax_1 = require(\"../../syntax\");\nconst createPostfixUnaryExpression_1 = require(\"./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 */\nconst createPostfixDecrement = (operand) => (0, createPostfixUnaryExpression_1.createPostfixUnaryExpression)(operand, syntax_1.SyntaxKind.MinusMinusToken);\nexports.createPostfixDecrement = createPostfixDecrement;\n//# sourceMappingURL=createPostfixDecrement.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,8BAA8B,GAAG,OAAO,CAAC,gCAAgC,CAAC;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,sBAAsB,GAAG,CAAC,OAAO,KAAK,IAAI,8BAA8B,CAAC,4BAA4B,EAAE,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAC,eAAe,CAAC;AAC1J,OAAO,CAAC,sBAAsB,GAAG,sBAAsB"}
+{"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;;;;"}

package/lib/factory/expressions/createPostfixIncrement.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPostfixIncrement = void 0;
-const syntax_1 = require("../../syntax");
-const createPostfixUnaryExpression_1 = require("./createPostfixUnaryExpression");
+import { createPostfixUnaryExpression } from './createPostfixUnaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
 /**
  * Create a postfix increment expression: `operand++`.
  *
@@ -17,6 +16,7 @@ const createPostfixUnaryExpression_1 = require("./createPostfixUnaryExpression")
  * @param operand The operand to increment.
  * @returns The created {@link PostfixUnaryExpression}.
  */
-const createPostfixIncrement = (operand) => (0, createPostfixUnaryExpression_1.createPostfixUnaryExpression)(operand, syntax_1.SyntaxKind.PlusPlusToken);
-exports.createPostfixIncrement = createPostfixIncrement;
+const createPostfixIncrement = (operand) => createPostfixUnaryExpression(operand, SyntaxKind.PlusPlusToken);
+
+export { createPostfixIncrement };
 //# sourceMappingURL=createPostfixIncrement.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createPostfixIncrement.mjs","sources":["createPostfixIncrement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createPostfixIncrement = void 0;\nconst syntax_1 = require(\"../../syntax\");\nconst createPostfixUnaryExpression_1 = require(\"./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 */\nconst createPostfixIncrement = (operand) => (0, createPostfixUnaryExpression_1.createPostfixUnaryExpression)(operand, syntax_1.SyntaxKind.PlusPlusToken);\nexports.createPostfixIncrement = createPostfixIncrement;\n//# sourceMappingURL=createPostfixIncrement.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,8BAA8B,GAAG,OAAO,CAAC,gCAAgC,CAAC;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,sBAAsB,GAAG,CAAC,OAAO,KAAK,IAAI,8BAA8B,CAAC,4BAA4B,EAAE,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAC,aAAa,CAAC;AACxJ,OAAO,CAAC,sBAAsB,GAAG,sBAAsB"}
+{"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;;;;"}

package/lib/factory/expressions/createPostfixUnaryExpression.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPostfixUnaryExpression = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link PostfixUnaryExpression}: a unary operator that follows its
  * operand.
@@ -20,6 +19,7 @@ const make_1 = require("../internal/make");
  * @param operator The trailing operator token (`++` or `--`).
  * @returns The created {@link PostfixUnaryExpression}.
  */
-const createPostfixUnaryExpression = (operand, operator) => (0, make_1.make)("PostfixUnaryExpression", { operand, operator });
-exports.createPostfixUnaryExpression = createPostfixUnaryExpression;
+const createPostfixUnaryExpression = (operand, operator) => make("PostfixUnaryExpression", { operand, operator });
+
+export { createPostfixUnaryExpression };
 //# sourceMappingURL=createPostfixUnaryExpression.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createPostfixUnaryExpression.mjs","sources":["createPostfixUnaryExpression.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createPostfixUnaryExpression = void 0;\nconst make_1 = require(\"../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 */\nconst createPostfixUnaryExpression = (operand, operator) => (0, make_1.make)(\"PostfixUnaryExpression\", { operand, operator });\nexports.createPostfixUnaryExpression = createPostfixUnaryExpression;\n//# sourceMappingURL=createPostfixUnaryExpression.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,4BAA4B,GAAG,MAAM;AAC7C,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,4BAA4B,GAAG,CAAC,OAAO,EAAE,QAAQ,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,wBAAwB,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;AAC7H,OAAO,CAAC,4BAA4B,GAAG,4BAA4B"}
+{"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;;;;"}

package/lib/factory/expressions/createPrefixDecrement.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPrefixDecrement = void 0;
-const syntax_1 = require("../../syntax");
-const createPrefixUnaryExpression_1 = require("./createPrefixUnaryExpression");
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
 /**
  * Create a prefix decrement expression: `--operand`.
  *
@@ -17,6 +16,7 @@ const createPrefixUnaryExpression_1 = require("./createPrefixUnaryExpression");
  * @param operand The operand to decrement.
  * @returns The created {@link PrefixUnaryExpression}.
  */
-const createPrefixDecrement = (operand) => (0, createPrefixUnaryExpression_1.createPrefixUnaryExpression)(syntax_1.SyntaxKind.MinusMinusToken, operand);
-exports.createPrefixDecrement = createPrefixDecrement;
+const createPrefixDecrement = (operand) => createPrefixUnaryExpression(SyntaxKind.MinusMinusToken, operand);
+
+export { createPrefixDecrement };
 //# sourceMappingURL=createPrefixDecrement.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createPrefixDecrement.mjs","sources":["createPrefixDecrement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createPrefixDecrement = void 0;\nconst syntax_1 = require(\"../../syntax\");\nconst createPrefixUnaryExpression_1 = require(\"./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 */\nconst createPrefixDecrement = (operand) => (0, createPrefixUnaryExpression_1.createPrefixUnaryExpression)(syntax_1.SyntaxKind.MinusMinusToken, operand);\nexports.createPrefixDecrement = createPrefixDecrement;\n//# sourceMappingURL=createPrefixDecrement.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,qBAAqB,GAAG,MAAM;AACtC,MAAM,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC;AACxC,MAAM,6BAA6B,GAAG,OAAO,CAAC,+BAA+B,CAAC;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,qBAAqB,GAAG,CAAC,OAAO,KAAK,IAAI,6BAA6B,CAAC,2BAA2B,EAAE,QAAQ,CAAC,UAAU,CAAC,eAAe,EAAE,OAAO,CAAC;AACvJ,OAAO,CAAC,qBAAqB,GAAG,qBAAqB"}
+{"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;;;;"}

package/lib/factory/expressions/createPrefixIncrement.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPrefixIncrement = void 0;
-const syntax_1 = require("../../syntax");
-const createPrefixUnaryExpression_1 = require("./createPrefixUnaryExpression");
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
 /**
  * Create a prefix increment expression: `++operand`.
  *
@@ -17,6 +16,7 @@ const createPrefixUnaryExpression_1 = require("./createPrefixUnaryExpression");
  * @param operand The operand to increment.
  * @returns The created {@link PrefixUnaryExpression}.
  */
-const createPrefixIncrement = (operand) => (0, createPrefixUnaryExpression_1.createPrefixUnaryExpression)(syntax_1.SyntaxKind.PlusPlusToken, operand);
-exports.createPrefixIncrement = createPrefixIncrement;
+const createPrefixIncrement = (operand) => createPrefixUnaryExpression(SyntaxKind.PlusPlusToken, operand);
+
+export { createPrefixIncrement };
 //# sourceMappingURL=createPrefixIncrement.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createPrefixIncrement.mjs","sources":["createPrefixIncrement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createPrefixIncrement = void 0;\nconst syntax_1 = require(\"../../syntax\");\nconst createPrefixUnaryExpression_1 = require(\"./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 */\nconst createPrefixIncrement = (operand) => (0, createPrefixUnaryExpression_1.createPrefixUnaryExpression)(syntax_1.SyntaxKind.PlusPlusToken, operand);\nexports.createPrefixIncrement = createPrefixIncrement;\n//# sourceMappingURL=createPrefixIncrement.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,qBAAqB,GAAG,MAAM;AACtC,MAAM,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC;AACxC,MAAM,6BAA6B,GAAG,OAAO,CAAC,+BAA+B,CAAC;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,qBAAqB,GAAG,CAAC,OAAO,KAAK,IAAI,6BAA6B,CAAC,2BAA2B,EAAE,QAAQ,CAAC,UAAU,CAAC,aAAa,EAAE,OAAO,CAAC;AACrJ,OAAO,CAAC,qBAAqB,GAAG,qBAAqB"}
+{"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;;;;"}

package/lib/factory/expressions/createPrefixMinus.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPrefixMinus = void 0;
-const syntax_1 = require("../../syntax");
-const createPrefixUnaryExpression_1 = require("./createPrefixUnaryExpression");
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
 /**
  * Create a unary minus expression: `-operand`.
  *
@@ -17,6 +16,7 @@ const createPrefixUnaryExpression_1 = require("./createPrefixUnaryExpression");
  * @param operand The operand to negate.
  * @returns The created {@link PrefixUnaryExpression}.
  */
-const createPrefixMinus = (operand) => (0, createPrefixUnaryExpression_1.createPrefixUnaryExpression)(syntax_1.SyntaxKind.MinusToken, operand);
-exports.createPrefixMinus = createPrefixMinus;
+const createPrefixMinus = (operand) => createPrefixUnaryExpression(SyntaxKind.MinusToken, operand);
+
+export { createPrefixMinus };
 //# sourceMappingURL=createPrefixMinus.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createPrefixMinus.mjs","sources":["createPrefixMinus.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createPrefixMinus = void 0;\nconst syntax_1 = require(\"../../syntax\");\nconst createPrefixUnaryExpression_1 = require(\"./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 */\nconst createPrefixMinus = (operand) => (0, createPrefixUnaryExpression_1.createPrefixUnaryExpression)(syntax_1.SyntaxKind.MinusToken, operand);\nexports.createPrefixMinus = createPrefixMinus;\n//# sourceMappingURL=createPrefixMinus.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,iBAAiB,GAAG,MAAM;AAClC,MAAM,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC;AACxC,MAAM,6BAA6B,GAAG,OAAO,CAAC,+BAA+B,CAAC;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,iBAAiB,GAAG,CAAC,OAAO,KAAK,IAAI,6BAA6B,CAAC,2BAA2B,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CAAC;AAC9I,OAAO,CAAC,iBAAiB,GAAG,iBAAiB"}
+{"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;;;;"}

package/lib/factory/expressions/createPrefixPlus.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPrefixPlus = void 0;
-const syntax_1 = require("../../syntax");
-const createPrefixUnaryExpression_1 = require("./createPrefixUnaryExpression");
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
 /**
  * Create a unary plus expression: `+operand`.
  *
@@ -17,6 +16,7 @@ const createPrefixUnaryExpression_1 = require("./createPrefixUnaryExpression");
  * @param operand The operand.
  * @returns The created {@link PrefixUnaryExpression}.
  */
-const createPrefixPlus = (operand) => (0, createPrefixUnaryExpression_1.createPrefixUnaryExpression)(syntax_1.SyntaxKind.PlusToken, operand);
-exports.createPrefixPlus = createPrefixPlus;
+const createPrefixPlus = (operand) => createPrefixUnaryExpression(SyntaxKind.PlusToken, operand);
+
+export { createPrefixPlus };
 //# sourceMappingURL=createPrefixPlus.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createPrefixPlus.mjs","sources":["createPrefixPlus.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createPrefixPlus = void 0;\nconst syntax_1 = require(\"../../syntax\");\nconst createPrefixUnaryExpression_1 = require(\"./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 */\nconst createPrefixPlus = (operand) => (0, createPrefixUnaryExpression_1.createPrefixUnaryExpression)(syntax_1.SyntaxKind.PlusToken, operand);\nexports.createPrefixPlus = createPrefixPlus;\n//# sourceMappingURL=createPrefixPlus.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,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC;AACxC,MAAM,6BAA6B,GAAG,OAAO,CAAC,+BAA+B,CAAC;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,gBAAgB,GAAG,CAAC,OAAO,KAAK,IAAI,6BAA6B,CAAC,2BAA2B,EAAE,QAAQ,CAAC,UAAU,CAAC,SAAS,EAAE,OAAO,CAAC;AAC5I,OAAO,CAAC,gBAAgB,GAAG,gBAAgB"}
+{"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;;;;"}

package/lib/factory/expressions/createPrefixUnaryExpression.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPrefixUnaryExpression = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link PrefixUnaryExpression}: a unary operator that precedes its
  * operand.
@@ -20,6 +19,7 @@ const make_1 = require("../internal/make");
  * @param operand The operand.
  * @returns The created {@link PrefixUnaryExpression}.
  */
-const createPrefixUnaryExpression = (operator, operand) => (0, make_1.make)("PrefixUnaryExpression", { operator, operand });
-exports.createPrefixUnaryExpression = createPrefixUnaryExpression;
+const createPrefixUnaryExpression = (operator, operand) => make("PrefixUnaryExpression", { operator, operand });
+
+export { createPrefixUnaryExpression };
 //# sourceMappingURL=createPrefixUnaryExpression.mjs.map