@ttsc/factory 0.15.6 → 0.15.8

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

@@ -1 +1 @@
-{"version":3,"file":"createEmptyStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createEmptyStatement.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;GAKG;AACI,MAAM,oBAAoB,GAAG,GAAmB,EAAE,CACvD,IAAA,WAAI,EAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC;AADhB,QAAA,oBAAoB,GAApB,oBAAoB,CACJ"}
+{"version":3,"file":"createEmptyStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createEmptyStatement.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;;;;;;;GAcG;AACI,MAAM,oBAAoB,GAAG,GAAmB,EAAE,CACvD,IAAA,WAAI,EAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC;AADhB,QAAA,oBAAoB,GAApB,oBAAoB,CACJ"}

package/lib/factory/statements/createEmptyStatement.mjs

@@ -2,7 +2,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEmptyStatement = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link EmptyStatement}.
+ * 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}.

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

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

package/lib/factory/statements/createExpressionStatement.d.ts

@@ -1,6 +1,16 @@
 import type { Expression, ExpressionStatement } from "../../ast";
 /**
- * Create a {@link ExpressionStatement}.
+ * 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.

package/lib/factory/statements/createExpressionStatement.js

@@ -3,7 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createExpressionStatement = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link ExpressionStatement}.
+ * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"createExpressionStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createExpressionStatement.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;GAMG;AACI,MAAM,yBAAyB,GAAG,CACvC,UAAsB,EACD,EAAE,CAAC,IAAA,WAAI,EAAC,qBAAqB,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;AAFzD,QAAA,yBAAyB,GAAzB,yBAAyB,CAEgC"}
+{"version":3,"file":"createExpressionStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createExpressionStatement.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;;;;;;;;;GAgBG;AACI,MAAM,yBAAyB,GAAG,CACvC,UAAsB,EACD,EAAE,CAAC,IAAA,WAAI,EAAC,qBAAqB,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;AAFzD,QAAA,yBAAyB,GAAzB,yBAAyB,CAEgC"}

package/lib/factory/statements/createExpressionStatement.mjs

@@ -2,7 +2,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createExpressionStatement = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link ExpressionStatement}.
+ * 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.

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

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

package/lib/factory/statements/createForInStatement.d.ts

@@ -1,6 +1,20 @@
 import type { Expression, ForInStatement, ForInitializer, Statement } from "../../ast";
 /**
- * Create a {@link ForInStatement}.
+ * 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.

package/lib/factory/statements/createForInStatement.js

@@ -3,7 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createForInStatement = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link ForInStatement}.
+ * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"createForInStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createForInStatement.ts"],"names":[],"mappings":";;;AAMA,2CAAwC;AAExC;;;;;;;;GAQG;AACI,MAAM,oBAAoB,GAAG,CAClC,WAA2B,EAC3B,UAAsB,EACtB,SAAoB,EACJ,EAAE,CAClB,IAAA,WAAI,EAAC,gBAAgB,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,CAAC;AALpD,QAAA,oBAAoB,GAApB,oBAAoB,CAKgC"}
+{"version":3,"file":"createForInStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createForInStatement.ts"],"names":[],"mappings":";;;AAMA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACI,MAAM,oBAAoB,GAAG,CAClC,WAA2B,EAC3B,UAAsB,EACtB,SAAoB,EACJ,EAAE,CAClB,IAAA,WAAI,EAAC,gBAAgB,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,CAAC;AALpD,QAAA,oBAAoB,GAApB,oBAAoB,CAKgC"}

package/lib/factory/statements/createForInStatement.mjs

@@ -2,7 +2,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createForInStatement = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link ForInStatement}.
+ * 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.

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

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

package/lib/factory/statements/createForOfStatement.d.ts

@@ -1,6 +1,29 @@
 import type { Expression, ForInitializer, ForOfStatement, Statement, Token } from "../../ast";
 /**
- * Create a {@link ForOfStatement}.
+ * 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.

package/lib/factory/statements/createForOfStatement.js

@@ -3,7 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createForOfStatement = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link ForOfStatement}.
+ * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"createForOfStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createForOfStatement.ts"],"names":[],"mappings":";;;AAOA,2CAAwC;AAExC;;;;;;;;;GASG;AACI,MAAM,oBAAoB,GAAG,CAClC,aAAgC,EAChC,WAA2B,EAC3B,UAAsB,EACtB,SAAoB,EACJ,EAAE,CAClB,IAAA,WAAI,EAAC,gBAAgB,EAAE,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,CAAC;AANnE,QAAA,oBAAoB,GAApB,oBAAoB,CAM+C"}
+{"version":3,"file":"createForOfStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createForOfStatement.ts"],"names":[],"mappings":";;;AAOA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACI,MAAM,oBAAoB,GAAG,CAClC,aAAgC,EAChC,WAA2B,EAC3B,UAAsB,EACtB,SAAoB,EACJ,EAAE,CAClB,IAAA,WAAI,EAAC,gBAAgB,EAAE,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,CAAC;AANnE,QAAA,oBAAoB,GAApB,oBAAoB,CAM+C"}

package/lib/factory/statements/createForOfStatement.mjs

@@ -2,7 +2,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createForOfStatement = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link ForOfStatement}.
+ * 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.

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

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

package/lib/factory/statements/createForStatement.d.ts

@@ -1,6 +1,22 @@
 import type { Expression, ForInitializer, ForStatement, Statement } from "../../ast";
 /**
- * Create a {@link ForStatement}.
+ * 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.

package/lib/factory/statements/createForStatement.js

@@ -3,7 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createForStatement = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link ForStatement}.
+ * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"createForStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createForStatement.ts"],"names":[],"mappings":";;;AAMA,2CAAwC;AAExC;;;;;;;;;GASG;AACI,MAAM,kBAAkB,GAAG,CAChC,WAAuC,EACvC,SAAiC,EACjC,WAAmC,EACnC,SAAoB,EACN,EAAE,CAChB,IAAA,WAAI,EAAC,cAAc,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC,CAAC;AAN9D,QAAA,kBAAkB,GAAlB,kBAAkB,CAM4C"}
+{"version":3,"file":"createForStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createForStatement.ts"],"names":[],"mappings":";;;AAMA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACI,MAAM,kBAAkB,GAAG,CAChC,WAAuC,EACvC,SAAiC,EACjC,WAAmC,EACnC,SAAoB,EACN,EAAE,CAChB,IAAA,WAAI,EAAC,cAAc,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC,CAAC;AAN9D,QAAA,kBAAkB,GAAlB,kBAAkB,CAM4C"}

package/lib/factory/statements/createForStatement.mjs

@@ -2,7 +2,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createForStatement = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link ForStatement}.
+ * 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.

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

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

package/lib/factory/statements/createIfStatement.d.ts

@@ -1,6 +1,22 @@
 import type { Expression, IfStatement, Statement } from "../../ast";
 /**
- * Create a {@link IfStatement}.
+ * 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.

package/lib/factory/statements/createIfStatement.js

@@ -3,7 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createIfStatement = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link IfStatement}.
+ * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"createIfStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createIfStatement.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;GAQG;AACI,MAAM,iBAAiB,GAAG,CAC/B,UAAsB,EACtB,aAAwB,EACxB,aAAyB,EACZ,EAAE,CACf,IAAA,WAAI,EAAC,aAAa,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,CAAC,CAAC;AALvD,QAAA,iBAAiB,GAAjB,iBAAiB,CAKsC"}
+{"version":3,"file":"createIfStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createIfStatement.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACI,MAAM,iBAAiB,GAAG,CAC/B,UAAsB,EACtB,aAAwB,EACxB,aAAyB,EACZ,EAAE,CACf,IAAA,WAAI,EAAC,aAAa,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,CAAC,CAAC;AALvD,QAAA,iBAAiB,GAAjB,iBAAiB,CAKsC"}

package/lib/factory/statements/createIfStatement.mjs

@@ -2,7 +2,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createIfStatement = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link IfStatement}.
+ * 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.

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

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

package/lib/factory/statements/createLabeledStatement.d.ts

@@ -1,6 +1,19 @@
 import type { Identifier, LabeledStatement, Statement } from "../../ast";
 /**
- * Create a {@link LabeledStatement}.
+ * 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.

package/lib/factory/statements/createLabeledStatement.js

@@ -4,7 +4,20 @@ exports.createLabeledStatement = void 0;
 const asName_1 = require("../internal/asName");
 const make_1 = require("../internal/make");
 /**
- * Create a {@link LabeledStatement}.
+ * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"createLabeledStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createLabeledStatement.ts"],"names":[],"mappings":";;;AACA,+CAA4C;AAC5C,2CAAwC;AAExC;;;;;;;GAOG;AACI,MAAM,sBAAsB,GAAG,CACpC,KAA0B,EAC1B,SAAoB,EACF,EAAE,CACpB,IAAA,WAAI,EAAC,kBAAkB,EAAE,EAAE,KAAK,EAAE,IAAA,eAAM,EAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC;AAJnD,QAAA,sBAAsB,GAAtB,sBAAsB,CAI6B"}
+{"version":3,"file":"createLabeledStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createLabeledStatement.ts"],"names":[],"mappings":";;;AACA,+CAA4C;AAC5C,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;GAoBG;AACI,MAAM,sBAAsB,GAAG,CACpC,KAA0B,EAC1B,SAAoB,EACF,EAAE,CACpB,IAAA,WAAI,EAAC,kBAAkB,EAAE,EAAE,KAAK,EAAE,IAAA,eAAM,EAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC;AAJnD,QAAA,sBAAsB,GAAtB,sBAAsB,CAI6B"}

package/lib/factory/statements/createLabeledStatement.mjs

@@ -3,7 +3,20 @@ exports.createLabeledStatement = void 0;
 const asName_1 = require("../internal/asName");
 const make_1 = require("../internal/make");
 /**
- * Create a {@link LabeledStatement}.
+ * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"createLabeledStatement.mjs","sources":["createLabeledStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createLabeledStatement = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link LabeledStatement}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param label The label.\n * @param statement The statement.\n * @returns The created {@link LabeledStatement}.\n */\nconst createLabeledStatement = (label, statement) => (0, make_1.make)(\"LabeledStatement\", { label: (0, asName_1.asName)(label), statement });\nexports.createLabeledStatement = createLabeledStatement;\n//# sourceMappingURL=createLabeledStatement.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,sBAAsB,GAAG,MAAM;AACvC,MAAM,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC;AAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,sBAAsB,GAAG,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,EAAE,KAAK,EAAE,IAAI,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC;AAC5I,OAAO,CAAC,sBAAsB,GAAG,sBAAsB"}
+{"version":3,"file":"createLabeledStatement.mjs","sources":["createLabeledStatement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createLabeledStatement = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link LabeledStatement}: a `label: ...` statement.\n *\n * The `label` names the statement so a `break` or `continue` can target it; a\n * string is wrapped into an identifier. The `statement` is the body the label\n * applies to, typically a loop.\n *\n * With a `label` of `outer` and a `statement` of an empty `for` loop that calls\n * `break outer`, the result is:\n *\n * ```ts\n * outer: for (;;) {\n *   break outer;\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param label The label.\n * @param statement The statement.\n * @returns The created {@link LabeledStatement}.\n */\nconst createLabeledStatement = (label, statement) => (0, make_1.make)(\"LabeledStatement\", { label: (0, asName_1.asName)(label), statement });\nexports.createLabeledStatement = createLabeledStatement;\n//# sourceMappingURL=createLabeledStatement.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,sBAAsB,GAAG,MAAM;AACvC,MAAM,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC;AAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,sBAAsB,GAAG,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,EAAE,KAAK,EAAE,IAAI,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC;AAC5I,OAAO,CAAC,sBAAsB,GAAG,sBAAsB"}

package/lib/factory/statements/createNotEmittedStatement.d.ts

@@ -0,0 +1,16 @@
+import type { Node, NotEmittedStatement } from "../../ast";
+/**
+ * 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}.
+ */
+export declare const createNotEmittedStatement: (original?: Node) => NotEmittedStatement;

package/lib/factory/statements/createNotEmittedStatement.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createNotEmittedStatement.js","sourceRoot":"","sources":["../../../src/factory/statements/createNotEmittedStatement.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;;;;;;GAaG;AACI,MAAM,yBAAyB,GAAG,CACvC,QAAe,EACM,EAAE,CAAC,IAAA,WAAI,EAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;AAFvD,QAAA,yBAAyB,GAAzB,yBAAyB,CAE8B"}