@ttsc/factory 0.15.9 → 0.15.11

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":["../../../src/factory/names/createUniqueName.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,gBAAgB,GAAG,CAC9B,IAAY,EACZ,MAAe,EACf,MAAe,EACf,MAAe,KACA,gBAAgB,CAAC,CAAA,EAAG,MAAM,IAAI,EAAE,CAAA,EAAG,IAAI,CAAA,EAAG,MAAM,IAAI,EAAE,CAAA,CAAE;;;;"}

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":["../../../src/factory/names/createUniquePrivateName.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,uBAAuB,GAAG,CACrC,IAAa,EACb,MAAe,EACf,MAAe,KAEf,uBAAuB,CACrB,IAAI,MAAM,IAAI,EAAE,CAAA,EAAG,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,SAAS,CAAA,EAAG,MAAM,IAAI,EAAE,CAAA,CAAE;;;;"}

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":["../../../src/factory/statements/createBlock.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,WAAW,GAAG,CACzB,UAAgC,EAChC,SAAmB,KACT,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":["../../../src/factory/statements/createBreakStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,oBAAoB,GAAG,CAClC,KAA2B,KAE3B,IAAI,CAAC,gBAAgB,EAAE;AACrB,IAAA,KAAK,EAAE,KAAK,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC;AACvD,CAAA;;;;"}

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":["../../../src/factory/statements/createCaseBlock.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,eAAe,GAAG,CAC7B,OAAuC,KACzB,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":["../../../src/factory/statements/createCaseClause.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;AAqBG;MACU,gBAAgB,GAAG,CAC9B,UAAsB,EACtB,UAAgC,KACjB,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":["../../../src/factory/statements/createCatchClause.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,iBAAiB,GAAG,CAC/B,mBAA6D,EAC7D,KAAY,KAEZ,IAAI,CAAC,aAAa,EAAE;AAClB,IAAA,mBAAmB,EACjB,OAAO,mBAAmB,KAAK;UAC3B,yBAAyB,CACvB,mBAAmB,EACnB,SAAS,EACT,SAAS,EACT,SAAS;AAEb,UAAE,mBAAmB;IACzB,KAAK;AACN,CAAA;;;;"}

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":["../../../src/factory/statements/createContinueStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,uBAAuB,GAAG,CACrC,KAA2B,KAE3B,IAAI,CAAC,mBAAmB,EAAE;AACxB,IAAA,KAAK,EAAE,KAAK,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC;AACvD,CAAA;;;;"}

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":["../../../src/factory/statements/createDebuggerStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;AAcG;AACI,MAAM,uBAAuB,GAAG,MACrC,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":["../../../src/factory/statements/createDefaultClause.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,mBAAmB,GAAG,CACjC,UAAgC,KACd,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":["../../../src/factory/statements/createDoStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,iBAAiB,GAAG,CAC/B,SAAoB,EACpB,UAAsB,KACN,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":["../../../src/factory/statements/createEmptyStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;AAcG;AACI,MAAM,oBAAoB,GAAG,MAClC,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":["../../../src/factory/statements/createExpressionStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,yBAAyB,GAAG,CACvC,UAAsB,KACE,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createForInStatement.mjs","sources":["../../../src/factory/statements/createForInStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,oBAAoB,GAAG,CAClC,WAA2B,EAC3B,UAAsB,EACtB,SAAoB,KAEpB,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":["../../../src/factory/statements/createForOfStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACI,MAAM,oBAAoB,GAAG,CAClC,aAAgC,EAChC,WAA2B,EAC3B,UAAsB,EACtB,SAAoB,KAEpB,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":["../../../src/factory/statements/createForStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,kBAAkB,GAAG,CAChC,WAAuC,EACvC,SAAiC,EACjC,WAAmC,EACnC,SAAoB,KAEpB,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":["../../../src/factory/statements/createIfStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACI,MAAM,iBAAiB,GAAG,CAC/B,UAAsB,EACtB,aAAwB,EACxB,aAAyB,KAEzB,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":["../../../src/factory/statements/createLabeledStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,sBAAsB,GAAG,CACpC,KAA0B,EAC1B,SAAoB,KAEpB,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":["../../../src/factory/statements/createNotEmittedStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;AAaG;AACI,MAAM,yBAAyB,GAAG,CACvC,QAAe,KACS,IAAI,CAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE;;;;"}