@ttsc/factory 0.15.8 → 0.15.9

package/lib/factory/names/createSuper.mjs

@@ -1,22 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSuper = void 0;
-const syntax_1 = require("../../syntax");
-const createToken_1 = require("./createToken");
-/**
- * Create the `super` keyword as a {@link Token}.
- *
- * This takes no arguments and wraps the `SuperKeyword` syntax kind. The printer
- * emits the keyword as the `super` expression.
- *
- * This prints:
- *
- * ```ts
- * super
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @returns The created node.
- */
-const createSuper = () => (0, createToken_1.createToken)(syntax_1.SyntaxKind.SuperKeyword);
-exports.createSuper = createSuper;
-//# sourceMappingURL=createSuper.mjs.map

package/lib/factory/names/createSuper.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createSuper.mjs","sources":["createSuper.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createSuper = void 0;\nconst syntax_1 = require(\"../../syntax\");\nconst createToken_1 = require(\"./createToken\");\n/**\n * Create the `super` keyword as a {@link Token}.\n *\n * This takes no arguments and wraps the `SuperKeyword` syntax kind. The printer\n * emits the keyword as the `super` expression.\n *\n * This prints:\n *\n * ```ts\n * super\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created node.\n */\nconst createSuper = () => (0, createToken_1.createToken)(syntax_1.SyntaxKind.SuperKeyword);\nexports.createSuper = createSuper;\n//# sourceMappingURL=createSuper.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,WAAW,GAAG,MAAM;AAC5B,MAAM,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC;AACxC,MAAM,aAAa,GAAG,OAAO,CAAC,eAAe,CAAC;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,WAAW,GAAG,MAAM,IAAI,aAAa,CAAC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,YAAY,CAAC;AAC1F,OAAO,CAAC,WAAW,GAAG,WAAW"}

package/lib/factory/names/createTempVariable.mjs

@@ -1,33 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTempVariable = void 0;
-const createIdentifier_1 = require("./createIdentifier");
-/**
- * Create a temporary variable name as a plain {@link Identifier}.
- *
- * The legacy compiler uses a stateful name generator that allocates a fresh,
- * collision-free identifier and records it via `recordTempVariable`. This
- * package is stateless, so this is a simplified placeholder: it does not track
- * or guarantee uniqueness, it just returns an identifier built from a fixed
- * `_temp` base with the optional `prefix` and `suffix` wrapped around it.
- *
- * The `recordTempVariable` and `reservedInNestedScopes` parameters belong to
- * the stateful generator and are accepted for signature parity but ignored. Two
- * calls with the same arguments produce the same name, so the caller must keep
- * names distinct.
- *
- * With no arguments, this prints:
- *
- * ```ts
- * _temp;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param _recordTempVariable Ignored; kept for signature parity.
- * @param _reservedInNestedScopes Ignored; kept for signature parity.
- * @param prefix An optional name prefix.
- * @param suffix An optional name suffix.
- * @returns The created {@link Identifier}.
- */
-const createTempVariable = (_recordTempVariable, _reservedInNestedScopes, prefix, suffix) => (0, createIdentifier_1.createIdentifier)(`${prefix ?? ""}_temp${suffix ?? ""}`);
-exports.createTempVariable = createTempVariable;
-//# sourceMappingURL=createTempVariable.mjs.map

package/lib/factory/names/createTempVariable.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createTempVariable.mjs","sources":["createTempVariable.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createTempVariable = void 0;\nconst createIdentifier_1 = require(\"./createIdentifier\");\n/**\n * Create a temporary variable name as a plain {@link Identifier}.\n *\n * The legacy compiler uses a stateful name generator that allocates a fresh,\n * collision-free identifier and records it via `recordTempVariable`. This\n * package is stateless, so this is a simplified placeholder: it does not track\n * or guarantee uniqueness, it just returns an identifier built from a fixed\n * `_temp` base with the optional `prefix` and `suffix` wrapped around it.\n *\n * The `recordTempVariable` and `reservedInNestedScopes` parameters belong to\n * the stateful generator and are accepted for signature parity but ignored. Two\n * calls with the same arguments produce the same name, so the caller must keep\n * names distinct.\n *\n * With no arguments, this prints:\n *\n * ```ts\n * _temp;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param _recordTempVariable Ignored; kept for signature parity.\n * @param _reservedInNestedScopes Ignored; kept for signature parity.\n * @param prefix An optional name prefix.\n * @param suffix An optional name suffix.\n * @returns The created {@link Identifier}.\n */\nconst createTempVariable = (_recordTempVariable, _reservedInNestedScopes, prefix, suffix) => (0, createIdentifier_1.createIdentifier)(`${prefix ?? \"\"}_temp${suffix ?? \"\"}`);\nexports.createTempVariable = createTempVariable;\n//# sourceMappingURL=createTempVariable.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,kBAAkB,GAAG,OAAO,CAAC,oBAAoB,CAAC;AACxD;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,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,kBAAkB,CAAC,gBAAgB,EAAE,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC;AAC5K,OAAO,CAAC,kBAAkB,GAAG,kBAAkB"}

package/lib/factory/names/createThis.mjs

@@ -1,22 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createThis = void 0;
-const syntax_1 = require("../../syntax");
-const createToken_1 = require("./createToken");
-/**
- * Create the `this` keyword as a {@link Token}.
- *
- * This takes no arguments and wraps the `ThisKeyword` syntax kind. The printer
- * emits the keyword as the `this` expression.
- *
- * This prints:
- *
- * ```ts
- * this;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @returns The created {@link Token}.
- */
-const createThis = () => (0, createToken_1.createToken)(syntax_1.SyntaxKind.ThisKeyword);
-exports.createThis = createThis;
-//# sourceMappingURL=createThis.mjs.map

package/lib/factory/names/createThis.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createThis.mjs","sources":["createThis.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createThis = void 0;\nconst syntax_1 = require(\"../../syntax\");\nconst createToken_1 = require(\"./createToken\");\n/**\n * Create the `this` keyword as a {@link Token}.\n *\n * This takes no arguments and wraps the `ThisKeyword` syntax kind. The printer\n * emits the keyword as the `this` expression.\n *\n * This prints:\n *\n * ```ts\n * this;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link Token}.\n */\nconst createThis = () => (0, createToken_1.createToken)(syntax_1.SyntaxKind.ThisKeyword);\nexports.createThis = createThis;\n//# sourceMappingURL=createThis.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,UAAU,GAAG,MAAM;AAC3B,MAAM,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC;AACxC,MAAM,aAAa,GAAG,OAAO,CAAC,eAAe,CAAC;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,UAAU,GAAG,MAAM,IAAI,aAAa,CAAC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,WAAW,CAAC;AACxF,OAAO,CAAC,UAAU,GAAG,UAAU"}

package/lib/factory/names/createToken.mjs

@@ -1,24 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createToken = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link Token}: a node that wraps a single {@link SyntaxKind}.
- *
- * The `token` is the syntax kind to wrap, such as a punctuation or keyword
- * kind. The printer emits the source spelling tied to that kind, so a question
- * mark token prints as `?` and a keyword token prints as its keyword. The
- * generic `TKind` flows through to the result type for type-safe consumers.
- *
- * With `token` of the question-mark kind, this prints:
- *
- * ```ts
- * ?
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param token The token.
- * @returns The created {@link Token}.
- */
-const createToken = (token) => (0, make_1.make)("Token", { token });
-exports.createToken = createToken;
-//# sourceMappingURL=createToken.mjs.map

package/lib/factory/names/createToken.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createToken.mjs","sources":["createToken.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createToken = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link Token}: a node that wraps a single {@link SyntaxKind}.\n *\n * The `token` is the syntax kind to wrap, such as a punctuation or keyword\n * kind. The printer emits the source spelling tied to that kind, so a question\n * mark token prints as `?` and a keyword token prints as its keyword. The\n * generic `TKind` flows through to the result type for type-safe consumers.\n *\n * With `token` of the question-mark kind, this prints:\n *\n * ```ts\n * ?\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param token The token.\n * @returns The created {@link Token}.\n */\nconst createToken = (token) => (0, make_1.make)(\"Token\", { token });\nexports.createToken = createToken;\n//# sourceMappingURL=createToken.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,WAAW,GAAG,MAAM;AAC5B,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,WAAW,GAAG,CAAC,KAAK,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC;AACnE,OAAO,CAAC,WAAW,GAAG,WAAW"}

package/lib/factory/names/createTrue.mjs

@@ -1,22 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTrue = void 0;
-const syntax_1 = require("../../syntax");
-const createToken_1 = require("./createToken");
-/**
- * Create the `true` keyword as a {@link Token}.
- *
- * This takes no arguments and wraps the `TrueKeyword` syntax kind. The printer
- * emits the keyword as the boolean literal `true`.
- *
- * This prints:
- *
- * ```ts
- * true;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @returns The created {@link Token}.
- */
-const createTrue = () => (0, createToken_1.createToken)(syntax_1.SyntaxKind.TrueKeyword);
-exports.createTrue = createTrue;
-//# sourceMappingURL=createTrue.mjs.map

package/lib/factory/names/createTrue.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createTrue.mjs","sources":["createTrue.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createTrue = void 0;\nconst syntax_1 = require(\"../../syntax\");\nconst createToken_1 = require(\"./createToken\");\n/**\n * Create the `true` keyword as a {@link Token}.\n *\n * This takes no arguments and wraps the `TrueKeyword` syntax kind. The printer\n * emits the keyword as the boolean literal `true`.\n *\n * This prints:\n *\n * ```ts\n * true;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link Token}.\n */\nconst createTrue = () => (0, createToken_1.createToken)(syntax_1.SyntaxKind.TrueKeyword);\nexports.createTrue = createTrue;\n//# sourceMappingURL=createTrue.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,UAAU,GAAG,MAAM;AAC3B,MAAM,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC;AACxC,MAAM,aAAa,GAAG,OAAO,CAAC,eAAe,CAAC;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,UAAU,GAAG,MAAM,IAAI,aAAa,CAAC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,WAAW,CAAC;AACxF,OAAO,CAAC,UAAU,GAAG,UAAU"}

package/lib/factory/names/createUniqueName.mjs

@@ -1,32 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createUniqueName = void 0;
-const createIdentifier_1 = require("./createIdentifier");
-/**
- * Create a unique identifier name as a plain {@link Identifier}.
- *
- * The legacy compiler uses a stateful name generator that guarantees the
- * returned identifier is unique within its scope. This package is stateless, so
- * this is a simplified placeholder: it does not guarantee uniqueness, it just
- * returns the given `text` with the optional `prefix` and `suffix` wrapped
- * around it.
- *
- * The `flags` parameter belongs to the stateful generator and is accepted for
- * signature parity but ignored. Two calls with the same arguments produce the
- * same name, so the caller is responsible for avoiding collisions.
- *
- * With `text` of `base` and no prefix or suffix, this prints:
- *
- * ```ts
- * base;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param text The base name text.
- * @param _flags Ignored; kept for signature parity.
- * @param prefix An optional name prefix.
- * @param suffix An optional name suffix.
- * @returns The created {@link Identifier}.
- */
-const createUniqueName = (text, _flags, prefix, suffix) => (0, createIdentifier_1.createIdentifier)(`${prefix ?? ""}${text}${suffix ?? ""}`);
-exports.createUniqueName = createUniqueName;
-//# sourceMappingURL=createUniqueName.mjs.map

package/lib/factory/names/createUniqueName.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createUniqueName.mjs","sources":["createUniqueName.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createUniqueName = void 0;\nconst createIdentifier_1 = require(\"./createIdentifier\");\n/**\n * Create a unique identifier name as a plain {@link Identifier}.\n *\n * The legacy compiler uses a stateful name generator that guarantees the\n * returned identifier is unique within its scope. This package is stateless, so\n * this is a simplified placeholder: it does not guarantee uniqueness, it just\n * returns the given `text` with the optional `prefix` and `suffix` wrapped\n * around it.\n *\n * The `flags` parameter belongs to the stateful generator and is accepted for\n * signature parity but ignored. Two calls with the same arguments produce the\n * same name, so the caller is responsible for avoiding collisions.\n *\n * With `text` of `base` and no prefix or suffix, this prints:\n *\n * ```ts\n * base;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The base name text.\n * @param _flags Ignored; kept for signature parity.\n * @param prefix An optional name prefix.\n * @param suffix An optional name suffix.\n * @returns The created {@link Identifier}.\n */\nconst createUniqueName = (text, _flags, prefix, suffix) => (0, createIdentifier_1.createIdentifier)(`${prefix ?? \"\"}${text}${suffix ?? \"\"}`);\nexports.createUniqueName = createUniqueName;\n//# sourceMappingURL=createUniqueName.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,gBAAgB,GAAG,MAAM;AACjC,MAAM,kBAAkB,GAAG,OAAO,CAAC,oBAAoB,CAAC;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,kBAAkB,CAAC,gBAAgB,EAAE,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC;AAC5I,OAAO,CAAC,gBAAgB,GAAG,gBAAgB"}

package/lib/factory/names/createUniquePrivateName.mjs

@@ -1,29 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createUniquePrivateName = void 0;
-const createPrivateIdentifier_1 = require("./createPrivateIdentifier");
-/**
- * Create a unique private identifier name as a plain {@link PrivateIdentifier}.
- *
- * The legacy compiler uses a stateful name generator that guarantees the
- * returned private identifier is unique within its scope. This package is
- * stateless, so this is a simplified placeholder: it does not guarantee
- * uniqueness, it assembles a name from the optional `prefix`, the `text` (or
- * the fallback `_unique` when omitted), and the optional `suffix`, then
- * delegates to {@link createPrivateIdentifier}. Any leading `#` on `text` is
- * stripped first so the delegate adds exactly one.
- *
- * With no arguments, the fallback applies and this prints:
- *
- * ```ts
- * #_unique;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param text The base name text, if any.
- * @param prefix An optional name prefix.
- * @param suffix An optional name suffix.
- * @returns The created {@link PrivateIdentifier}.
- */
-const createUniquePrivateName = (text, prefix, suffix) => (0, createPrivateIdentifier_1.createPrivateIdentifier)(`#${prefix ?? ""}${text ? text.replace(/^#/, "") : "_unique"}${suffix ?? ""}`);
-exports.createUniquePrivateName = createUniquePrivateName;
-//# sourceMappingURL=createUniquePrivateName.mjs.map

package/lib/factory/names/createUniquePrivateName.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createUniquePrivateName.mjs","sources":["createUniquePrivateName.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createUniquePrivateName = void 0;\nconst createPrivateIdentifier_1 = require(\"./createPrivateIdentifier\");\n/**\n * Create a unique private identifier name as a plain {@link PrivateIdentifier}.\n *\n * The legacy compiler uses a stateful name generator that guarantees the\n * returned private identifier is unique within its scope. This package is\n * stateless, so this is a simplified placeholder: it does not guarantee\n * uniqueness, it assembles a name from the optional `prefix`, the `text` (or\n * the fallback `_unique` when omitted), and the optional `suffix`, then\n * delegates to {@link createPrivateIdentifier}. Any leading `#` on `text` is\n * stripped first so the delegate adds exactly one.\n *\n * With no arguments, the fallback applies and this prints:\n *\n * ```ts\n * #_unique;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The base name text, if any.\n * @param prefix An optional name prefix.\n * @param suffix An optional name suffix.\n * @returns The created {@link PrivateIdentifier}.\n */\nconst createUniquePrivateName = (text, prefix, suffix) => (0, createPrivateIdentifier_1.createPrivateIdentifier)(`#${prefix ?? \"\"}${text ? text.replace(/^#/, \"\") : \"_unique\"}${suffix ?? \"\"}`);\nexports.createUniquePrivateName = createUniquePrivateName;\n//# sourceMappingURL=createUniquePrivateName.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,yBAAyB,GAAG,OAAO,CAAC,2BAA2B,CAAC;AACtE;AACA;AACA;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,IAAI,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,yBAAyB,CAAC,uBAAuB,EAAE,CAAC,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC;AAC/L,OAAO,CAAC,uBAAuB,GAAG,uBAAuB"}

package/lib/factory/statements/createBlock.mjs

@@ -1,29 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBlock = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link Block}: a `{ ... }` statement block.
- *
- * The `statements` become the body, in order. The `multiLine` flag controls how
- * the printer lays the block out: when `true` (the default here), each
- * statement sits on its own indented line between braces; when `false`, the
- * printer keeps the body compact on a single line.
- *
- * With `statements` printing `a()` and `b()` and `multiLine` left at its
- * default, the result is:
- *
- * ```ts
- * {
- *   a();
- *   b();
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param statements The statements.
- * @param multiLine When `true`, print one entry per line.
- * @returns The created {@link Block}.
- */
-const createBlock = (statements, multiLine) => (0, make_1.make)("Block", { statements, multiLine: multiLine ?? true });
-exports.createBlock = createBlock;
-//# sourceMappingURL=createBlock.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createBlock.mjs","sources":["createBlock.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createBlock = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link Block}: a `{ ... }` statement block.\n *\n * The `statements` become the body, in order. The `multiLine` flag controls how\n * the printer lays the block out: when `true` (the default here), each\n * statement sits on its own indented line between braces; when `false`, the\n * printer keeps the body compact on a single line.\n *\n * With `statements` printing `a()` and `b()` and `multiLine` left at its\n * default, the result is:\n *\n * ```ts\n * {\n *   a();\n *   b();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param statements The statements.\n * @param multiLine When `true`, print one entry per line.\n * @returns The created {@link Block}.\n */\nconst createBlock = (statements, multiLine) => (0, make_1.make)(\"Block\", { statements, multiLine: multiLine ?? true });\nexports.createBlock = createBlock;\n//# sourceMappingURL=createBlock.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,WAAW,GAAG,MAAM;AAC5B,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,WAAW,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,IAAI,IAAI,EAAE,CAAC;AACtH,OAAO,CAAC,WAAW,GAAG,WAAW"}

package/lib/factory/statements/createBreakStatement.mjs

@@ -1,31 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBreakStatement = void 0;
-const asName_1 = require("../internal/asName");
-const make_1 = require("../internal/make");
-/**
- * Create a {@link BreakStatement}: a `break;` statement.
- *
- * The optional `label` names an enclosing labeled statement to break out of. A
- * string is wrapped into an identifier; pass nothing for a plain `break`.
- *
- * With no label the result is:
- *
- * ```ts
- * break;
- * ```
- *
- * With `label` of `outer` the result is:
- *
- * ```ts
- * break outer;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param label The label.
- * @returns The created {@link BreakStatement}.
- */
-const createBreakStatement = (label) => (0, make_1.make)("BreakStatement", {
-    label: label === undefined ? undefined : (0, asName_1.asName)(label),
-});
-exports.createBreakStatement = createBreakStatement;
-//# sourceMappingURL=createBreakStatement.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createBreakStatement.mjs","sources":["createBreakStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createBreakStatement = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link BreakStatement}: a `break;` statement.\n *\n * The optional `label` names an enclosing labeled statement to break out of. A\n * string is wrapped into an identifier; pass nothing for a plain `break`.\n *\n * With no label the result is:\n *\n * ```ts\n * break;\n * ```\n *\n * With `label` of `outer` the result is:\n *\n * ```ts\n * break outer;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param label The label.\n * @returns The created {@link BreakStatement}.\n */\nconst createBreakStatement = (label) => (0, make_1.make)(\"BreakStatement\", {\n    label: label === undefined ? undefined : (0, asName_1.asName)(label),\n});\nexports.createBreakStatement = createBreakStatement;\n//# sourceMappingURL=createBreakStatement.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,oBAAoB,GAAG,MAAM;AACrC,MAAM,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC;AAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,oBAAoB,GAAG,CAAC,KAAK,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,gBAAgB,EAAE;AAC3E,IAAI,KAAK,EAAE,KAAK,KAAK,SAAS,GAAG,SAAS,GAAG,IAAI,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;AACxE,CAAC,CAAC;AACF,OAAO,CAAC,oBAAoB,GAAG,oBAAoB"}

package/lib/factory/statements/createCaseBlock.mjs

@@ -1,30 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCaseBlock = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link CaseBlock}: the braced body of a switch statement.
- *
- * The `clauses` are the `case` and `default` arms, printed in the given order
- * between braces. This is the body you hand to {@link createSwitchStatement}; on
- * its own it carries no switch subject.
- *
- * With `clauses` of a `case 1:` arm (calling `a()` then `break`) and a
- * `default:` arm (calling `b()`), the result is:
- *
- * ```ts
- * {
- *   case 1:
- *     a();
- *     break;
- *   default:
- *     b();
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param clauses The clauses.
- * @returns The created {@link CaseBlock}.
- */
-const createCaseBlock = (clauses) => (0, make_1.make)("CaseBlock", { clauses });
-exports.createCaseBlock = createCaseBlock;
-//# sourceMappingURL=createCaseBlock.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createCaseBlock.mjs","sources":["createCaseBlock.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createCaseBlock = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link CaseBlock}: the braced body of a switch statement.\n *\n * The `clauses` are the `case` and `default` arms, printed in the given order\n * between braces. This is the body you hand to {@link createSwitchStatement}; on\n * its own it carries no switch subject.\n *\n * With `clauses` of a `case 1:` arm (calling `a()` then `break`) and a\n * `default:` arm (calling `b()`), the result is:\n *\n * ```ts\n * {\n *   case 1:\n *     a();\n *     break;\n *   default:\n *     b();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param clauses The clauses.\n * @returns The created {@link CaseBlock}.\n */\nconst createCaseBlock = (clauses) => (0, make_1.make)(\"CaseBlock\", { clauses });\nexports.createCaseBlock = createCaseBlock;\n//# sourceMappingURL=createCaseBlock.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,eAAe,GAAG,MAAM;AAChC,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,MAAM,eAAe,GAAG,CAAC,OAAO,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,OAAO,EAAE,CAAC;AAC/E,OAAO,CAAC,eAAe,GAAG,eAAe"}

package/lib/factory/statements/createCaseClause.mjs

@@ -1,28 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCaseClause = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link CaseClause}: one `case ...:` arm of a switch.
- *
- * The `expression` is the value matched against the switch subject, and
- * `statements` is the body that runs on a match. Fall-through is the default,
- * so include an explicit `break` in `statements` when you want the arm to
- * stop.
- *
- * With `expression` of `1` and `statements` of `a()` followed by a `break`, the
- * result is:
- *
- * ```ts
- * case 1:
- *   a();
- *   break;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param expression The expression.
- * @param statements The statements.
- * @returns The created {@link CaseClause}.
- */
-const createCaseClause = (expression, statements) => (0, make_1.make)("CaseClause", { expression, statements });
-exports.createCaseClause = createCaseClause;
-//# sourceMappingURL=createCaseClause.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createCaseClause.mjs","sources":["createCaseClause.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createCaseClause = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link CaseClause}: one `case ...:` arm of a switch.\n *\n * The `expression` is the value matched against the switch subject, and\n * `statements` is the body that runs on a match. Fall-through is the default,\n * so include an explicit `break` in `statements` when you want the arm to\n * stop.\n *\n * With `expression` of `1` and `statements` of `a()` followed by a `break`, the\n * result is:\n *\n * ```ts\n * case 1:\n *   a();\n *   break;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @param statements The statements.\n * @returns The created {@link CaseClause}.\n */\nconst createCaseClause = (expression, statements) => (0, make_1.make)(\"CaseClause\", { expression, statements });\nexports.createCaseClause = createCaseClause;\n//# sourceMappingURL=createCaseClause.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,gBAAgB,GAAG,MAAM;AACjC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,gBAAgB,GAAG,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC;AAC/G,OAAO,CAAC,gBAAgB,GAAG,gBAAgB"}

package/lib/factory/statements/createCatchClause.mjs

@@ -1,35 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCatchClause = void 0;
-const make_1 = require("../internal/make");
-const createVariableDeclaration_1 = require("./createVariableDeclaration");
-/**
- * Create a {@link CatchClause}: the `catch (...) { ... }` arm of a try.
- *
- * The `variableDeclaration` binds the caught value. Pass a string for the
- * common `catch (e)` case and it is turned into a bare binding; pass a full
- * {@link VariableDeclaration} when you need a type or destructuring pattern;
- * pass `undefined` for the binding-less `catch { ... }` form. The `block` is
- * the handler body.
- *
- * With `variableDeclaration` of `e` and a `block` calling `handle(e)`, the
- * result is:
- *
- * ```ts
- * catch (e) {
- *   handle(e);
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param variableDeclaration The variableDeclaration.
- * @param block The block.
- * @returns The created {@link CatchClause}.
- */
-const createCatchClause = (variableDeclaration, block) => (0, make_1.make)("CatchClause", {
-    variableDeclaration: typeof variableDeclaration === "string"
-        ? (0, createVariableDeclaration_1.createVariableDeclaration)(variableDeclaration, undefined, undefined, undefined)
-        : variableDeclaration,
-    block,
-});
-exports.createCatchClause = createCatchClause;
-//# sourceMappingURL=createCatchClause.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createCatchClause.mjs","sources":["createCatchClause.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createCatchClause = void 0;\nconst make_1 = require(\"../internal/make\");\nconst createVariableDeclaration_1 = require(\"./createVariableDeclaration\");\n/**\n * Create a {@link CatchClause}: the `catch (...) { ... }` arm of a try.\n *\n * The `variableDeclaration` binds the caught value. Pass a string for the\n * common `catch (e)` case and it is turned into a bare binding; pass a full\n * {@link VariableDeclaration} when you need a type or destructuring pattern;\n * pass `undefined` for the binding-less `catch { ... }` form. The `block` is\n * the handler body.\n *\n * With `variableDeclaration` of `e` and a `block` calling `handle(e)`, the\n * result is:\n *\n * ```ts\n * catch (e) {\n *   handle(e);\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param variableDeclaration The variableDeclaration.\n * @param block The block.\n * @returns The created {@link CatchClause}.\n */\nconst createCatchClause = (variableDeclaration, block) => (0, make_1.make)(\"CatchClause\", {\n    variableDeclaration: typeof variableDeclaration === \"string\"\n        ? (0, createVariableDeclaration_1.createVariableDeclaration)(variableDeclaration, undefined, undefined, undefined)\n        : variableDeclaration,\n    block,\n});\nexports.createCatchClause = createCatchClause;\n//# sourceMappingURL=createCatchClause.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,MAAM,2BAA2B,GAAG,OAAO,CAAC,6BAA6B,CAAC;AAC1E;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,mBAAmB,EAAE,KAAK,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE;AAC1F,IAAI,mBAAmB,EAAE,OAAO,mBAAmB,KAAK;AACxD,UAAU,IAAI,2BAA2B,CAAC,yBAAyB,EAAE,mBAAmB,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS;AACzH,UAAU,mBAAmB;AAC7B,IAAI,KAAK;AACT,CAAC,CAAC;AACF,OAAO,CAAC,iBAAiB,GAAG,iBAAiB"}

package/lib/factory/statements/createContinueStatement.mjs

@@ -1,31 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createContinueStatement = void 0;
-const asName_1 = require("../internal/asName");
-const make_1 = require("../internal/make");
-/**
- * Create a {@link ContinueStatement}: a `continue;` statement.
- *
- * The optional `label` names an enclosing labeled loop to continue. A string is
- * wrapped into an identifier; pass nothing for a plain `continue`.
- *
- * With no label the result is:
- *
- * ```ts
- * continue;
- * ```
- *
- * With `label` of `outer` the result is:
- *
- * ```ts
- * continue outer;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param label The label.
- * @returns The created {@link ContinueStatement}.
- */
-const createContinueStatement = (label) => (0, make_1.make)("ContinueStatement", {
-    label: label === undefined ? undefined : (0, asName_1.asName)(label),
-});
-exports.createContinueStatement = createContinueStatement;
-//# sourceMappingURL=createContinueStatement.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createContinueStatement.mjs","sources":["createContinueStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createContinueStatement = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ContinueStatement}: a `continue;` statement.\n *\n * The optional `label` names an enclosing labeled loop to continue. A string is\n * wrapped into an identifier; pass nothing for a plain `continue`.\n *\n * With no label the result is:\n *\n * ```ts\n * continue;\n * ```\n *\n * With `label` of `outer` the result is:\n *\n * ```ts\n * continue outer;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param label The label.\n * @returns The created {@link ContinueStatement}.\n */\nconst createContinueStatement = (label) => (0, make_1.make)(\"ContinueStatement\", {\n    label: label === undefined ? undefined : (0, asName_1.asName)(label),\n});\nexports.createContinueStatement = createContinueStatement;\n//# sourceMappingURL=createContinueStatement.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,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC;AAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,uBAAuB,GAAG,CAAC,KAAK,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,mBAAmB,EAAE;AACjF,IAAI,KAAK,EAAE,KAAK,KAAK,SAAS,GAAG,SAAS,GAAG,IAAI,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;AACxE,CAAC,CAAC;AACF,OAAO,CAAC,uBAAuB,GAAG,uBAAuB"}

package/lib/factory/statements/createDebuggerStatement.mjs

@@ -1,21 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDebuggerStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link DebuggerStatement}: a `debugger;` statement.
- *
- * The statement takes no inputs and triggers a breakpoint when a debugger is
- * attached.
- *
- * The result is always:
- *
- * ```ts
- * debugger;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @returns The created {@link DebuggerStatement}.
- */
-const createDebuggerStatement = () => (0, make_1.make)("DebuggerStatement", {});
-exports.createDebuggerStatement = createDebuggerStatement;
-//# sourceMappingURL=createDebuggerStatement.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createDebuggerStatement.mjs","sources":["createDebuggerStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createDebuggerStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link DebuggerStatement}: a `debugger;` statement.\n *\n * The statement takes no inputs and triggers a breakpoint when a debugger is\n * attached.\n *\n * The result is always:\n *\n * ```ts\n * debugger;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link DebuggerStatement}.\n */\nconst createDebuggerStatement = () => (0, make_1.make)(\"DebuggerStatement\", {});\nexports.createDebuggerStatement = createDebuggerStatement;\n//# sourceMappingURL=createDebuggerStatement.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,uBAAuB,GAAG,MAAM;AACxC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,uBAAuB,GAAG,MAAM,IAAI,MAAM,CAAC,IAAI,EAAE,mBAAmB,EAAE,EAAE,CAAC;AAC/E,OAAO,CAAC,uBAAuB,GAAG,uBAAuB"}

package/lib/factory/statements/createDefaultClause.mjs

@@ -1,24 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDefaultClause = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link DefaultClause}: the `default:` arm of a switch.
- *
- * The `statements` form the body that runs when no `case` matches. As with
- * `case` arms, fall-through is the default, so add an explicit `break` when the
- * arm should stop.
- *
- * With `statements` of a single `b()` call, the result is:
- *
- * ```ts
- * default:
- *   b();
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param statements The statements.
- * @returns The created {@link DefaultClause}.
- */
-const createDefaultClause = (statements) => (0, make_1.make)("DefaultClause", { statements });
-exports.createDefaultClause = createDefaultClause;
-//# sourceMappingURL=createDefaultClause.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createDefaultClause.mjs","sources":["createDefaultClause.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createDefaultClause = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link DefaultClause}: the `default:` arm of a switch.\n *\n * The `statements` form the body that runs when no `case` matches. As with\n * `case` arms, fall-through is the default, so add an explicit `break` when the\n * arm should stop.\n *\n * With `statements` of a single `b()` call, the result is:\n *\n * ```ts\n * default:\n *   b();\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param statements The statements.\n * @returns The created {@link DefaultClause}.\n */\nconst createDefaultClause = (statements) => (0, make_1.make)(\"DefaultClause\", { statements });\nexports.createDefaultClause = createDefaultClause;\n//# sourceMappingURL=createDefaultClause.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,MAAM,mBAAmB,GAAG,CAAC,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,UAAU,EAAE,CAAC;AAC7F,OAAO,CAAC,mBAAmB,GAAG,mBAAmB"}

package/lib/factory/statements/createDoStatement.mjs

@@ -1,27 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDoStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link DoStatement}: a `do ... while (...)` loop.
- *
- * The `statement` is the loop body and `expression` is the condition tested
- * after each pass, so the body always runs at least once. Note the argument
- * order: the body comes before the condition, matching the source layout.
- *
- * With a `statement` block calling `a()` and an `expression` of `cond`, the
- * result is:
- *
- * ```ts
- * do {
- *   a();
- * } while (cond);
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param statement The statement.
- * @param expression The expression.
- * @returns The created {@link DoStatement}.
- */
-const createDoStatement = (statement, expression) => (0, make_1.make)("DoStatement", { statement, expression });
-exports.createDoStatement = createDoStatement;
-//# sourceMappingURL=createDoStatement.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createDoStatement.mjs","sources":["createDoStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createDoStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link DoStatement}: a `do ... while (...)` loop.\n *\n * The `statement` is the loop body and `expression` is the condition tested\n * after each pass, so the body always runs at least once. Note the argument\n * order: the body comes before the condition, matching the source layout.\n *\n * With a `statement` block calling `a()` and an `expression` of `cond`, the\n * result is:\n *\n * ```ts\n * do {\n *   a();\n * } while (cond);\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param statement The statement.\n * @param expression The expression.\n * @returns The created {@link DoStatement}.\n */\nconst createDoStatement = (statement, expression) => (0, make_1.make)(\"DoStatement\", { statement, expression });\nexports.createDoStatement = createDoStatement;\n//# sourceMappingURL=createDoStatement.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,MAAM,iBAAiB,GAAG,CAAC,SAAS,EAAE,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC;AAC/G,OAAO,CAAC,iBAAiB,GAAG,iBAAiB"}

package/lib/factory/statements/createEmptyStatement.mjs

@@ -1,21 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEmptyStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create an {@link EmptyStatement}: a lone `;` statement.
- *
- * The statement takes no inputs and does nothing. It is the empty body you
- * reach for when a loop or branch needs a statement but no work, such as `for
- * (; cond; );`.
- *
- * The result is a single semicolon:
- *
- * ```ts
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @returns The created {@link EmptyStatement}.
- */
-const createEmptyStatement = () => (0, make_1.make)("EmptyStatement", {});
-exports.createEmptyStatement = createEmptyStatement;
-//# sourceMappingURL=createEmptyStatement.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createEmptyStatement.mjs","sources":["createEmptyStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createEmptyStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link EmptyStatement}: a lone `;` statement.\n *\n * The statement takes no inputs and does nothing. It is the empty body you\n * reach for when a loop or branch needs a statement but no work, such as `for\n * (; cond; );`.\n *\n * The result is a single semicolon:\n *\n * ```ts\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link EmptyStatement}.\n */\nconst createEmptyStatement = () => (0, make_1.make)(\"EmptyStatement\", {});\nexports.createEmptyStatement = createEmptyStatement;\n//# sourceMappingURL=createEmptyStatement.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,MAAM,oBAAoB,GAAG,MAAM,IAAI,MAAM,CAAC,IAAI,EAAE,gBAAgB,EAAE,EAAE,CAAC;AACzE,OAAO,CAAC,oBAAoB,GAAG,oBAAoB"}

package/lib/factory/statements/createExpressionStatement.mjs

@@ -1,23 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExpressionStatement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create an {@link ExpressionStatement}: an expression used as a statement.
- *
- * The `expression` is evaluated for its effect and the printer terminates it
- * with a semicolon. This is how a call, assignment, or similar expression
- * becomes a standalone statement.
- *
- * With `expression` of a `doThing(a)` call, the result is:
- *
- * ```ts
- * doThing(a);
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param expression The expression.
- * @returns The created {@link ExpressionStatement}.
- */
-const createExpressionStatement = (expression) => (0, make_1.make)("ExpressionStatement", { expression });
-exports.createExpressionStatement = createExpressionStatement;
-//# sourceMappingURL=createExpressionStatement.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createExpressionStatement.mjs","sources":["createExpressionStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createExpressionStatement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link ExpressionStatement}: an expression used as a statement.\n *\n * The `expression` is evaluated for its effect and the printer terminates it\n * with a semicolon. This is how a call, assignment, or similar expression\n * becomes a standalone statement.\n *\n * With `expression` of a `doThing(a)` call, the result is:\n *\n * ```ts\n * doThing(a);\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @returns The created {@link ExpressionStatement}.\n */\nconst createExpressionStatement = (expression) => (0, make_1.make)(\"ExpressionStatement\", { expression });\nexports.createExpressionStatement = createExpressionStatement;\n//# sourceMappingURL=createExpressionStatement.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,MAAM,yBAAyB,GAAG,CAAC,UAAU,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,qBAAqB,EAAE,EAAE,UAAU,EAAE,CAAC;AACzG,OAAO,CAAC,yBAAyB,GAAG,yBAAyB"}