@ttsc/factory 0.15.8 → 0.15.10

package/lib/factory/statements/createLabeledStatement.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLabeledStatement = 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 LabeledStatement}: a `label: ...` statement.
  *
@@ -23,6 +22,7 @@ const make_1 = require("../internal/make");
  * @param statement The statement.
  * @returns The created {@link LabeledStatement}.
  */
-const createLabeledStatement = (label, statement) => (0, make_1.make)("LabeledStatement", { label: (0, asName_1.asName)(label), statement });
-exports.createLabeledStatement = createLabeledStatement;
+const createLabeledStatement = (label, statement) => make("LabeledStatement", { label: asName(label), statement });
+
+export { createLabeledStatement };
 //# sourceMappingURL=createLabeledStatement.mjs.map

package/lib/factory/statements/createLabeledStatement.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createLabeledStatement.mjs","sources":["createLabeledStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createLabeledStatement = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link LabeledStatement}: a `label: ...` statement.\n *\n * The `label` names the statement so a `break` or `continue` can target it; a\n * string is wrapped into an identifier. The `statement` is the body the label\n * applies to, typically a loop.\n *\n * With a `label` of `outer` and a `statement` of an empty `for` loop that calls\n * `break outer`, the result is:\n *\n * ```ts\n * outer: for (;;) {\n *   break outer;\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param label The label.\n * @param statement The statement.\n * @returns The created {@link LabeledStatement}.\n */\nconst createLabeledStatement = (label, statement) => (0, make_1.make)(\"LabeledStatement\", { label: (0, asName_1.asName)(label), statement });\nexports.createLabeledStatement = createLabeledStatement;\n//# sourceMappingURL=createLabeledStatement.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,oBAAoB,CAAC;AAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,sBAAsB,GAAG,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,EAAE,KAAK,EAAE,IAAI,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC;AAC5I,OAAO,CAAC,sBAAsB,GAAG,sBAAsB"}
+{"version":3,"file":"createLabeledStatement.mjs","sources":["../../../esm-tmp/factory/statements/createLabeledStatement.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link LabeledStatement}: a `label: ...` statement.\n *\n * The `label` names the statement so a `break` or `continue` can target it; a\n * string is wrapped into an identifier. The `statement` is the body the label\n * applies to, typically a loop.\n *\n * With a `label` of `outer` and a `statement` of an empty `for` loop that calls\n * `break outer`, the result is:\n *\n * ```ts\n * outer: for (;;) {\n *   break outer;\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param label The label.\n * @param statement The statement.\n * @returns The created {@link LabeledStatement}.\n */\nexport const createLabeledStatement = (label, statement) => make(\"LabeledStatement\", { label: asName(label), statement });\n//# sourceMappingURL=createLabeledStatement.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,sBAAsB,GAAG,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC,kBAAkB,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/statements/createNotEmittedStatement.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNotEmittedStatement = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link NotEmittedStatement}: a placeholder that prints nothing.
  *
@@ -15,6 +14,7 @@ const make_1 = require("../internal/make");
  * @param original The original node this placeholder replaces, if any.
  * @returns The created {@link NotEmittedStatement}.
  */
-const createNotEmittedStatement = (original) => (0, make_1.make)("NotEmittedStatement", { original });
-exports.createNotEmittedStatement = createNotEmittedStatement;
+const createNotEmittedStatement = (original) => make("NotEmittedStatement", { original });
+
+export { createNotEmittedStatement };
 //# sourceMappingURL=createNotEmittedStatement.mjs.map

package/lib/factory/statements/createNotEmittedStatement.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createNotEmittedStatement.mjs","sources":["createNotEmittedStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createNotEmittedStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link NotEmittedStatement}: a placeholder that prints nothing.\n *\n * This is a synthetic statement that occupies a slot in the tree but produces\n * no output. The optional `original` records the node this placeholder stands\n * in for, so comments and source positions attached to it can still be carried\n * through.\n *\n * With any `original` (or none), the printed result is empty:\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param original The original node this placeholder replaces, if any.\n * @returns The created {@link NotEmittedStatement}.\n */\nconst createNotEmittedStatement = (original) => (0, make_1.make)(\"NotEmittedStatement\", { original });\nexports.createNotEmittedStatement = createNotEmittedStatement;\n//# sourceMappingURL=createNotEmittedStatement.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,yBAAyB,GAAG,MAAM;AAC1C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,yBAAyB,GAAG,CAAC,QAAQ,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,qBAAqB,EAAE,EAAE,QAAQ,EAAE,CAAC;AACrG,OAAO,CAAC,yBAAyB,GAAG,yBAAyB"}
+{"version":3,"file":"createNotEmittedStatement.mjs","sources":["../../../esm-tmp/factory/statements/createNotEmittedStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link NotEmittedStatement}: a placeholder that prints nothing.\n *\n * This is a synthetic statement that occupies a slot in the tree but produces\n * no output. The optional `original` records the node this placeholder stands\n * in for, so comments and source positions attached to it can still be carried\n * through.\n *\n * With any `original` (or none), the printed result is empty:\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param original The original node this placeholder replaces, if any.\n * @returns The created {@link NotEmittedStatement}.\n */\nexport const createNotEmittedStatement = (original) => make(\"NotEmittedStatement\", { original });\n//# sourceMappingURL=createNotEmittedStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,yBAAyB,GAAG,CAAC,QAAQ,KAAK,IAAI,CAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/statements/createReturnStatement.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createReturnStatement = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link ReturnStatement}: a `return ...;` statement.
  *
@@ -23,6 +22,7 @@ const make_1 = require("../internal/make");
  * @param expression The expression.
  * @returns The created {@link ReturnStatement}.
  */
-const createReturnStatement = (expression) => (0, make_1.make)("ReturnStatement", { expression });
-exports.createReturnStatement = createReturnStatement;
+const createReturnStatement = (expression) => make("ReturnStatement", { expression });
+
+export { createReturnStatement };
 //# sourceMappingURL=createReturnStatement.mjs.map

package/lib/factory/statements/createReturnStatement.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createReturnStatement.mjs","sources":["createReturnStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createReturnStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ReturnStatement}: a `return ...;` statement.\n *\n * The optional `expression` is the value handed back to the caller. Omit it for\n * a bare `return;` that yields `undefined`.\n *\n * With no expression the result is:\n *\n * ```ts\n * return;\n * ```\n *\n * With an `expression` of `value` the result is:\n *\n * ```ts\n * return value;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @returns The created {@link ReturnStatement}.\n */\nconst createReturnStatement = (expression) => (0, make_1.make)(\"ReturnStatement\", { expression });\nexports.createReturnStatement = createReturnStatement;\n//# sourceMappingURL=createReturnStatement.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,qBAAqB,GAAG,MAAM;AACtC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,qBAAqB,GAAG,CAAC,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,UAAU,EAAE,CAAC;AACjG,OAAO,CAAC,qBAAqB,GAAG,qBAAqB"}
+{"version":3,"file":"createReturnStatement.mjs","sources":["../../../esm-tmp/factory/statements/createReturnStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ReturnStatement}: a `return ...;` statement.\n *\n * The optional `expression` is the value handed back to the caller. Omit it for\n * a bare `return;` that yields `undefined`.\n *\n * With no expression the result is:\n *\n * ```ts\n * return;\n * ```\n *\n * With an `expression` of `value` the result is:\n *\n * ```ts\n * return value;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @returns The created {@link ReturnStatement}.\n */\nexport const createReturnStatement = (expression) => make(\"ReturnStatement\", { expression });\n//# sourceMappingURL=createReturnStatement.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,qBAAqB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/statements/createSwitchStatement.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSwitchStatement = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link SwitchStatement}: a `switch (...) { ... }` statement.
  *
@@ -26,6 +25,7 @@ const make_1 = require("../internal/make");
  * @param caseBlock The caseBlock.
  * @returns The created {@link SwitchStatement}.
  */
-const createSwitchStatement = (expression, caseBlock) => (0, make_1.make)("SwitchStatement", { expression, caseBlock });
-exports.createSwitchStatement = createSwitchStatement;
+const createSwitchStatement = (expression, caseBlock) => make("SwitchStatement", { expression, caseBlock });
+
+export { createSwitchStatement };
 //# sourceMappingURL=createSwitchStatement.mjs.map

package/lib/factory/statements/createSwitchStatement.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createSwitchStatement.mjs","sources":["createSwitchStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createSwitchStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link SwitchStatement}: a `switch (...) { ... }` statement.\n *\n * The `expression` is the subject compared against each arm, and `caseBlock` is\n * the braced body of `case` and `default` clauses, built with\n * {@link createCaseBlock}.\n *\n * With `expression` of `x` and a `caseBlock` holding a `case 1:` arm (calling\n * `a()` then `break`) and a `default:` arm (calling `b()`), the result is:\n *\n * ```ts\n * switch (x) {\n *   case 1:\n *     a();\n *     break;\n *   default:\n *     b();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @param caseBlock The caseBlock.\n * @returns The created {@link SwitchStatement}.\n */\nconst createSwitchStatement = (expression, caseBlock) => (0, make_1.make)(\"SwitchStatement\", { expression, caseBlock });\nexports.createSwitchStatement = createSwitchStatement;\n//# sourceMappingURL=createSwitchStatement.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,qBAAqB,GAAG,MAAM;AACtC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,qBAAqB,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;AACvH,OAAO,CAAC,qBAAqB,GAAG,qBAAqB"}
+{"version":3,"file":"createSwitchStatement.mjs","sources":["../../../esm-tmp/factory/statements/createSwitchStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link SwitchStatement}: a `switch (...) { ... }` statement.\n *\n * The `expression` is the subject compared against each arm, and `caseBlock` is\n * the braced body of `case` and `default` clauses, built with\n * {@link createCaseBlock}.\n *\n * With `expression` of `x` and a `caseBlock` holding a `case 1:` arm (calling\n * `a()` then `break`) and a `default:` arm (calling `b()`), the result is:\n *\n * ```ts\n * switch (x) {\n *   case 1:\n *     a();\n *     break;\n *   default:\n *     b();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @param caseBlock The caseBlock.\n * @returns The created {@link SwitchStatement}.\n */\nexport const createSwitchStatement = (expression, caseBlock) => make(\"SwitchStatement\", { expression, caseBlock });\n//# sourceMappingURL=createSwitchStatement.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;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/statements/createThrowStatement.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createThrowStatement = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link ThrowStatement}: a `throw ...;` statement.
  *
@@ -17,6 +16,7 @@ const make_1 = require("../internal/make");
  * @param expression The expression.
  * @returns The created {@link ThrowStatement}.
  */
-const createThrowStatement = (expression) => (0, make_1.make)("ThrowStatement", { expression });
-exports.createThrowStatement = createThrowStatement;
+const createThrowStatement = (expression) => make("ThrowStatement", { expression });
+
+export { createThrowStatement };
 //# sourceMappingURL=createThrowStatement.mjs.map

package/lib/factory/statements/createThrowStatement.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createThrowStatement.mjs","sources":["createThrowStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createThrowStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ThrowStatement}: a `throw ...;` statement.\n *\n * The `expression` is the value raised, commonly a freshly constructed error.\n * Unlike `return`, the expression is required.\n *\n * With an `expression` of `new Error(\"oops\")`, the result is:\n *\n * ```ts\n * throw new Error(\"oops\");\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @returns The created {@link ThrowStatement}.\n */\nconst createThrowStatement = (expression) => (0, make_1.make)(\"ThrowStatement\", { expression });\nexports.createThrowStatement = createThrowStatement;\n//# sourceMappingURL=createThrowStatement.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,oBAAoB,GAAG,MAAM;AACrC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,oBAAoB,GAAG,CAAC,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,gBAAgB,EAAE,EAAE,UAAU,EAAE,CAAC;AAC/F,OAAO,CAAC,oBAAoB,GAAG,oBAAoB"}
+{"version":3,"file":"createThrowStatement.mjs","sources":["../../../esm-tmp/factory/statements/createThrowStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ThrowStatement}: a `throw ...;` statement.\n *\n * The `expression` is the value raised, commonly a freshly constructed error.\n * Unlike `return`, the expression is required.\n *\n * With an `expression` of `new Error(\"oops\")`, the result is:\n *\n * ```ts\n * throw new Error(\"oops\");\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @returns The created {@link ThrowStatement}.\n */\nexport const createThrowStatement = (expression) => make(\"ThrowStatement\", { expression });\n//# sourceMappingURL=createThrowStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,gBAAgB,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/statements/createTryStatement.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTryStatement = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link TryStatement}: a `try { ... } catch { ... } finally { ... }`
  * statement.
@@ -29,6 +28,7 @@ const make_1 = require("../internal/make");
  * @param finallyBlock The finallyBlock.
  * @returns The created {@link TryStatement}.
  */
-const createTryStatement = (tryBlock, catchClause, finallyBlock) => (0, make_1.make)("TryStatement", { tryBlock, catchClause, finallyBlock });
-exports.createTryStatement = createTryStatement;
+const createTryStatement = (tryBlock, catchClause, finallyBlock) => make("TryStatement", { tryBlock, catchClause, finallyBlock });
+
+export { createTryStatement };
 //# sourceMappingURL=createTryStatement.mjs.map

package/lib/factory/statements/createTryStatement.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createTryStatement.mjs","sources":["createTryStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createTryStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link TryStatement}: a `try { ... } catch { ... } finally { ... }`\n * statement.\n *\n * The `tryBlock` is the guarded body. The `catchClause` and `finallyBlock` are\n * both optional, but at least one must be present for valid TypeScript: pass\n * `undefined` for `catchClause` to emit a `try`/`finally`, or `undefined` for\n * `finallyBlock` to emit a `try`/`catch`.\n *\n * With a `tryBlock` calling `risky()`, a `catchClause` binding `e` and calling\n * `handle(e)`, and a `finallyBlock` calling `cleanup()`, the result is:\n *\n * ```ts\n * try {\n *   risky();\n * } catch (e) {\n *   handle(e);\n * } finally {\n *   cleanup();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tryBlock The tryBlock.\n * @param catchClause The catchClause.\n * @param finallyBlock The finallyBlock.\n * @returns The created {@link TryStatement}.\n */\nconst createTryStatement = (tryBlock, catchClause, finallyBlock) => (0, make_1.make)(\"TryStatement\", { tryBlock, catchClause, finallyBlock });\nexports.createTryStatement = createTryStatement;\n//# sourceMappingURL=createTryStatement.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,kBAAkB,GAAG,MAAM;AACnC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,kBAAkB,GAAG,CAAC,QAAQ,EAAE,WAAW,EAAE,YAAY,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,CAAC;AAC7I,OAAO,CAAC,kBAAkB,GAAG,kBAAkB"}
+{"version":3,"file":"createTryStatement.mjs","sources":["../../../esm-tmp/factory/statements/createTryStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TryStatement}: a `try { ... } catch { ... } finally { ... }`\n * statement.\n *\n * The `tryBlock` is the guarded body. The `catchClause` and `finallyBlock` are\n * both optional, but at least one must be present for valid TypeScript: pass\n * `undefined` for `catchClause` to emit a `try`/`finally`, or `undefined` for\n * `finallyBlock` to emit a `try`/`catch`.\n *\n * With a `tryBlock` calling `risky()`, a `catchClause` binding `e` and calling\n * `handle(e)`, and a `finallyBlock` calling `cleanup()`, the result is:\n *\n * ```ts\n * try {\n *   risky();\n * } catch (e) {\n *   handle(e);\n * } finally {\n *   cleanup();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tryBlock The tryBlock.\n * @param catchClause The catchClause.\n * @param finallyBlock The finallyBlock.\n * @returns The created {@link TryStatement}.\n */\nexport const createTryStatement = (tryBlock, catchClause, finallyBlock) => make(\"TryStatement\", { tryBlock, catchClause, finallyBlock });\n//# sourceMappingURL=createTryStatement.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;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,CAAC,QAAQ,EAAE,WAAW,EAAE,YAAY,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE;;;;"}

package/lib/factory/statements/createVariableDeclaration.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVariableDeclaration = void 0;
-const make_1 = require("../internal/make");
-const createIdentifier_1 = require("../names/createIdentifier");
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
 /**
  * Create a {@link VariableDeclaration}: one `name = value` binding.
  *
@@ -28,11 +27,12 @@ const createIdentifier_1 = require("../names/createIdentifier");
  * @param initializer The initializer, if any.
  * @returns The created {@link VariableDeclaration}.
  */
-const createVariableDeclaration = (name, exclamationToken, type, initializer) => (0, make_1.make)("VariableDeclaration", {
-    name: typeof name === "string" ? (0, createIdentifier_1.createIdentifier)(name) : name,
+const createVariableDeclaration = (name, exclamationToken, type, initializer) => make("VariableDeclaration", {
+    name: typeof name === "string" ? createIdentifier(name) : name,
     exclamationToken,
     type,
     initializer,
 });
-exports.createVariableDeclaration = createVariableDeclaration;
+
+export { createVariableDeclaration };
 //# sourceMappingURL=createVariableDeclaration.mjs.map

package/lib/factory/statements/createVariableDeclaration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createVariableDeclaration.mjs","sources":["createVariableDeclaration.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createVariableDeclaration = void 0;\nconst make_1 = require(\"../internal/make\");\nconst createIdentifier_1 = require(\"../names/createIdentifier\");\n/**\n * Create a {@link VariableDeclaration}: one `name = value` binding.\n *\n * The `name` is the binding target; a string becomes an identifier, while a\n * {@link BindingName} allows array or object destructuring such as `[a, b]`. The\n * `exclamationToken` adds the definite-assignment `!`, `type` adds a `: T`\n * annotation, and `initializer` adds `= value`. Each of those three is\n * optional.\n *\n * This node is a single declarator, not a full statement: it carries no `const`\n * / `let` / `var` keyword (that lives on the enclosing\n * {@link VariableDeclarationList}) and no trailing semicolon. With a `name` of\n * `x` and an `initializer` of `1`, it prints as:\n *\n * ```ts\n * x = 1;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The name; a {@link BindingName} allows array / object\n *   destructuring (e.g. `const [a, b] = ...`).\n * @param exclamationToken The definite-assignment marker (`!`), if any.\n * @param type The type.\n * @param initializer The initializer, if any.\n * @returns The created {@link VariableDeclaration}.\n */\nconst createVariableDeclaration = (name, exclamationToken, type, initializer) => (0, make_1.make)(\"VariableDeclaration\", {\n    name: typeof name === \"string\" ? (0, createIdentifier_1.createIdentifier)(name) : name,\n    exclamationToken,\n    type,\n    initializer,\n});\nexports.createVariableDeclaration = createVariableDeclaration;\n//# sourceMappingURL=createVariableDeclaration.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,yBAAyB,GAAG,MAAM;AAC1C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C,MAAM,kBAAkB,GAAG,OAAO,CAAC,2BAA2B,CAAC;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,yBAAyB,GAAG,CAAC,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,qBAAqB,EAAE;AACzH,IAAI,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,IAAI,kBAAkB,CAAC,gBAAgB,EAAE,IAAI,CAAC,GAAG,IAAI;AAC1F,IAAI,gBAAgB;AACpB,IAAI,IAAI;AACR,IAAI,WAAW;AACf,CAAC,CAAC;AACF,OAAO,CAAC,yBAAyB,GAAG,yBAAyB"}
+{"version":3,"file":"createVariableDeclaration.mjs","sources":["../../../esm-tmp/factory/statements/createVariableDeclaration.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link VariableDeclaration}: one `name = value` binding.\n *\n * The `name` is the binding target; a string becomes an identifier, while a\n * {@link BindingName} allows array or object destructuring such as `[a, b]`. The\n * `exclamationToken` adds the definite-assignment `!`, `type` adds a `: T`\n * annotation, and `initializer` adds `= value`. Each of those three is\n * optional.\n *\n * This node is a single declarator, not a full statement: it carries no `const`\n * / `let` / `var` keyword (that lives on the enclosing\n * {@link VariableDeclarationList}) and no trailing semicolon. With a `name` of\n * `x` and an `initializer` of `1`, it prints as:\n *\n * ```ts\n * x = 1;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The name; a {@link BindingName} allows array / object\n *   destructuring (e.g. `const [a, b] = ...`).\n * @param exclamationToken The definite-assignment marker (`!`), if any.\n * @param type The type.\n * @param initializer The initializer, if any.\n * @returns The created {@link VariableDeclaration}.\n */\nexport const createVariableDeclaration = (name, exclamationToken, type, initializer) => make(\"VariableDeclaration\", {\n    name: typeof name === \"string\" ? createIdentifier(name) : name,\n    exclamationToken,\n    type,\n    initializer,\n});\n//# sourceMappingURL=createVariableDeclaration.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;AACA;AACA;AACY,MAAC,yBAAyB,GAAG,CAAC,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC,qBAAqB,EAAE;AACpH,IAAI,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;AAClE,IAAI,gBAAgB;AACpB,IAAI,IAAI;AACR,IAAI,WAAW;AACf,CAAC;;;;"}

package/lib/factory/statements/createVariableDeclarationList.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVariableDeclarationList = void 0;
-const syntax_1 = require("../../syntax");
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+import { NodeFlags } from '../../syntax/NodeFlags.mjs';
+
 /**
  * Create a {@link VariableDeclarationList}: the `const x = 1` group.
  *
@@ -22,6 +21,7 @@ const make_1 = require("../internal/make");
  * @param flags The declaration flags (`const` / `let` / `var`).
  * @returns The created {@link VariableDeclarationList}.
  */
-const createVariableDeclarationList = (declarations, flags = syntax_1.NodeFlags.None) => (0, make_1.make)("VariableDeclarationList", { declarations, flags });
-exports.createVariableDeclarationList = createVariableDeclarationList;
+const createVariableDeclarationList = (declarations, flags = NodeFlags.None) => make("VariableDeclarationList", { declarations, flags });
+
+export { createVariableDeclarationList };
 //# sourceMappingURL=createVariableDeclarationList.mjs.map

package/lib/factory/statements/createVariableDeclarationList.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createVariableDeclarationList.mjs","sources":["createVariableDeclarationList.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createVariableDeclarationList = void 0;\nconst syntax_1 = require(\"../../syntax\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link VariableDeclarationList}: the `const x = 1` group.\n *\n * The `declarations` are the comma-separated declarators, and `flags` chooses\n * the keyword the printer emits: `const`, `let`, or plain `var` when no flag is\n * set. This is the keyword-bearing part shared by a {@link VariableStatement}\n * and by `for` loop headers.\n *\n * The list carries no trailing semicolon on its own. With a single declaration\n * of `x = 1` and the `const` flag, it prints as:\n *\n * ```ts\n * const x = 1;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param declarations The declarations.\n * @param flags The declaration flags (`const` / `let` / `var`).\n * @returns The created {@link VariableDeclarationList}.\n */\nconst createVariableDeclarationList = (declarations, flags = syntax_1.NodeFlags.None) => (0, make_1.make)(\"VariableDeclarationList\", { declarations, flags });\nexports.createVariableDeclarationList = createVariableDeclarationList;\n//# sourceMappingURL=createVariableDeclarationList.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,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC;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;AACA;AACA,MAAM,6BAA6B,GAAG,CAAC,YAAY,EAAE,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,yBAAyB,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;AAC7J,OAAO,CAAC,6BAA6B,GAAG,6BAA6B"}
+{"version":3,"file":"createVariableDeclarationList.mjs","sources":["../../../esm-tmp/factory/statements/createVariableDeclarationList.js"],"sourcesContent":["import { NodeFlags } from \"../../syntax\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link VariableDeclarationList}: the `const x = 1` group.\n *\n * The `declarations` are the comma-separated declarators, and `flags` chooses\n * the keyword the printer emits: `const`, `let`, or plain `var` when no flag is\n * set. This is the keyword-bearing part shared by a {@link VariableStatement}\n * and by `for` loop headers.\n *\n * The list carries no trailing semicolon on its own. With a single declaration\n * of `x = 1` and the `const` flag, it prints as:\n *\n * ```ts\n * const x = 1;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param declarations The declarations.\n * @param flags The declaration flags (`const` / `let` / `var`).\n * @returns The created {@link VariableDeclarationList}.\n */\nexport const createVariableDeclarationList = (declarations, flags = NodeFlags.None) => make(\"VariableDeclarationList\", { declarations, flags });\n//# sourceMappingURL=createVariableDeclarationList.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,6BAA6B,GAAG,CAAC,YAAY,EAAE,KAAK,GAAG,SAAS,CAAC,IAAI,KAAK,IAAI,CAAC,yBAAyB,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE;;;;"}

package/lib/factory/statements/createVariableStatement.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVariableStatement = void 0;
-const make_1 = require("../internal/make");
-const createVariableDeclarationList_1 = require("./createVariableDeclarationList");
+import { make } from '../internal/make.mjs';
+import { createVariableDeclarationList } from './createVariableDeclarationList.mjs';
+
 /**
  * Create a {@link VariableStatement}: a full `const x = 1;` statement.
  *
@@ -23,11 +22,12 @@ const createVariableDeclarationList_1 = require("./createVariableDeclarationList
  * @param declarationList The declaration list.
  * @returns The created {@link VariableStatement}.
  */
-const createVariableStatement = (modifiers, declarationList) => (0, make_1.make)("VariableStatement", {
+const createVariableStatement = (modifiers, declarationList) => make("VariableStatement", {
     modifiers,
     declarationList: Array.isArray(declarationList)
-        ? (0, createVariableDeclarationList_1.createVariableDeclarationList)(declarationList)
+        ? createVariableDeclarationList(declarationList)
         : declarationList,
 });
-exports.createVariableStatement = createVariableStatement;
+
+export { createVariableStatement };
 //# sourceMappingURL=createVariableStatement.mjs.map

package/lib/factory/statements/createVariableStatement.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createVariableStatement.mjs","sources":["createVariableStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createVariableStatement = void 0;\nconst make_1 = require(\"../internal/make\");\nconst createVariableDeclarationList_1 = require(\"./createVariableDeclarationList\");\n/**\n * Create a {@link VariableStatement}: a full `const x = 1;` statement.\n *\n * The optional `modifiers` are leading keywords such as `export` or `declare`.\n * The `declarationList` carries the keyword and declarators; pass a\n * {@link VariableDeclarationList} directly, or pass a plain array of\n * declarations and it is wrapped into a list for you (defaulting to `var`, so\n * build the list yourself when you need `const` or `let`).\n *\n * This is the statement-level wrapper that adds the trailing semicolon. With no\n * modifiers and a `const` declaration list of `x = 1`, the result is:\n *\n * ```ts\n * const x = 1;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param declarationList The declaration list.\n * @returns The created {@link VariableStatement}.\n */\nconst createVariableStatement = (modifiers, declarationList) => (0, make_1.make)(\"VariableStatement\", {\n    modifiers,\n    declarationList: Array.isArray(declarationList)\n        ? (0, createVariableDeclarationList_1.createVariableDeclarationList)(declarationList)\n        : declarationList,\n});\nexports.createVariableStatement = createVariableStatement;\n//# sourceMappingURL=createVariableStatement.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,MAAM,+BAA+B,GAAG,OAAO,CAAC,iCAAiC,CAAC;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,uBAAuB,GAAG,CAAC,SAAS,EAAE,eAAe,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,mBAAmB,EAAE;AACtG,IAAI,SAAS;AACb,IAAI,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,eAAe;AAClD,UAAU,IAAI,+BAA+B,CAAC,6BAA6B,EAAE,eAAe;AAC5F,UAAU,eAAe;AACzB,CAAC,CAAC;AACF,OAAO,CAAC,uBAAuB,GAAG,uBAAuB"}
+{"version":3,"file":"createVariableStatement.mjs","sources":["../../../esm-tmp/factory/statements/createVariableStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createVariableDeclarationList } from \"./createVariableDeclarationList\";\n/**\n * Create a {@link VariableStatement}: a full `const x = 1;` statement.\n *\n * The optional `modifiers` are leading keywords such as `export` or `declare`.\n * The `declarationList` carries the keyword and declarators; pass a\n * {@link VariableDeclarationList} directly, or pass a plain array of\n * declarations and it is wrapped into a list for you (defaulting to `var`, so\n * build the list yourself when you need `const` or `let`).\n *\n * This is the statement-level wrapper that adds the trailing semicolon. With no\n * modifiers and a `const` declaration list of `x = 1`, the result is:\n *\n * ```ts\n * const x = 1;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param declarationList The declaration list.\n * @returns The created {@link VariableStatement}.\n */\nexport const createVariableStatement = (modifiers, declarationList) => make(\"VariableStatement\", {\n    modifiers,\n    declarationList: Array.isArray(declarationList)\n        ? createVariableDeclarationList(declarationList)\n        : declarationList,\n});\n//# sourceMappingURL=createVariableStatement.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,SAAS,EAAE,eAAe,KAAK,IAAI,CAAC,mBAAmB,EAAE;AACjG,IAAI,SAAS;AACb,IAAI,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,eAAe;AAClD,UAAU,6BAA6B,CAAC,eAAe;AACvD,UAAU,eAAe;AACzB,CAAC;;;;"}

package/lib/factory/statements/createWhileStatement.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWhileStatement = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link WhileStatement}: a `while (...) ...` loop.
  *
@@ -22,6 +21,7 @@ const make_1 = require("../internal/make");
  * @param statement The statement.
  * @returns The created {@link WhileStatement}.
  */
-const createWhileStatement = (expression, statement) => (0, make_1.make)("WhileStatement", { expression, statement });
-exports.createWhileStatement = createWhileStatement;
+const createWhileStatement = (expression, statement) => make("WhileStatement", { expression, statement });
+
+export { createWhileStatement };
 //# sourceMappingURL=createWhileStatement.mjs.map

package/lib/factory/statements/createWhileStatement.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createWhileStatement.mjs","sources":["createWhileStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createWhileStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link WhileStatement}: a `while (...) ...` loop.\n *\n * The `expression` is the condition tested before each pass and `statement` is\n * the loop body. The body runs zero or more times, only while the condition\n * holds.\n *\n * With an `expression` of `cond` and a `statement` block calling `a()`, the\n * result is:\n *\n * ```ts\n * while (cond) {\n *   a();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @param statement The statement.\n * @returns The created {@link WhileStatement}.\n */\nconst createWhileStatement = (expression, statement) => (0, make_1.make)(\"WhileStatement\", { expression, statement });\nexports.createWhileStatement = createWhileStatement;\n//# sourceMappingURL=createWhileStatement.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,oBAAoB,GAAG,MAAM;AACrC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,oBAAoB,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,gBAAgB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;AACrH,OAAO,CAAC,oBAAoB,GAAG,oBAAoB"}
+{"version":3,"file":"createWhileStatement.mjs","sources":["../../../esm-tmp/factory/statements/createWhileStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link WhileStatement}: a `while (...) ...` loop.\n *\n * The `expression` is the condition tested before each pass and `statement` is\n * the loop body. The body runs zero or more times, only while the condition\n * holds.\n *\n * With an `expression` of `cond` and a `statement` block calling `a()`, the\n * result is:\n *\n * ```ts\n * while (cond) {\n *   a();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @param statement The statement.\n * @returns The created {@link WhileStatement}.\n */\nexport const createWhileStatement = (expression, statement) => make(\"WhileStatement\", { expression, statement });\n//# sourceMappingURL=createWhileStatement.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,oBAAoB,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,CAAC,gBAAgB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/statements/createWithStatement.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWithStatement = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link WithStatement}: a `with (...) ...` statement.
  *
@@ -22,6 +21,7 @@ const make_1 = require("../internal/make");
  * @param statement The statement.
  * @returns The created {@link WithStatement}.
  */
-const createWithStatement = (expression, statement) => (0, make_1.make)("WithStatement", { expression, statement });
-exports.createWithStatement = createWithStatement;
+const createWithStatement = (expression, statement) => make("WithStatement", { expression, statement });
+
+export { createWithStatement };
 //# sourceMappingURL=createWithStatement.mjs.map

package/lib/factory/statements/createWithStatement.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createWithStatement.mjs","sources":["createWithStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createWithStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link WithStatement}: a `with (...) ...` statement.\n *\n * The `expression` supplies the object whose properties join the scope of\n * `statement`, the body. `with` is disallowed in strict mode and in ES modules,\n * so this exists mainly for completeness and faithful round-tripping.\n *\n * With an `expression` of `obj` and a `statement` block calling `a()`, the\n * result is:\n *\n * ```ts\n * with (obj) {\n *   a();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @param statement The statement.\n * @returns The created {@link WithStatement}.\n */\nconst createWithStatement = (expression, statement) => (0, make_1.make)(\"WithStatement\", { expression, statement });\nexports.createWithStatement = createWithStatement;\n//# sourceMappingURL=createWithStatement.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;AACA,MAAM,mBAAmB,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;AACnH,OAAO,CAAC,mBAAmB,GAAG,mBAAmB"}
+{"version":3,"file":"createWithStatement.mjs","sources":["../../../esm-tmp/factory/statements/createWithStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link WithStatement}: a `with (...) ...` statement.\n *\n * The `expression` supplies the object whose properties join the scope of\n * `statement`, the body. `with` is disallowed in strict mode and in ES modules,\n * so this exists mainly for completeness and faithful round-tripping.\n *\n * With an `expression` of `obj` and a `statement` block calling `a()`, the\n * result is:\n *\n * ```ts\n * with (obj) {\n *   a();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @param statement The statement.\n * @returns The created {@link WithStatement}.\n */\nexport const createWithStatement = (expression, statement) => make(\"WithStatement\", { expression, statement });\n//# sourceMappingURL=createWithStatement.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,mBAAmB,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/types/createArrayTypeNode.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createArrayTypeNode = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create an {@link ArrayTypeNode}: a `T[]` postfix array type.
  *
@@ -20,6 +19,7 @@ const make_1 = require("../internal/make");
  * @param elementType The element type.
  * @returns The created {@link ArrayTypeNode}.
  */
-const createArrayTypeNode = (elementType) => (0, make_1.make)("ArrayTypeNode", { elementType });
-exports.createArrayTypeNode = createArrayTypeNode;
+const createArrayTypeNode = (elementType) => make("ArrayTypeNode", { elementType });
+
+export { createArrayTypeNode };
 //# sourceMappingURL=createArrayTypeNode.mjs.map

package/lib/factory/types/createArrayTypeNode.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createArrayTypeNode.mjs","sources":["createArrayTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createArrayTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link ArrayTypeNode}: a `T[]` postfix array type.\n *\n * The element type is emitted in postfix-operand position, so a\n * lower-precedence form that would otherwise re-associate gets wrapped in\n * parentheses first. A union, intersection, function, constructor, conditional,\n * infer, or type-operator element prints as `(...)[]`; anything else prints\n * bare.\n *\n * Given a `string` element, the printer renders:\n *\n * ```ts\n * string[]\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elementType The element type.\n * @returns The created {@link ArrayTypeNode}.\n */\nconst createArrayTypeNode = (elementType) => (0, make_1.make)(\"ArrayTypeNode\", { elementType });\nexports.createArrayTypeNode = createArrayTypeNode;\n//# sourceMappingURL=createArrayTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,mBAAmB,GAAG,MAAM;AACpC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,mBAAmB,GAAG,CAAC,WAAW,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,WAAW,EAAE,CAAC;AAC/F,OAAO,CAAC,mBAAmB,GAAG,mBAAmB"}
+{"version":3,"file":"createArrayTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createArrayTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ArrayTypeNode}: a `T[]` postfix array type.\n *\n * The element type is emitted in postfix-operand position, so a\n * lower-precedence form that would otherwise re-associate gets wrapped in\n * parentheses first. A union, intersection, function, constructor, conditional,\n * infer, or type-operator element prints as `(...)[]`; anything else prints\n * bare.\n *\n * Given a `string` element, the printer renders:\n *\n * ```ts\n * string[]\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elementType The element type.\n * @returns The created {@link ArrayTypeNode}.\n */\nexport const createArrayTypeNode = (elementType) => make(\"ArrayTypeNode\", { elementType });\n//# sourceMappingURL=createArrayTypeNode.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,WAAW,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,WAAW,EAAE;;;;"}

package/lib/factory/types/createCallSignature.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCallSignature = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link CallSignature}: a `(params): ReturnType` call signature for an
  * interface or type literal.
@@ -21,6 +20,7 @@ const make_1 = require("../internal/make");
  * @param type The return type, if any.
  * @returns The created {@link CallSignature}.
  */
-const createCallSignature = (typeParameters, parameters, type) => (0, make_1.make)("CallSignature", { typeParameters, parameters, type });
-exports.createCallSignature = createCallSignature;
+const createCallSignature = (typeParameters, parameters, type) => make("CallSignature", { typeParameters, parameters, type });
+
+export { createCallSignature };
 //# sourceMappingURL=createCallSignature.mjs.map

package/lib/factory/types/createCallSignature.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createCallSignature.mjs","sources":["createCallSignature.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createCallSignature = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link CallSignature}: a `(params): ReturnType` call signature for an\n * interface or type literal.\n *\n * Optional type parameters print first as `<...>`, then the parameter list,\n * then the return type as `: Type` when present.\n *\n * Given one `x: number` parameter and a `string` return type, the printer\n * renders:\n *\n * ```ts\n * (x: number): string\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type, if any.\n * @returns The created {@link CallSignature}.\n */\nconst createCallSignature = (typeParameters, parameters, type) => (0, make_1.make)(\"CallSignature\", { typeParameters, parameters, type });\nexports.createCallSignature = createCallSignature;\n//# sourceMappingURL=createCallSignature.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,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AACzI,OAAO,CAAC,mBAAmB,GAAG,mBAAmB"}
+{"version":3,"file":"createCallSignature.mjs","sources":["../../../esm-tmp/factory/types/createCallSignature.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link CallSignature}: a `(params): ReturnType` call signature for an\n * interface or type literal.\n *\n * Optional type parameters print first as `<...>`, then the parameter list,\n * then the return type as `: Type` when present.\n *\n * Given one `x: number` parameter and a `string` return type, the printer\n * renders:\n *\n * ```ts\n * (x: number): string\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type, if any.\n * @returns The created {@link CallSignature}.\n */\nexport const createCallSignature = (typeParameters, parameters, type) => make(\"CallSignature\", { typeParameters, parameters, type });\n//# sourceMappingURL=createCallSignature.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,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createConditionalTypeNode.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConditionalTypeNode = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link ConditionalTypeNode}: a `C extends E ? X : Y` conditional
  * type.
@@ -23,6 +22,7 @@ const make_1 = require("../internal/make");
  * @param falseType The branch type when the test fails.
  * @returns The created {@link ConditionalTypeNode}.
  */
-const createConditionalTypeNode = (checkType, extendsType, trueType, falseType) => (0, make_1.make)("ConditionalTypeNode", { checkType, extendsType, trueType, falseType });
-exports.createConditionalTypeNode = createConditionalTypeNode;
+const createConditionalTypeNode = (checkType, extendsType, trueType, falseType) => make("ConditionalTypeNode", { checkType, extendsType, trueType, falseType });
+
+export { createConditionalTypeNode };
 //# sourceMappingURL=createConditionalTypeNode.mjs.map

package/lib/factory/types/createConditionalTypeNode.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createConditionalTypeNode.mjs","sources":["createConditionalTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createConditionalTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ConditionalTypeNode}: a `C extends E ? X : Y` conditional\n * type.\n *\n * The four type arms print in order, joined by `extends`, `?`, and `:`. The\n * printer emits each arm as-is without adding parentheses, so the caller is\n * responsible for wrapping any arm that needs grouping.\n *\n * Given check `T`, extends `U`, true `string`, and false `number`, the printer\n * renders:\n *\n * ```ts\n * T extends U ? string : number\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param checkType The type being tested.\n * @param extendsType The type tested against.\n * @param trueType The branch type when the test passes.\n * @param falseType The branch type when the test fails.\n * @returns The created {@link ConditionalTypeNode}.\n */\nconst createConditionalTypeNode = (checkType, extendsType, trueType, falseType) => (0, make_1.make)(\"ConditionalTypeNode\", { checkType, extendsType, trueType, falseType });\nexports.createConditionalTypeNode = createConditionalTypeNode;\n//# sourceMappingURL=createConditionalTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,yBAAyB,GAAG,MAAM;AAC1C,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,yBAAyB,GAAG,CAAC,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,qBAAqB,EAAE,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;AAC3K,OAAO,CAAC,yBAAyB,GAAG,yBAAyB"}
+{"version":3,"file":"createConditionalTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createConditionalTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ConditionalTypeNode}: a `C extends E ? X : Y` conditional\n * type.\n *\n * The four type arms print in order, joined by `extends`, `?`, and `:`. The\n * printer emits each arm as-is without adding parentheses, so the caller is\n * responsible for wrapping any arm that needs grouping.\n *\n * Given check `T`, extends `U`, true `string`, and false `number`, the printer\n * renders:\n *\n * ```ts\n * T extends U ? string : number\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param checkType The type being tested.\n * @param extendsType The type tested against.\n * @param trueType The branch type when the test passes.\n * @param falseType The branch type when the test fails.\n * @returns The created {@link ConditionalTypeNode}.\n */\nexport const createConditionalTypeNode = (checkType, extendsType, trueType, falseType) => make(\"ConditionalTypeNode\", { checkType, extendsType, trueType, falseType });\n//# sourceMappingURL=createConditionalTypeNode.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,yBAAyB,GAAG,CAAC,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,KAAK,IAAI,CAAC,qBAAqB,EAAE,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/types/createConstructSignature.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConstructSignature = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link ConstructSignature}: a `new (params): T` construct signature
  * for an interface or type literal.
@@ -20,6 +19,7 @@ const make_1 = require("../internal/make");
  * @param type The return type, if any.
  * @returns The created {@link ConstructSignature}.
  */
-const createConstructSignature = (typeParameters, parameters, type) => (0, make_1.make)("ConstructSignature", { typeParameters, parameters, type });
-exports.createConstructSignature = createConstructSignature;
+const createConstructSignature = (typeParameters, parameters, type) => make("ConstructSignature", { typeParameters, parameters, type });
+
+export { createConstructSignature };
 //# sourceMappingURL=createConstructSignature.mjs.map

package/lib/factory/types/createConstructSignature.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createConstructSignature.mjs","sources":["createConstructSignature.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createConstructSignature = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ConstructSignature}: a `new (params): T` construct signature\n * for an interface or type literal.\n *\n * The `new ` keyword prints first, then optional type parameters as `<...>`,\n * the parameter list, and the return type as `: Type` when present.\n *\n * Given one `x: number` parameter and a `Foo` return type, the printer renders:\n *\n * ```ts\n * new (x: number): Foo\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type, if any.\n * @returns The created {@link ConstructSignature}.\n */\nconst createConstructSignature = (typeParameters, parameters, type) => (0, make_1.make)(\"ConstructSignature\", { typeParameters, parameters, type });\nexports.createConstructSignature = createConstructSignature;\n//# sourceMappingURL=createConstructSignature.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,wBAAwB,GAAG,MAAM;AACzC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,wBAAwB,GAAG,CAAC,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,oBAAoB,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AACnJ,OAAO,CAAC,wBAAwB,GAAG,wBAAwB"}
+{"version":3,"file":"createConstructSignature.mjs","sources":["../../../esm-tmp/factory/types/createConstructSignature.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ConstructSignature}: a `new (params): T` construct signature\n * for an interface or type literal.\n *\n * The `new ` keyword prints first, then optional type parameters as `<...>`,\n * the parameter list, and the return type as `: Type` when present.\n *\n * Given one `x: number` parameter and a `Foo` return type, the printer renders:\n *\n * ```ts\n * new (x: number): Foo\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type, if any.\n * @returns The created {@link ConstructSignature}.\n */\nexport const createConstructSignature = (typeParameters, parameters, type) => make(\"ConstructSignature\", { typeParameters, parameters, type });\n//# sourceMappingURL=createConstructSignature.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,wBAAwB,GAAG,CAAC,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,oBAAoB,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createConstructorTypeNode.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConstructorTypeNode = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link ConstructorTypeNode}: a `new (params) => T` constructor type.
  *
@@ -22,6 +21,7 @@ const make_1 = require("../internal/make");
  * @param type The return type.
  * @returns The created {@link ConstructorTypeNode}.
  */
-const createConstructorTypeNode = (modifiers, typeParameters, parameters, type) => (0, make_1.make)("ConstructorTypeNode", { modifiers, typeParameters, parameters, type });
-exports.createConstructorTypeNode = createConstructorTypeNode;
+const createConstructorTypeNode = (modifiers, typeParameters, parameters, type) => make("ConstructorTypeNode", { modifiers, typeParameters, parameters, type });
+
+export { createConstructorTypeNode };
 //# sourceMappingURL=createConstructorTypeNode.mjs.map

package/lib/factory/types/createConstructorTypeNode.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createConstructorTypeNode.mjs","sources":["createConstructorTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createConstructorTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ConstructorTypeNode}: a `new (params) => T` constructor type.\n *\n * Any modifiers print first (for example `abstract`), then the `new ` keyword,\n * then optional type parameters as `<...>`, the parameter list, and finally\n * `=>` followed by the return type.\n *\n * Given no modifiers, one `x: number` parameter, and a `Foo` return type, the\n * printer renders:\n *\n * ```ts\n * new (x: number) => Foo\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers, if any.\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type.\n * @returns The created {@link ConstructorTypeNode}.\n */\nconst createConstructorTypeNode = (modifiers, typeParameters, parameters, type) => (0, make_1.make)(\"ConstructorTypeNode\", { modifiers, typeParameters, parameters, type });\nexports.createConstructorTypeNode = createConstructorTypeNode;\n//# sourceMappingURL=createConstructorTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,yBAAyB,GAAG,MAAM;AAC1C,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,yBAAyB,GAAG,CAAC,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,qBAAqB,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AAC3K,OAAO,CAAC,yBAAyB,GAAG,yBAAyB"}
+{"version":3,"file":"createConstructorTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createConstructorTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ConstructorTypeNode}: a `new (params) => T` constructor type.\n *\n * Any modifiers print first (for example `abstract`), then the `new ` keyword,\n * then optional type parameters as `<...>`, the parameter list, and finally\n * `=>` followed by the return type.\n *\n * Given no modifiers, one `x: number` parameter, and a `Foo` return type, the\n * printer renders:\n *\n * ```ts\n * new (x: number) => Foo\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers, if any.\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type.\n * @returns The created {@link ConstructorTypeNode}.\n */\nexport const createConstructorTypeNode = (modifiers, typeParameters, parameters, type) => make(\"ConstructorTypeNode\", { modifiers, typeParameters, parameters, type });\n//# sourceMappingURL=createConstructorTypeNode.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,yBAAyB,GAAG,CAAC,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,qBAAqB,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createExpressionWithTypeArguments.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExpressionWithTypeArguments = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create an {@link ExpressionWithTypeArguments}: an `Expr<TypeArgs>` form used
  * in heritage clauses such as `extends Base<T>`.
@@ -20,6 +19,7 @@ const make_1 = require("../internal/make");
  * @param typeArguments The generic type arguments, if any.
  * @returns The created {@link ExpressionWithTypeArguments}.
  */
-const createExpressionWithTypeArguments = (expression, typeArguments) => (0, make_1.make)("ExpressionWithTypeArguments", { expression, typeArguments });
-exports.createExpressionWithTypeArguments = createExpressionWithTypeArguments;
+const createExpressionWithTypeArguments = (expression, typeArguments) => make("ExpressionWithTypeArguments", { expression, typeArguments });
+
+export { createExpressionWithTypeArguments };
 //# sourceMappingURL=createExpressionWithTypeArguments.mjs.map

package/lib/factory/types/createExpressionWithTypeArguments.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createExpressionWithTypeArguments.mjs","sources":["createExpressionWithTypeArguments.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createExpressionWithTypeArguments = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link ExpressionWithTypeArguments}: an `Expr<TypeArgs>` form used\n * in heritage clauses such as `extends Base<T>`.\n *\n * The expression prints first, followed by the type arguments as `<...>` when\n * present. With no type arguments only the bare expression prints.\n *\n * Given a `Foo` expression and a single `string` type argument, the printer\n * renders:\n *\n * ```ts\n * Foo<string>;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The base expression.\n * @param typeArguments The generic type arguments, if any.\n * @returns The created {@link ExpressionWithTypeArguments}.\n */\nconst createExpressionWithTypeArguments = (expression, typeArguments) => (0, make_1.make)(\"ExpressionWithTypeArguments\", { expression, typeArguments });\nexports.createExpressionWithTypeArguments = createExpressionWithTypeArguments;\n//# sourceMappingURL=createExpressionWithTypeArguments.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,iCAAiC,GAAG,MAAM;AAClD,MAAM,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,iCAAiC,GAAG,CAAC,UAAU,EAAE,aAAa,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,6BAA6B,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC;AACvJ,OAAO,CAAC,iCAAiC,GAAG,iCAAiC"}
+{"version":3,"file":"createExpressionWithTypeArguments.mjs","sources":["../../../esm-tmp/factory/types/createExpressionWithTypeArguments.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ExpressionWithTypeArguments}: an `Expr<TypeArgs>` form used\n * in heritage clauses such as `extends Base<T>`.\n *\n * The expression prints first, followed by the type arguments as `<...>` when\n * present. With no type arguments only the bare expression prints.\n *\n * Given a `Foo` expression and a single `string` type argument, the printer\n * renders:\n *\n * ```ts\n * Foo<string>;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The base expression.\n * @param typeArguments The generic type arguments, if any.\n * @returns The created {@link ExpressionWithTypeArguments}.\n */\nexport const createExpressionWithTypeArguments = (expression, typeArguments) => make(\"ExpressionWithTypeArguments\", { expression, typeArguments });\n//# sourceMappingURL=createExpressionWithTypeArguments.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,iCAAiC,GAAG,CAAC,UAAU,EAAE,aAAa,KAAK,IAAI,CAAC,6BAA6B,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE;;;;"}

package/lib/factory/types/createFunctionTypeNode.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFunctionTypeNode = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link FunctionTypeNode}: a `(params) => T` function type.
  *
@@ -22,6 +21,7 @@ const make_1 = require("../internal/make");
  * @param type The return type.
  * @returns The created {@link FunctionTypeNode}.
  */
-const createFunctionTypeNode = (typeParameters, parameters, type) => (0, make_1.make)("FunctionTypeNode", { typeParameters, parameters, type });
-exports.createFunctionTypeNode = createFunctionTypeNode;
+const createFunctionTypeNode = (typeParameters, parameters, type) => make("FunctionTypeNode", { typeParameters, parameters, type });
+
+export { createFunctionTypeNode };
 //# sourceMappingURL=createFunctionTypeNode.mjs.map

package/lib/factory/types/createFunctionTypeNode.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createFunctionTypeNode.mjs","sources":["createFunctionTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createFunctionTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link FunctionTypeNode}: a `(params) => T` function type.\n *\n * Optional type parameters print first as `<...>`, then the parameter list,\n * then `=>` followed by the return type. In postfix and array positions the\n * surrounding printer wraps a function type in parentheses, since `() => T[]`\n * would otherwise read as an array of the return type.\n *\n * Given one `x: number` parameter and a `string` return type, the printer\n * renders:\n *\n * ```ts\n * (x: number) => string;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type.\n * @returns The created {@link FunctionTypeNode}.\n */\nconst createFunctionTypeNode = (typeParameters, parameters, type) => (0, make_1.make)(\"FunctionTypeNode\", { typeParameters, parameters, type });\nexports.createFunctionTypeNode = createFunctionTypeNode;\n//# sourceMappingURL=createFunctionTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,sBAAsB,GAAG,MAAM;AACvC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,sBAAsB,GAAG,CAAC,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AAC/I,OAAO,CAAC,sBAAsB,GAAG,sBAAsB"}
+{"version":3,"file":"createFunctionTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createFunctionTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link FunctionTypeNode}: a `(params) => T` function type.\n *\n * Optional type parameters print first as `<...>`, then the parameter list,\n * then `=>` followed by the return type. In postfix and array positions the\n * surrounding printer wraps a function type in parentheses, since `() => T[]`\n * would otherwise read as an array of the return type.\n *\n * Given one `x: number` parameter and a `string` return type, the printer\n * renders:\n *\n * ```ts\n * (x: number) => string;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type.\n * @returns The created {@link FunctionTypeNode}.\n */\nexport const createFunctionTypeNode = (typeParameters, parameters, type) => make(\"FunctionTypeNode\", { typeParameters, parameters, type });\n//# sourceMappingURL=createFunctionTypeNode.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,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,kBAAkB,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}