@ttsc/factory 0.15.7 → 0.15.9

package/lib/factory/statements/createForInStatement.mjs

@@ -1,29 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createForInStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link ForInStatement}: a `for (... in ...)` loop.
- *
- * The `initializer` is the binding that receives each enumerable key (a
- * declaration list such as `const key`, or an assignment target), `expression`
- * is the object being enumerated, and `statement` is the loop body. The loop
- * walks the object's enumerable property keys as strings.
- *
- * With an `initializer` of `const key`, an `expression` of `obj`, and a
- * `statement` block calling `use(key)`, the result is:
- *
- * ```ts
- * for (const key in obj) {
- *   use(key);
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param initializer The initializer.
- * @param expression The expression.
- * @param statement The statement.
- * @returns The created {@link ForInStatement}.
- */
-const createForInStatement = (initializer, expression, statement) => (0, make_1.make)("ForInStatement", { initializer, expression, statement });
-exports.createForInStatement = createForInStatement;
-//# sourceMappingURL=createForInStatement.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createForInStatement.mjs","sources":["createForInStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createForInStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ForInStatement}: a `for (... in ...)` loop.\n *\n * The `initializer` is the binding that receives each enumerable key (a\n * declaration list such as `const key`, or an assignment target), `expression`\n * is the object being enumerated, and `statement` is the loop body. The loop\n * walks the object's enumerable property keys as strings.\n *\n * With an `initializer` of `const key`, an `expression` of `obj`, and a\n * `statement` block calling `use(key)`, the result is:\n *\n * ```ts\n * for (const key in obj) {\n *   use(key);\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param initializer The initializer.\n * @param expression The expression.\n * @param statement The statement.\n * @returns The created {@link ForInStatement}.\n */\nconst createForInStatement = (initializer, expression, statement) => (0, make_1.make)(\"ForInStatement\", { initializer, expression, statement });\nexports.createForInStatement = createForInStatement;\n//# sourceMappingURL=createForInStatement.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;AACA;AACA,MAAM,oBAAoB,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,gBAAgB,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;AAC/I,OAAO,CAAC,oBAAoB,GAAG,oBAAoB"}

package/lib/factory/statements/createForOfStatement.mjs

@@ -1,39 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createForOfStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link ForOfStatement}: a `for (... of ...)` loop.
- *
- * The `initializer` is the binding that receives each element, `expression` is
- * the iterable being walked, and `statement` is the loop body. Pass an `await`
- * token as `awaitModifier` to emit `for await (...)` for async iterables, or
- * `undefined` for the plain form.
- *
- * With `awaitModifier` of `undefined`, an `initializer` of `const item`, an
- * `expression` of `list`, and a `statement` block calling `use(item)`, the
- * result is:
- *
- * ```ts
- * for (const item of list) {
- *   use(item);
- * }
- * ```
- *
- * Passing an `await` token as `awaitModifier` instead yields:
- *
- * ```ts
- * for await (const item of list) {
- *   use(item);
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param awaitModifier The awaitModifier.
- * @param initializer The initializer.
- * @param expression The expression.
- * @param statement The statement.
- * @returns The created {@link ForOfStatement}.
- */
-const createForOfStatement = (awaitModifier, initializer, expression, statement) => (0, make_1.make)("ForOfStatement", { awaitModifier, initializer, expression, statement });
-exports.createForOfStatement = createForOfStatement;
-//# sourceMappingURL=createForOfStatement.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createForOfStatement.mjs","sources":["createForOfStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createForOfStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ForOfStatement}: a `for (... of ...)` loop.\n *\n * The `initializer` is the binding that receives each element, `expression` is\n * the iterable being walked, and `statement` is the loop body. Pass an `await`\n * token as `awaitModifier` to emit `for await (...)` for async iterables, or\n * `undefined` for the plain form.\n *\n * With `awaitModifier` of `undefined`, an `initializer` of `const item`, an\n * `expression` of `list`, and a `statement` block calling `use(item)`, the\n * result is:\n *\n * ```ts\n * for (const item of list) {\n *   use(item);\n * }\n * ```\n *\n * Passing an `await` token as `awaitModifier` instead yields:\n *\n * ```ts\n * for await (const item of list) {\n *   use(item);\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param awaitModifier The awaitModifier.\n * @param initializer The initializer.\n * @param expression The expression.\n * @param statement The statement.\n * @returns The created {@link ForOfStatement}.\n */\nconst createForOfStatement = (awaitModifier, initializer, expression, statement) => (0, make_1.make)(\"ForOfStatement\", { awaitModifier, initializer, expression, statement });\nexports.createForOfStatement = createForOfStatement;\n//# sourceMappingURL=createForOfStatement.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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,oBAAoB,GAAG,CAAC,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,gBAAgB,EAAE,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;AAC7K,OAAO,CAAC,oBAAoB,GAAG,oBAAoB"}

package/lib/factory/statements/createForStatement.mjs

@@ -1,32 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createForStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link ForStatement}: a C-style `for (init; cond; inc) ...` loop.
- *
- * The `initializer` runs once before the loop (a declaration list or an
- * expression), `condition` is tested before each pass, and `incrementor` runs
- * after each pass; `statement` is the body. Each of the three header parts is
- * optional, so passing `undefined` for all of them yields the infinite `for (;
- * ; )` form.
- *
- * With an `initializer` of `let i = 0`, a `condition` of `i < 10`, an
- * `incrementor` of `i++`, and a `statement` block calling `use(i)`, the result
- * is:
- *
- * ```ts
- * for (let i = 0; i < 10; i++) {
- *   use(i);
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param initializer The initializer.
- * @param condition The condition.
- * @param incrementor The incrementor.
- * @param statement The statement.
- * @returns The created {@link ForStatement}.
- */
-const createForStatement = (initializer, condition, incrementor, statement) => (0, make_1.make)("ForStatement", { initializer, condition, incrementor, statement });
-exports.createForStatement = createForStatement;
-//# sourceMappingURL=createForStatement.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createForStatement.mjs","sources":["createForStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createForStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ForStatement}: a C-style `for (init; cond; inc) ...` loop.\n *\n * The `initializer` runs once before the loop (a declaration list or an\n * expression), `condition` is tested before each pass, and `incrementor` runs\n * after each pass; `statement` is the body. Each of the three header parts is\n * optional, so passing `undefined` for all of them yields the infinite `for (;\n * ; )` form.\n *\n * With an `initializer` of `let i = 0`, a `condition` of `i < 10`, an\n * `incrementor` of `i++`, and a `statement` block calling `use(i)`, the result\n * is:\n *\n * ```ts\n * for (let i = 0; i < 10; i++) {\n *   use(i);\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param initializer The initializer.\n * @param condition The condition.\n * @param incrementor The incrementor.\n * @param statement The statement.\n * @returns The created {@link ForStatement}.\n */\nconst createForStatement = (initializer, condition, incrementor, statement) => (0, make_1.make)(\"ForStatement\", { initializer, condition, incrementor, statement });\nexports.createForStatement = createForStatement;\n//# sourceMappingURL=createForStatement.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,MAAM,kBAAkB,GAAG,CAAC,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC;AACnK,OAAO,CAAC,kBAAkB,GAAG,kBAAkB"}

package/lib/factory/statements/createIfStatement.mjs

@@ -1,31 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIfStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create an {@link IfStatement}: an `if (...) ... else ...` statement.
- *
- * The `expression` is the condition, `thenStatement` runs when it holds, and
- * the optional `elseStatement` runs otherwise. Omit `elseStatement` for a bare
- * `if`; to build an `else if` chain, pass another `IfStatement` as
- * `elseStatement`.
- *
- * With an `expression` of `x`, a `thenStatement` block calling `a()`, and an
- * `elseStatement` block calling `b()`, the result is:
- *
- * ```ts
- * if (x) {
- *   a();
- * } else {
- *   b();
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param expression The expression.
- * @param thenStatement The statement run when the condition holds.
- * @param elseStatement The statement run otherwise, if any.
- * @returns The created {@link IfStatement}.
- */
-const createIfStatement = (expression, thenStatement, elseStatement) => (0, make_1.make)("IfStatement", { expression, thenStatement, elseStatement });
-exports.createIfStatement = createIfStatement;
-//# sourceMappingURL=createIfStatement.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createIfStatement.mjs","sources":["createIfStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createIfStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link IfStatement}: an `if (...) ... else ...` statement.\n *\n * The `expression` is the condition, `thenStatement` runs when it holds, and\n * the optional `elseStatement` runs otherwise. Omit `elseStatement` for a bare\n * `if`; to build an `else if` chain, pass another `IfStatement` as\n * `elseStatement`.\n *\n * With an `expression` of `x`, a `thenStatement` block calling `a()`, and an\n * `elseStatement` block calling `b()`, the result is:\n *\n * ```ts\n * if (x) {\n *   a();\n * } else {\n *   b();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @param thenStatement The statement run when the condition holds.\n * @param elseStatement The statement run otherwise, if any.\n * @returns The created {@link IfStatement}.\n */\nconst createIfStatement = (expression, thenStatement, elseStatement) => (0, make_1.make)(\"IfStatement\", { expression, thenStatement, elseStatement });\nexports.createIfStatement = createIfStatement;\n//# sourceMappingURL=createIfStatement.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,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,iBAAiB,GAAG,CAAC,UAAU,EAAE,aAAa,EAAE,aAAa,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,CAAC;AACrJ,OAAO,CAAC,iBAAiB,GAAG,iBAAiB"}

package/lib/factory/statements/createLabeledStatement.mjs

@@ -1,28 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLabeledStatement = void 0;
-const asName_1 = require("../internal/asName");
-const make_1 = require("../internal/make");
-/**
- * Create a {@link LabeledStatement}: a `label: ...` statement.
- *
- * The `label` names the statement so a `break` or `continue` can target it; a
- * string is wrapped into an identifier. The `statement` is the body the label
- * applies to, typically a loop.
- *
- * With a `label` of `outer` and a `statement` of an empty `for` loop that calls
- * `break outer`, the result is:
- *
- * ```ts
- * outer: for (;;) {
- *   break outer;
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param label The label.
- * @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;
-//# sourceMappingURL=createLabeledStatement.mjs.map

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

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

package/lib/factory/statements/createNotEmittedStatement.mjs

@@ -1,20 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNotEmittedStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link NotEmittedStatement}: a placeholder that prints nothing.
- *
- * This is a synthetic statement that occupies a slot in the tree but produces
- * no output. The optional `original` records the node this placeholder stands
- * in for, so comments and source positions attached to it can still be carried
- * through.
- *
- * With any `original` (or none), the printed result is empty:
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @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;
-//# sourceMappingURL=createNotEmittedStatement.mjs.map

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

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

package/lib/factory/statements/createReturnStatement.mjs

@@ -1,28 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createReturnStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link ReturnStatement}: a `return ...;` statement.
- *
- * The optional `expression` is the value handed back to the caller. Omit it for
- * a bare `return;` that yields `undefined`.
- *
- * With no expression the result is:
- *
- * ```ts
- * return;
- * ```
- *
- * With an `expression` of `value` the result is:
- *
- * ```ts
- * return value;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param expression The expression.
- * @returns The created {@link ReturnStatement}.
- */
-const createReturnStatement = (expression) => (0, make_1.make)("ReturnStatement", { expression });
-exports.createReturnStatement = createReturnStatement;
-//# sourceMappingURL=createReturnStatement.mjs.map

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

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

package/lib/factory/statements/createSwitchStatement.mjs

@@ -1,31 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSwitchStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link SwitchStatement}: a `switch (...) { ... }` statement.
- *
- * The `expression` is the subject compared against each arm, and `caseBlock` is
- * the braced body of `case` and `default` clauses, built with
- * {@link createCaseBlock}.
- *
- * With `expression` of `x` and a `caseBlock` holding a `case 1:` arm (calling
- * `a()` then `break`) and a `default:` arm (calling `b()`), the result is:
- *
- * ```ts
- * switch (x) {
- *   case 1:
- *     a();
- *     break;
- *   default:
- *     b();
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param expression The expression.
- * @param caseBlock The caseBlock.
- * @returns The created {@link SwitchStatement}.
- */
-const createSwitchStatement = (expression, caseBlock) => (0, make_1.make)("SwitchStatement", { expression, caseBlock });
-exports.createSwitchStatement = createSwitchStatement;
-//# sourceMappingURL=createSwitchStatement.mjs.map

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

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

package/lib/factory/statements/createThrowStatement.mjs

@@ -1,22 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createThrowStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link ThrowStatement}: a `throw ...;` statement.
- *
- * The `expression` is the value raised, commonly a freshly constructed error.
- * Unlike `return`, the expression is required.
- *
- * With an `expression` of `new Error("oops")`, the result is:
- *
- * ```ts
- * throw new Error("oops");
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param expression The expression.
- * @returns The created {@link ThrowStatement}.
- */
-const createThrowStatement = (expression) => (0, make_1.make)("ThrowStatement", { expression });
-exports.createThrowStatement = createThrowStatement;
-//# sourceMappingURL=createThrowStatement.mjs.map

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

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

package/lib/factory/statements/createTryStatement.mjs

@@ -1,34 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTryStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link TryStatement}: a `try { ... } catch { ... } finally { ... }`
- * statement.
- *
- * The `tryBlock` is the guarded body. The `catchClause` and `finallyBlock` are
- * both optional, but at least one must be present for valid TypeScript: pass
- * `undefined` for `catchClause` to emit a `try`/`finally`, or `undefined` for
- * `finallyBlock` to emit a `try`/`catch`.
- *
- * With a `tryBlock` calling `risky()`, a `catchClause` binding `e` and calling
- * `handle(e)`, and a `finallyBlock` calling `cleanup()`, the result is:
- *
- * ```ts
- * try {
- *   risky();
- * } catch (e) {
- *   handle(e);
- * } finally {
- *   cleanup();
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param tryBlock The tryBlock.
- * @param catchClause The catchClause.
- * @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;
-//# sourceMappingURL=createTryStatement.mjs.map

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

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

package/lib/factory/statements/createVariableDeclaration.mjs

@@ -1,38 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVariableDeclaration = void 0;
-const make_1 = require("../internal/make");
-const createIdentifier_1 = require("../names/createIdentifier");
-/**
- * Create a {@link VariableDeclaration}: one `name = value` binding.
- *
- * The `name` is the binding target; a string becomes an identifier, while a
- * {@link BindingName} allows array or object destructuring such as `[a, b]`. The
- * `exclamationToken` adds the definite-assignment `!`, `type` adds a `: T`
- * annotation, and `initializer` adds `= value`. Each of those three is
- * optional.
- *
- * This node is a single declarator, not a full statement: it carries no `const`
- * / `let` / `var` keyword (that lives on the enclosing
- * {@link VariableDeclarationList}) and no trailing semicolon. With a `name` of
- * `x` and an `initializer` of `1`, it prints as:
- *
- * ```ts
- * x = 1;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param name The name; a {@link BindingName} allows array / object
- *   destructuring (e.g. `const [a, b] = ...`).
- * @param exclamationToken The definite-assignment marker (`!`), if any.
- * @param type The type.
- * @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,
-    exclamationToken,
-    type,
-    initializer,
-});
-exports.createVariableDeclaration = createVariableDeclaration;
-//# sourceMappingURL=createVariableDeclaration.mjs.map

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

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

package/lib/factory/statements/createVariableDeclarationList.mjs

@@ -1,26 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVariableDeclarationList = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link VariableDeclarationList}: the `const x = 1` group.
- *
- * The `declarations` are the comma-separated declarators, and `flags` chooses
- * the keyword the printer emits: `const`, `let`, or plain `var` when no flag is
- * set. This is the keyword-bearing part shared by a {@link VariableStatement}
- * and by `for` loop headers.
- *
- * The list carries no trailing semicolon on its own. With a single declaration
- * of `x = 1` and the `const` flag, it prints as:
- *
- * ```ts
- * const x = 1;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param declarations The declarations.
- * @param flags The declaration flags (`const` / `let` / `var`).
- * @returns The created {@link VariableDeclarationList}.
- */
-const createVariableDeclarationList = (declarations, flags = "" /* NodeFlags.None */) => (0, make_1.make)("VariableDeclarationList", { declarations, flags });
-exports.createVariableDeclarationList = createVariableDeclarationList;
-//# sourceMappingURL=createVariableDeclarationList.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createVariableDeclarationList.mjs","sources":["createVariableDeclarationList.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createVariableDeclarationList = void 0;\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 = \"\" /* 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,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,EAAE,0BAA0B,IAAI,MAAM,CAAC,IAAI,EAAE,yBAAyB,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;AAC7J,OAAO,CAAC,6BAA6B,GAAG,6BAA6B"}

package/lib/factory/statements/createVariableStatement.mjs

@@ -1,33 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVariableStatement = void 0;
-const make_1 = require("../internal/make");
-const createVariableDeclarationList_1 = require("./createVariableDeclarationList");
-/**
- * Create a {@link VariableStatement}: a full `const x = 1;` statement.
- *
- * The optional `modifiers` are leading keywords such as `export` or `declare`.
- * The `declarationList` carries the keyword and declarators; pass a
- * {@link VariableDeclarationList} directly, or pass a plain array of
- * declarations and it is wrapped into a list for you (defaulting to `var`, so
- * build the list yourself when you need `const` or `let`).
- *
- * This is the statement-level wrapper that adds the trailing semicolon. With no
- * modifiers and a `const` declaration list of `x = 1`, the result is:
- *
- * ```ts
- * const x = 1;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param modifiers The leading modifiers and decorators, if any.
- * @param declarationList The declaration list.
- * @returns The created {@link VariableStatement}.
- */
-const createVariableStatement = (modifiers, declarationList) => (0, make_1.make)("VariableStatement", {
-    modifiers,
-    declarationList: Array.isArray(declarationList)
-        ? (0, createVariableDeclarationList_1.createVariableDeclarationList)(declarationList)
-        : declarationList,
-});
-exports.createVariableStatement = createVariableStatement;
-//# sourceMappingURL=createVariableStatement.mjs.map

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

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

package/lib/factory/statements/createWhileStatement.mjs

@@ -1,27 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWhileStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link WhileStatement}: a `while (...) ...` loop.
- *
- * The `expression` is the condition tested before each pass and `statement` is
- * the loop body. The body runs zero or more times, only while the condition
- * holds.
- *
- * With an `expression` of `cond` and a `statement` block calling `a()`, the
- * result is:
- *
- * ```ts
- * while (cond) {
- *   a();
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param expression The expression.
- * @param statement The statement.
- * @returns The created {@link WhileStatement}.
- */
-const createWhileStatement = (expression, statement) => (0, make_1.make)("WhileStatement", { expression, statement });
-exports.createWhileStatement = createWhileStatement;
-//# sourceMappingURL=createWhileStatement.mjs.map

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

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

package/lib/factory/statements/createWithStatement.mjs

@@ -1,27 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWithStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link WithStatement}: a `with (...) ...` statement.
- *
- * The `expression` supplies the object whose properties join the scope of
- * `statement`, the body. `with` is disallowed in strict mode and in ES modules,
- * so this exists mainly for completeness and faithful round-tripping.
- *
- * With an `expression` of `obj` and a `statement` block calling `a()`, the
- * result is:
- *
- * ```ts
- * with (obj) {
- *   a();
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param expression The expression.
- * @param statement The statement.
- * @returns The created {@link WithStatement}.
- */
-const createWithStatement = (expression, statement) => (0, make_1.make)("WithStatement", { expression, statement });
-exports.createWithStatement = createWithStatement;
-//# sourceMappingURL=createWithStatement.mjs.map

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

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

package/lib/factory/types/createArrayTypeNode.mjs

@@ -1,25 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createArrayTypeNode = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create an {@link ArrayTypeNode}: a `T[]` postfix array type.
- *
- * The element type is emitted in postfix-operand position, so a
- * lower-precedence form that would otherwise re-associate gets wrapped in
- * parentheses first. A union, intersection, function, constructor, conditional,
- * infer, or type-operator element prints as `(...)[]`; anything else prints
- * bare.
- *
- * Given a `string` element, the printer renders:
- *
- * ```ts
- * string[]
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param elementType The element type.
- * @returns The created {@link ArrayTypeNode}.
- */
-const createArrayTypeNode = (elementType) => (0, make_1.make)("ArrayTypeNode", { elementType });
-exports.createArrayTypeNode = createArrayTypeNode;
-//# sourceMappingURL=createArrayTypeNode.mjs.map

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

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

package/lib/factory/types/createCallSignature.mjs

@@ -1,26 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCallSignature = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link CallSignature}: a `(params): ReturnType` call signature for an
- * interface or type literal.
- *
- * Optional type parameters print first as `<...>`, then the parameter list,
- * then the return type as `: Type` when present.
- *
- * Given one `x: number` parameter and a `string` return type, the printer
- * renders:
- *
- * ```ts
- * (x: number): string
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param typeParameters The generic type parameters, if any.
- * @param parameters The parameters.
- * @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;
-//# sourceMappingURL=createCallSignature.mjs.map

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

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