@ttsc/factory 0.15.9 → 0.15.10

package/lib/factory/names/createSuper.mjs

@@ -0,0 +1,22 @@
+import { createToken } from './createToken.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * 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 = () => createToken(SyntaxKind.SuperKeyword);
+
+export { createSuper };
+//# sourceMappingURL=createSuper.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createSuper.mjs","sources":["../../../esm-tmp/factory/names/createSuper.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createToken } from \"./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 */\nexport const createSuper = () => createToken(SyntaxKind.SuperKeyword);\n//# sourceMappingURL=createSuper.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,WAAW,GAAG,MAAM,WAAW,CAAC,UAAU,CAAC,YAAY;;;;"}

package/lib/factory/names/createTempVariable.mjs

@@ -0,0 +1,33 @@
+import { createIdentifier } from './createIdentifier.mjs';
+
+/**
+ * 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) => createIdentifier(`${prefix ?? ""}_temp${suffix ?? ""}`);
+
+export { createTempVariable };
+//# sourceMappingURL=createTempVariable.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTempVariable.mjs","sources":["../../../esm-tmp/factory/names/createTempVariable.js"],"sourcesContent":["import { createIdentifier } from \"./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 */\nexport const createTempVariable = (_recordTempVariable, _reservedInNestedScopes, prefix, suffix) => createIdentifier(`${prefix ?? \"\"}_temp${suffix ?? \"\"}`);\n//# sourceMappingURL=createTempVariable.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,CAAC,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,EAAE,MAAM,KAAK,gBAAgB,CAAC,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC;;;;"}

package/lib/factory/names/createThis.mjs

@@ -0,0 +1,22 @@
+import { createToken } from './createToken.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * 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 = () => createToken(SyntaxKind.ThisKeyword);
+
+export { createThis };
+//# sourceMappingURL=createThis.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createThis.mjs","sources":["../../../esm-tmp/factory/names/createThis.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createToken } from \"./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 */\nexport const createThis = () => createToken(SyntaxKind.ThisKeyword);\n//# sourceMappingURL=createThis.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,UAAU,GAAG,MAAM,WAAW,CAAC,UAAU,CAAC,WAAW;;;;"}

package/lib/factory/names/createToken.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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) => make("Token", { token });
+
+export { createToken };
+//# sourceMappingURL=createToken.mjs.map

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

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

package/lib/factory/names/createTrue.mjs

@@ -0,0 +1,22 @@
+import { createToken } from './createToken.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * 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 = () => createToken(SyntaxKind.TrueKeyword);
+
+export { createTrue };
+//# sourceMappingURL=createTrue.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTrue.mjs","sources":["../../../esm-tmp/factory/names/createTrue.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createToken } from \"./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 */\nexport const createTrue = () => createToken(SyntaxKind.TrueKeyword);\n//# sourceMappingURL=createTrue.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,UAAU,GAAG,MAAM,WAAW,CAAC,UAAU,CAAC,WAAW;;;;"}

package/lib/factory/names/createUniqueName.mjs

@@ -0,0 +1,32 @@
+import { createIdentifier } from './createIdentifier.mjs';
+
+/**
+ * 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) => createIdentifier(`${prefix ?? ""}${text}${suffix ?? ""}`);
+
+export { createUniqueName };
+//# sourceMappingURL=createUniqueName.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createUniqueName.mjs","sources":["../../../esm-tmp/factory/names/createUniqueName.js"],"sourcesContent":["import { createIdentifier } from \"./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 */\nexport const createUniqueName = (text, _flags, prefix, suffix) => createIdentifier(`${prefix ?? \"\"}${text}${suffix ?? \"\"}`);\n//# sourceMappingURL=createUniqueName.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,gBAAgB,CAAC,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC;;;;"}

package/lib/factory/names/createUniquePrivateName.mjs

@@ -0,0 +1,29 @@
+import { createPrivateIdentifier } from './createPrivateIdentifier.mjs';
+
+/**
+ * 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) => createPrivateIdentifier(`#${prefix ?? ""}${text ? text.replace(/^#/, "") : "_unique"}${suffix ?? ""}`);
+
+export { createUniquePrivateName };
+//# sourceMappingURL=createUniquePrivateName.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createUniquePrivateName.mjs","sources":["../../../esm-tmp/factory/names/createUniquePrivateName.js"],"sourcesContent":["import { createPrivateIdentifier } from \"./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 */\nexport const createUniquePrivateName = (text, prefix, suffix) => createPrivateIdentifier(`#${prefix ?? \"\"}${text ? text.replace(/^#/, \"\") : \"_unique\"}${suffix ?? \"\"}`);\n//# sourceMappingURL=createUniquePrivateName.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,KAAK,uBAAuB,CAAC,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;;;;"}

package/lib/factory/statements/createBlock.mjs

@@ -0,0 +1,29 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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) => make("Block", { statements, multiLine: multiLine ?? true });
+
+export { createBlock };
+//# sourceMappingURL=createBlock.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createBlock.mjs","sources":["../../../esm-tmp/factory/statements/createBlock.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createBlock = (statements, multiLine) => make(\"Block\", { statements, multiLine: multiLine ?? true });\n//# sourceMappingURL=createBlock.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,WAAW,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,CAAC,OAAO,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,IAAI,IAAI,EAAE;;;;"}

package/lib/factory/statements/createBreakStatement.mjs

@@ -0,0 +1,31 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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) => make("BreakStatement", {
+    label: label === undefined ? undefined : asName(label),
+});
+
+export { createBreakStatement };
+//# sourceMappingURL=createBreakStatement.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createBreakStatement.mjs","sources":["../../../esm-tmp/factory/statements/createBreakStatement.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../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 */\nexport const createBreakStatement = (label) => make(\"BreakStatement\", {\n    label: label === undefined ? undefined : asName(label),\n});\n//# sourceMappingURL=createBreakStatement.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,CAAC,KAAK,KAAK,IAAI,CAAC,gBAAgB,EAAE;AACtE,IAAI,KAAK,EAAE,KAAK,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC;AAC1D,CAAC;;;;"}

package/lib/factory/statements/createCaseBlock.mjs

@@ -0,0 +1,30 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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) => make("CaseBlock", { clauses });
+
+export { createCaseBlock };
+//# sourceMappingURL=createCaseBlock.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createCaseBlock.mjs","sources":["../../../esm-tmp/factory/statements/createCaseBlock.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createCaseBlock = (clauses) => make(\"CaseBlock\", { clauses });\n//# sourceMappingURL=createCaseBlock.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,eAAe,GAAG,CAAC,OAAO,KAAK,IAAI,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/statements/createCaseClause.mjs

@@ -0,0 +1,28 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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) => make("CaseClause", { expression, statements });
+
+export { createCaseClause };
+//# sourceMappingURL=createCaseClause.mjs.map

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

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

package/lib/factory/statements/createCatchClause.mjs

@@ -0,0 +1,35 @@
+import { make } from '../internal/make.mjs';
+import { createVariableDeclaration } from './createVariableDeclaration.mjs';
+
+/**
+ * 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) => make("CatchClause", {
+    variableDeclaration: typeof variableDeclaration === "string"
+        ? createVariableDeclaration(variableDeclaration, undefined, undefined, undefined)
+        : variableDeclaration,
+    block,
+});
+
+export { createCatchClause };
+//# sourceMappingURL=createCatchClause.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createCatchClause.mjs","sources":["../../../esm-tmp/factory/statements/createCatchClause.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createVariableDeclaration } from \"./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 */\nexport const createCatchClause = (variableDeclaration, block) => make(\"CatchClause\", {\n    variableDeclaration: typeof variableDeclaration === \"string\"\n        ? createVariableDeclaration(variableDeclaration, undefined, undefined, undefined)\n        : variableDeclaration,\n    block,\n});\n//# sourceMappingURL=createCatchClause.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,iBAAiB,GAAG,CAAC,mBAAmB,EAAE,KAAK,KAAK,IAAI,CAAC,aAAa,EAAE;AACrF,IAAI,mBAAmB,EAAE,OAAO,mBAAmB,KAAK;AACxD,UAAU,yBAAyB,CAAC,mBAAmB,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS;AACxF,UAAU,mBAAmB;AAC7B,IAAI,KAAK;AACT,CAAC;;;;"}

package/lib/factory/statements/createContinueStatement.mjs

@@ -0,0 +1,31 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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) => make("ContinueStatement", {
+    label: label === undefined ? undefined : asName(label),
+});
+
+export { createContinueStatement };
+//# sourceMappingURL=createContinueStatement.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createContinueStatement.mjs","sources":["../../../esm-tmp/factory/statements/createContinueStatement.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../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 */\nexport const createContinueStatement = (label) => make(\"ContinueStatement\", {\n    label: label === undefined ? undefined : asName(label),\n});\n//# sourceMappingURL=createContinueStatement.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,KAAK,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC5E,IAAI,KAAK,EAAE,KAAK,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC;AAC1D,CAAC;;;;"}

package/lib/factory/statements/createDebuggerStatement.mjs

@@ -0,0 +1,21 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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 = () => make("DebuggerStatement", {});
+
+export { createDebuggerStatement };
+//# sourceMappingURL=createDebuggerStatement.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createDebuggerStatement.mjs","sources":["../../../esm-tmp/factory/statements/createDebuggerStatement.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createDebuggerStatement = () => make(\"DebuggerStatement\", {});\n//# sourceMappingURL=createDebuggerStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,MAAM,IAAI,CAAC,mBAAmB,EAAE,EAAE;;;;"}

package/lib/factory/statements/createDefaultClause.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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) => make("DefaultClause", { statements });
+
+export { createDefaultClause };
+//# sourceMappingURL=createDefaultClause.mjs.map

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

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

package/lib/factory/statements/createDoStatement.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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) => make("DoStatement", { statement, expression });
+
+export { createDoStatement };
+//# sourceMappingURL=createDoStatement.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createDoStatement.mjs","sources":["../../../esm-tmp/factory/statements/createDoStatement.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createDoStatement = (statement, expression) => make(\"DoStatement\", { statement, expression });\n//# sourceMappingURL=createDoStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,iBAAiB,GAAG,CAAC,SAAS,EAAE,UAAU,KAAK,IAAI,CAAC,aAAa,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/statements/createEmptyStatement.mjs

@@ -0,0 +1,21 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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 = () => make("EmptyStatement", {});
+
+export { createEmptyStatement };
+//# sourceMappingURL=createEmptyStatement.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createEmptyStatement.mjs","sources":["../../../esm-tmp/factory/statements/createEmptyStatement.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createEmptyStatement = () => make(\"EmptyStatement\", {});\n//# sourceMappingURL=createEmptyStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,MAAM,IAAI,CAAC,gBAAgB,EAAE,EAAE;;;;"}

package/lib/factory/statements/createExpressionStatement.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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) => make("ExpressionStatement", { expression });
+
+export { createExpressionStatement };
+//# sourceMappingURL=createExpressionStatement.mjs.map

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

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

package/lib/factory/statements/createForInStatement.mjs

@@ -0,0 +1,29 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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) => make("ForInStatement", { initializer, expression, statement });
+
+export { createForInStatement };
+//# sourceMappingURL=createForInStatement.mjs.map