@ttsc/factory 0.15.9 → 0.15.10

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

@@ -0,0 +1 @@
+{"version":3,"file":"createForInStatement.mjs","sources":["../../../esm-tmp/factory/statements/createForInStatement.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createForInStatement = (initializer, expression, statement) => make(\"ForInStatement\", { initializer, expression, statement });\n//# sourceMappingURL=createForInStatement.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,oBAAoB,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,SAAS,KAAK,IAAI,CAAC,gBAAgB,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/statements/createForOfStatement.mjs

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

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

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

package/lib/factory/statements/createForStatement.mjs

@@ -0,0 +1,32 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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) => make("ForStatement", { initializer, condition, incrementor, statement });
+
+export { createForStatement };
+//# sourceMappingURL=createForStatement.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createForStatement.mjs","sources":["../../../esm-tmp/factory/statements/createForStatement.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createForStatement = (initializer, condition, incrementor, statement) => make(\"ForStatement\", { initializer, condition, incrementor, statement });\n//# sourceMappingURL=createForStatement.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,kBAAkB,GAAG,CAAC,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/statements/createIfStatement.mjs

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

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

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

package/lib/factory/statements/createLabeledStatement.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createLabeledStatement.mjs","sources":["../../../esm-tmp/factory/statements/createLabeledStatement.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link LabeledStatement}: a `label: ...` statement.\n *\n * The `label` names the statement so a `break` or `continue` can target it; a\n * string is wrapped into an identifier. The `statement` is the body the label\n * applies to, typically a loop.\n *\n * With a `label` of `outer` and a `statement` of an empty `for` loop that calls\n * `break outer`, the result is:\n *\n * ```ts\n * outer: for (;;) {\n *   break outer;\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param label The label.\n * @param statement The statement.\n * @returns The created {@link LabeledStatement}.\n */\nexport const createLabeledStatement = (label, statement) => make(\"LabeledStatement\", { label: asName(label), statement });\n//# sourceMappingURL=createLabeledStatement.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC,kBAAkB,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/statements/createNotEmittedStatement.mjs

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

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

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

package/lib/factory/statements/createReturnStatement.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createReturnStatement.mjs","sources":["../../../esm-tmp/factory/statements/createReturnStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ReturnStatement}: a `return ...;` statement.\n *\n * The optional `expression` is the value handed back to the caller. Omit it for\n * a bare `return;` that yields `undefined`.\n *\n * With no expression the result is:\n *\n * ```ts\n * return;\n * ```\n *\n * With an `expression` of `value` the result is:\n *\n * ```ts\n * return value;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @returns The created {@link ReturnStatement}.\n */\nexport const createReturnStatement = (expression) => make(\"ReturnStatement\", { expression });\n//# sourceMappingURL=createReturnStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/statements/createSwitchStatement.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createSwitchStatement.mjs","sources":["../../../esm-tmp/factory/statements/createSwitchStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link SwitchStatement}: a `switch (...) { ... }` statement.\n *\n * The `expression` is the subject compared against each arm, and `caseBlock` is\n * the braced body of `case` and `default` clauses, built with\n * {@link createCaseBlock}.\n *\n * With `expression` of `x` and a `caseBlock` holding a `case 1:` arm (calling\n * `a()` then `break`) and a `default:` arm (calling `b()`), the result is:\n *\n * ```ts\n * switch (x) {\n *   case 1:\n *     a();\n *     break;\n *   default:\n *     b();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @param caseBlock The caseBlock.\n * @returns The created {@link SwitchStatement}.\n */\nexport const createSwitchStatement = (expression, caseBlock) => make(\"SwitchStatement\", { expression, caseBlock });\n//# sourceMappingURL=createSwitchStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/statements/createThrowStatement.mjs

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

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

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

package/lib/factory/statements/createTryStatement.mjs

@@ -0,0 +1,34 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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) => make("TryStatement", { tryBlock, catchClause, finallyBlock });
+
+export { createTryStatement };
+//# sourceMappingURL=createTryStatement.mjs.map

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

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

package/lib/factory/statements/createVariableDeclaration.mjs

@@ -0,0 +1,38 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * 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) => make("VariableDeclaration", {
+    name: typeof name === "string" ? createIdentifier(name) : name,
+    exclamationToken,
+    type,
+    initializer,
+});
+
+export { createVariableDeclaration };
+//# sourceMappingURL=createVariableDeclaration.mjs.map

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

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

package/lib/factory/statements/createVariableDeclarationList.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+import { NodeFlags } from '../../syntax/NodeFlags.mjs';
+
+/**
+ * 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) => make("VariableDeclarationList", { declarations, flags });
+
+export { createVariableDeclarationList };
+//# sourceMappingURL=createVariableDeclarationList.mjs.map

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

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

package/lib/factory/statements/createVariableStatement.mjs

@@ -0,0 +1,33 @@
+import { make } from '../internal/make.mjs';
+import { createVariableDeclarationList } from './createVariableDeclarationList.mjs';
+
+/**
+ * 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) => make("VariableStatement", {
+    modifiers,
+    declarationList: Array.isArray(declarationList)
+        ? createVariableDeclarationList(declarationList)
+        : declarationList,
+});
+
+export { createVariableStatement };
+//# sourceMappingURL=createVariableStatement.mjs.map

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

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

package/lib/factory/statements/createWhileStatement.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createWhileStatement.mjs","sources":["../../../esm-tmp/factory/statements/createWhileStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link WhileStatement}: a `while (...) ...` loop.\n *\n * The `expression` is the condition tested before each pass and `statement` is\n * the loop body. The body runs zero or more times, only while the condition\n * holds.\n *\n * With an `expression` of `cond` and a `statement` block calling `a()`, the\n * result is:\n *\n * ```ts\n * while (cond) {\n *   a();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @param statement The statement.\n * @returns The created {@link WhileStatement}.\n */\nexport const createWhileStatement = (expression, statement) => make(\"WhileStatement\", { expression, statement });\n//# sourceMappingURL=createWhileStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,CAAC,gBAAgB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/statements/createWithStatement.mjs

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

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

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

package/lib/factory/types/createArrayTypeNode.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createArrayTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createArrayTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ArrayTypeNode}: a `T[]` postfix array type.\n *\n * The element type is emitted in postfix-operand position, so a\n * lower-precedence form that would otherwise re-associate gets wrapped in\n * parentheses first. A union, intersection, function, constructor, conditional,\n * infer, or type-operator element prints as `(...)[]`; anything else prints\n * bare.\n *\n * Given a `string` element, the printer renders:\n *\n * ```ts\n * string[]\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elementType The element type.\n * @returns The created {@link ArrayTypeNode}.\n */\nexport const createArrayTypeNode = (elementType) => make(\"ArrayTypeNode\", { elementType });\n//# sourceMappingURL=createArrayTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,WAAW,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,WAAW,EAAE;;;;"}

package/lib/factory/types/createCallSignature.mjs

@@ -0,0 +1,26 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * 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) => make("CallSignature", { typeParameters, parameters, type });
+
+export { createCallSignature };
+//# sourceMappingURL=createCallSignature.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createCallSignature.mjs","sources":["../../../esm-tmp/factory/types/createCallSignature.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link CallSignature}: a `(params): ReturnType` call signature for an\n * interface or type literal.\n *\n * Optional type parameters print first as `<...>`, then the parameter list,\n * then the return type as `: Type` when present.\n *\n * Given one `x: number` parameter and a `string` return type, the printer\n * renders:\n *\n * ```ts\n * (x: number): string\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type, if any.\n * @returns The created {@link CallSignature}.\n */\nexport const createCallSignature = (typeParameters, parameters, type) => make(\"CallSignature\", { typeParameters, parameters, type });\n//# sourceMappingURL=createCallSignature.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createConditionalTypeNode.mjs

@@ -0,0 +1,28 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ConditionalTypeNode}: a `C extends E ? X : Y` conditional
+ * type.
+ *
+ * The four type arms print in order, joined by `extends`, `?`, and `:`. The
+ * printer emits each arm as-is without adding parentheses, so the caller is
+ * responsible for wrapping any arm that needs grouping.
+ *
+ * Given check `T`, extends `U`, true `string`, and false `number`, the printer
+ * renders:
+ *
+ * ```ts
+ * T extends U ? string : number
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param checkType The type being tested.
+ * @param extendsType The type tested against.
+ * @param trueType The branch type when the test passes.
+ * @param falseType The branch type when the test fails.
+ * @returns The created {@link ConditionalTypeNode}.
+ */
+const createConditionalTypeNode = (checkType, extendsType, trueType, falseType) => make("ConditionalTypeNode", { checkType, extendsType, trueType, falseType });
+
+export { createConditionalTypeNode };
+//# sourceMappingURL=createConditionalTypeNode.mjs.map

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

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