@ttsc/factory 0.15.9 → 0.15.10

package/lib/factory/jsx/createJsxText.mjs

@@ -0,0 +1,31 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JsxText}: a run of literal text appearing as a child between
+ * JSX tags.
+ *
+ * The `text` is the raw character content, written verbatim with no quoting or
+ * escaping. The `containsOnlyTriviaWhiteSpaces` flag marks text that is nothing
+ * but insignificant whitespace (spaces, tabs, newlines between tags); it is
+ * coerced to a boolean and defaults to `false`. The flag does not change the
+ * printed characters; it records whether the run is meaningful content.
+ *
+ * Given the text `Hello`, the printer emits:
+ *
+ * ```tsx
+ * Hello;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The text.
+ * @param containsOnlyTriviaWhiteSpaces Whether the text contains only trivia
+ *   whitespace.
+ * @returns The created {@link JsxText}.
+ */
+const createJsxText = (text, containsOnlyTriviaWhiteSpaces) => make("JsxText", {
+    text,
+    containsOnlyTriviaWhiteSpaces: !!containsOnlyTriviaWhiteSpaces,
+});
+
+export { createJsxText };
+//# sourceMappingURL=createJsxText.mjs.map

package/lib/factory/jsx/createJsxText.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJsxText.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxText.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxText}: a run of literal text appearing as a child between\n * JSX tags.\n *\n * The `text` is the raw character content, written verbatim with no quoting or\n * escaping. The `containsOnlyTriviaWhiteSpaces` flag marks text that is nothing\n * but insignificant whitespace (spaces, tabs, newlines between tags); it is\n * coerced to a boolean and defaults to `false`. The flag does not change the\n * printed characters; it records whether the run is meaningful content.\n *\n * Given the text `Hello`, the printer emits:\n *\n * ```tsx\n * Hello;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The text.\n * @param containsOnlyTriviaWhiteSpaces Whether the text contains only trivia\n *   whitespace.\n * @returns The created {@link JsxText}.\n */\nexport const createJsxText = (text, containsOnlyTriviaWhiteSpaces) => make(\"JsxText\", {\n    text,\n    containsOnlyTriviaWhiteSpaces: !!containsOnlyTriviaWhiteSpaces,\n});\n//# sourceMappingURL=createJsxText.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,aAAa,GAAG,CAAC,IAAI,EAAE,6BAA6B,KAAK,IAAI,CAAC,SAAS,EAAE;AACtF,IAAI,IAAI;AACR,IAAI,6BAA6B,EAAE,CAAC,CAAC,6BAA6B;AAClE,CAAC;;;;"}

package/lib/factory/literals/createBigIntLiteral.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link BigIntLiteral}: a `bigint` literal expression.
+ *
+ * The `value` is the digit text of the literal. The trailing `n` suffix is
+ * appended automatically when it is missing, so both `123` and `123n` produce
+ * the same node.
+ *
+ * With `value` of `123`, this prints:
+ *
+ * ```ts
+ * 123n;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param value The literal value.
+ * @returns The created {@link BigIntLiteral}.
+ */
+const createBigIntLiteral = (value) => make("BigIntLiteral", { text: value.endsWith("n") ? value : `${value}n` });
+
+export { createBigIntLiteral };
+//# sourceMappingURL=createBigIntLiteral.mjs.map

package/lib/factory/literals/createBigIntLiteral.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBigIntLiteral.mjs","sources":["../../../esm-tmp/factory/literals/createBigIntLiteral.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link BigIntLiteral}: a `bigint` literal expression.\n *\n * The `value` is the digit text of the literal. The trailing `n` suffix is\n * appended automatically when it is missing, so both `123` and `123n` produce\n * the same node.\n *\n * With `value` of `123`, this prints:\n *\n * ```ts\n * 123n;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param value The literal value.\n * @returns The created {@link BigIntLiteral}.\n */\nexport const createBigIntLiteral = (value) => make(\"BigIntLiteral\", { text: value.endsWith(\"n\") ? value : `${value}n` });\n//# sourceMappingURL=createBigIntLiteral.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,KAAK,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE;;;;"}

package/lib/factory/literals/createNoSubstitutionTemplateLiteral.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link NoSubstitutionTemplateLiteral}: a backtick template string
+ * with no `${...}` substitutions.
+ *
+ * The `text` is the literal content between the backticks. Because there are no
+ * placeholders, the whole literal is a single span and the printer wraps the
+ * content in backticks unchanged.
+ *
+ * With `text` of `hello`, this prints:
+ *
+ * ```ts
+ * `hello`;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The text.
+ * @returns The created node.
+ */
+const createNoSubstitutionTemplateLiteral = (text) => make("NoSubstitutionTemplateLiteral", { text });
+
+export { createNoSubstitutionTemplateLiteral };
+//# sourceMappingURL=createNoSubstitutionTemplateLiteral.mjs.map

package/lib/factory/literals/createNoSubstitutionTemplateLiteral.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNoSubstitutionTemplateLiteral.mjs","sources":["../../../esm-tmp/factory/literals/createNoSubstitutionTemplateLiteral.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link NoSubstitutionTemplateLiteral}: a backtick template string\n * with no `${...}` substitutions.\n *\n * The `text` is the literal content between the backticks. Because there are no\n * placeholders, the whole literal is a single span and the printer wraps the\n * content in backticks unchanged.\n *\n * With `text` of `hello`, this prints:\n *\n * ```ts\n * `hello`;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The text.\n * @returns The created node.\n */\nexport const createNoSubstitutionTemplateLiteral = (text) => make(\"NoSubstitutionTemplateLiteral\", { text });\n//# sourceMappingURL=createNoSubstitutionTemplateLiteral.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mCAAmC,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,+BAA+B,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/literals/createNumericLiteral.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link NumericLiteral}: a numeric literal expression.
+ *
+ * The `value` accepts either a number or a string. It is coerced to its string
+ * form and stored verbatim, so the printer emits exactly that text. Passing a
+ * string lets you preserve a specific spelling such as `0xff` or `1_000`.
+ *
+ * With `value` of `42`, this prints:
+ *
+ * ```ts
+ * 42;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param value The literal value.
+ * @returns The created {@link NumericLiteral}.
+ */
+const createNumericLiteral = (value) => make("NumericLiteral", { text: String(value) });
+
+export { createNumericLiteral };
+//# sourceMappingURL=createNumericLiteral.mjs.map

package/lib/factory/literals/createNumericLiteral.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNumericLiteral.mjs","sources":["../../../esm-tmp/factory/literals/createNumericLiteral.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link NumericLiteral}: a numeric literal expression.\n *\n * The `value` accepts either a number or a string. It is coerced to its string\n * form and stored verbatim, so the printer emits exactly that text. Passing a\n * string lets you preserve a specific spelling such as `0xff` or `1_000`.\n *\n * With `value` of `42`, this prints:\n *\n * ```ts\n * 42;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param value The literal value.\n * @returns The created {@link NumericLiteral}.\n */\nexport const createNumericLiteral = (value) => make(\"NumericLiteral\", { text: String(value) });\n//# sourceMappingURL=createNumericLiteral.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,CAAC,KAAK,KAAK,IAAI,CAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE;;;;"}

package/lib/factory/literals/createStringLiteral.mjs

@@ -0,0 +1,29 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link StringLiteral}: a quoted string literal expression.
+ *
+ * The `text` is the raw, unescaped content of the string. By default the
+ * printer wraps it in double quotes; pass `isSingleQuote` as `true` to wrap it
+ * in single quotes instead.
+ *
+ * The printer escapes the active quote character inside the content. With
+ * double quotes, an embedded `"` is emitted as `\"`; with single quotes, an
+ * embedded `'` is emitted as `\'`. The other quote character is left
+ * untouched.
+ *
+ * With `text` of `he said "hi"` and the default quoting, this prints:
+ *
+ * ```ts
+ * "he said \"hi\"";
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The textual content.
+ * @param isSingleQuote When `true`, use single quotes instead of double.
+ * @returns The created {@link StringLiteral}.
+ */
+const createStringLiteral = (text, isSingleQuote) => make("StringLiteral", { text, singleQuote: isSingleQuote });
+
+export { createStringLiteral };
+//# sourceMappingURL=createStringLiteral.mjs.map

package/lib/factory/literals/createStringLiteral.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStringLiteral.mjs","sources":["../../../esm-tmp/factory/literals/createStringLiteral.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link StringLiteral}: a quoted string literal expression.\n *\n * The `text` is the raw, unescaped content of the string. By default the\n * printer wraps it in double quotes; pass `isSingleQuote` as `true` to wrap it\n * in single quotes instead.\n *\n * The printer escapes the active quote character inside the content. With\n * double quotes, an embedded `\"` is emitted as `\\\"`; with single quotes, an\n * embedded `'` is emitted as `\\'`. The other quote character is left\n * untouched.\n *\n * With `text` of `he said \"hi\"` and the default quoting, this prints:\n *\n * ```ts\n * \"he said \\\"hi\\\"\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The textual content.\n * @param isSingleQuote When `true`, use single quotes instead of double.\n * @returns The created {@link StringLiteral}.\n */\nexport const createStringLiteral = (text, isSingleQuote) => make(\"StringLiteral\", { text, singleQuote: isSingleQuote });\n//# sourceMappingURL=createStringLiteral.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,mBAAmB,GAAG,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,aAAa,EAAE;;;;"}

package/lib/factory/literals/createStringLiteralFromNode.mjs

@@ -0,0 +1,25 @@
+import { createStringLiteral } from './createStringLiteral.mjs';
+
+/**
+ * Create a {@link StringLiteral} whose content is copied from an existing name
+ * or literal node.
+ *
+ * The `sourceNode` may be an {@link Identifier}, a {@link PrivateIdentifier}, a
+ * {@link StringLiteral}, or a {@link NumericLiteral}. Its `text` is read and
+ * handed to {@link createStringLiteral}, so the result is double-quoted by
+ * default and the quote-escaping rules of that factory apply.
+ *
+ * With a `sourceNode` identifier named `foo`, this prints:
+ *
+ * ```ts
+ * "foo";
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param sourceNode The node to derive the text from.
+ * @returns The created {@link StringLiteral}.
+ */
+const createStringLiteralFromNode = (sourceNode) => createStringLiteral(sourceNode.text);
+
+export { createStringLiteralFromNode };
+//# sourceMappingURL=createStringLiteralFromNode.mjs.map

package/lib/factory/literals/createStringLiteralFromNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStringLiteralFromNode.mjs","sources":["../../../esm-tmp/factory/literals/createStringLiteralFromNode.js"],"sourcesContent":["import { createStringLiteral } from \"./createStringLiteral\";\n/**\n * Create a {@link StringLiteral} whose content is copied from an existing name\n * or literal node.\n *\n * The `sourceNode` may be an {@link Identifier}, a {@link PrivateIdentifier}, a\n * {@link StringLiteral}, or a {@link NumericLiteral}. Its `text` is read and\n * handed to {@link createStringLiteral}, so the result is double-quoted by\n * default and the quote-escaping rules of that factory apply.\n *\n * With a `sourceNode` identifier named `foo`, this prints:\n *\n * ```ts\n * \"foo\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param sourceNode The node to derive the text from.\n * @returns The created {@link StringLiteral}.\n */\nexport const createStringLiteralFromNode = (sourceNode) => createStringLiteral(sourceNode.text);\n//# sourceMappingURL=createStringLiteralFromNode.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,2BAA2B,GAAG,CAAC,UAAU,KAAK,mBAAmB,CAAC,UAAU,CAAC,IAAI;;;;"}

package/lib/factory/literals/createTemplateHead.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TemplateHead}: the opening span of a template expression, from
+ * the leading backtick up to the first `${`.
+ *
+ * The `text` is the cooked content of that span. The optional `rawText` carries
+ * the source spelling before escape processing; when omitted, the cooked text
+ * is used. A head is not a complete expression on its own, it is one piece of a
+ * larger template literal.
+ *
+ * The printer emits the opening backtick, the content, then the `${` that opens
+ * the first substitution. With `text` of `head`, this prints:
+ *
+ * ```ts
+ * `head${
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The text.
+ * @param rawText The rawText.
+ * @returns The created node.
+ */
+const createTemplateHead = (text, rawText) => make("TemplateHead", { text, rawText });
+
+export { createTemplateHead };
+//# sourceMappingURL=createTemplateHead.mjs.map

package/lib/factory/literals/createTemplateHead.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTemplateHead.mjs","sources":["../../../esm-tmp/factory/literals/createTemplateHead.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TemplateHead}: the opening span of a template expression, from\n * the leading backtick up to the first `${`.\n *\n * The `text` is the cooked content of that span. The optional `rawText` carries\n * the source spelling before escape processing; when omitted, the cooked text\n * is used. A head is not a complete expression on its own, it is one piece of a\n * larger template literal.\n *\n * The printer emits the opening backtick, the content, then the `${` that opens\n * the first substitution. With `text` of `head`, this prints:\n *\n * ```ts\n * `head${\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The text.\n * @param rawText The rawText.\n * @returns The created node.\n */\nexport const createTemplateHead = (text, rawText) => make(\"TemplateHead\", { text, rawText });\n//# sourceMappingURL=createTemplateHead.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,kBAAkB,GAAG,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/literals/createTemplateMiddle.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TemplateMiddle}: a span of a template expression that sits
+ * between two substitutions, from one `}` to the next `${`.
+ *
+ * The `text` is the cooked content of that span. A middle span only appears in
+ * a template literal that has two or more substitutions, and it is one piece of
+ * that larger literal rather than a complete expression.
+ *
+ * The printer emits the closing `}` of the preceding substitution, the content,
+ * then the `${` that opens the next one. With `text` of `mid`, this prints:
+ *
+ * ```ts
+ * }mid${
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The text.
+ * @returns The created node.
+ */
+const createTemplateMiddle = (text) => make("TemplateMiddle", { text });
+
+export { createTemplateMiddle };
+//# sourceMappingURL=createTemplateMiddle.mjs.map

package/lib/factory/literals/createTemplateMiddle.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTemplateMiddle.mjs","sources":["../../../esm-tmp/factory/literals/createTemplateMiddle.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TemplateMiddle}: a span of a template expression that sits\n * between two substitutions, from one `}` to the next `${`.\n *\n * The `text` is the cooked content of that span. A middle span only appears in\n * a template literal that has two or more substitutions, and it is one piece of\n * that larger literal rather than a complete expression.\n *\n * The printer emits the closing `}` of the preceding substitution, the content,\n * then the `${` that opens the next one. With `text` of `mid`, this prints:\n *\n * ```ts\n * }mid${\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The text.\n * @returns The created node.\n */\nexport const createTemplateMiddle = (text) => make(\"TemplateMiddle\", { text });\n//# sourceMappingURL=createTemplateMiddle.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,oBAAoB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/literals/createTemplateTail.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TemplateTail}: the closing span of a template expression, from
+ * the last `}` to the trailing backtick.
+ *
+ * The `text` is the cooked content of that span. A tail closes a template
+ * literal that has at least one substitution, and it is one piece of that
+ * larger literal rather than a complete expression.
+ *
+ * The printer emits the closing `}` of the final substitution, the content,
+ * then the trailing backtick. With `text` of `tail`, this prints:
+ *
+ * ```ts
+ * }tail`
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The text.
+ * @returns The created node.
+ */
+const createTemplateTail = (text) => make("TemplateTail", { text });
+
+export { createTemplateTail };
+//# sourceMappingURL=createTemplateTail.mjs.map

package/lib/factory/literals/createTemplateTail.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTemplateTail.mjs","sources":["../../../esm-tmp/factory/literals/createTemplateTail.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TemplateTail}: the closing span of a template expression, from\n * the last `}` to the trailing backtick.\n *\n * The `text` is the cooked content of that span. A tail closes a template\n * literal that has at least one substitution, and it is one piece of that\n * larger literal rather than a complete expression.\n *\n * The printer emits the closing `}` of the final substitution, the content,\n * then the trailing backtick. With `text` of `tail`, this prints:\n *\n * ```ts\n * }tail`\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The text.\n * @returns The created node.\n */\nexport const createTemplateTail = (text) => make(\"TemplateTail\", { text });\n//# sourceMappingURL=createTemplateTail.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,kBAAkB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/names/createDecorator.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link Decorator}: an `@expression` attached to a declaration.
+ *
+ * The `expression` is the decorator body, commonly an identifier or a call
+ * expression. The printer prefixes it with `@` and emits the expression as
+ * given; it does not add the surrounding declaration.
+ *
+ * With `expression` of an identifier named `deco`, this prints:
+ *
+ * ```ts
+ * @deco
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The expression.
+ * @returns The created {@link Decorator}.
+ */
+const createDecorator = (expression) => make("Decorator", { expression });
+
+export { createDecorator };
+//# sourceMappingURL=createDecorator.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createDecorator.mjs","sources":["../../../esm-tmp/factory/names/createDecorator.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link Decorator}: an `@expression` attached to a declaration.\n *\n * The `expression` is the decorator body, commonly an identifier or a call\n * expression. The printer prefixes it with `@` and emits the expression as\n * given; it does not add the surrounding declaration.\n *\n * With `expression` of an identifier named `deco`, this prints:\n *\n * ```ts\n * @deco\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @returns The created {@link Decorator}.\n */\nexport const createDecorator = (expression) => make(\"Decorator\", { expression });\n//# sourceMappingURL=createDecorator.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,eAAe,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,WAAW,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/names/createFalse.mjs

@@ -0,0 +1,22 @@
+import { createToken } from './createToken.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * Create the `false` keyword as a {@link Token}.
+ *
+ * This takes no arguments and wraps the `FalseKeyword` syntax kind. The printer
+ * emits the keyword as the boolean literal `false`.
+ *
+ * This prints:
+ *
+ * ```ts
+ * false;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link Token}.
+ */
+const createFalse = () => createToken(SyntaxKind.FalseKeyword);
+
+export { createFalse };
+//# sourceMappingURL=createFalse.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createFalse.mjs","sources":["../../../esm-tmp/factory/names/createFalse.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createToken } from \"./createToken\";\n/**\n * Create the `false` keyword as a {@link Token}.\n *\n * This takes no arguments and wraps the `FalseKeyword` syntax kind. The printer\n * emits the keyword as the boolean literal `false`.\n *\n * This prints:\n *\n * ```ts\n * false;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link Token}.\n */\nexport const createFalse = () => createToken(SyntaxKind.FalseKeyword);\n//# sourceMappingURL=createFalse.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,WAAW,GAAG,MAAM,WAAW,CAAC,UAAU,CAAC,YAAY;;;;"}

package/lib/factory/names/createIdentifier.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link Identifier}: a bare name reference.
+ *
+ * The `text` is stored verbatim as the identifier name, so the printer emits it
+ * exactly as given. No validation or escaping is applied, the caller is
+ * responsible for passing a valid identifier name.
+ *
+ * With `text` of `foo`, this prints:
+ *
+ * ```ts
+ * foo;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The textual content.
+ * @returns The created {@link Identifier}.
+ */
+const createIdentifier = (text) => make("Identifier", { text });
+
+export { createIdentifier };
+//# sourceMappingURL=createIdentifier.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createIdentifier.mjs","sources":["../../../esm-tmp/factory/names/createIdentifier.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link Identifier}: a bare name reference.\n *\n * The `text` is stored verbatim as the identifier name, so the printer emits it\n * exactly as given. No validation or escaping is applied, the caller is\n * responsible for passing a valid identifier name.\n *\n * With `text` of `foo`, this prints:\n *\n * ```ts\n * foo;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The textual content.\n * @returns The created {@link Identifier}.\n */\nexport const createIdentifier = (text) => make(\"Identifier\", { text });\n//# sourceMappingURL=createIdentifier.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gBAAgB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,YAAY,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/names/createLoopVariable.mjs

@@ -0,0 +1,28 @@
+import { createIdentifier } from './createIdentifier.mjs';
+
+/**
+ * Create a loop variable name as a plain {@link Identifier}.
+ *
+ * The legacy compiler uses a stateful name generator that allocates a fresh,
+ * collision-free identifier. This package is stateless, so this is a simplified
+ * placeholder: it does not track or guarantee uniqueness, it always returns an
+ * identifier named `_i`.
+ *
+ * The `reservedInNestedScopes` parameter belongs to the stateful generator and
+ * is accepted for signature parity but ignored. Because the name is fixed,
+ * nested loops would collide, so the caller must rename as needed.
+ *
+ * With no arguments, this prints:
+ *
+ * ```ts
+ * _i;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param _reservedInNestedScopes Ignored; kept for signature parity.
+ * @returns The created {@link Identifier}.
+ */
+const createLoopVariable = (_reservedInNestedScopes) => createIdentifier("_i");
+
+export { createLoopVariable };
+//# sourceMappingURL=createLoopVariable.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createLoopVariable.mjs","sources":["../../../esm-tmp/factory/names/createLoopVariable.js"],"sourcesContent":["import { createIdentifier } from \"./createIdentifier\";\n/**\n * Create a loop variable name as a plain {@link Identifier}.\n *\n * The legacy compiler uses a stateful name generator that allocates a fresh,\n * collision-free identifier. This package is stateless, so this is a simplified\n * placeholder: it does not track or guarantee uniqueness, it always returns an\n * identifier named `_i`.\n *\n * The `reservedInNestedScopes` parameter belongs to the stateful generator and\n * is accepted for signature parity but ignored. Because the name is fixed,\n * nested loops would collide, so the caller must rename as needed.\n *\n * With no arguments, this prints:\n *\n * ```ts\n * _i;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param _reservedInNestedScopes Ignored; kept for signature parity.\n * @returns The created {@link Identifier}.\n */\nexport const createLoopVariable = (_reservedInNestedScopes) => createIdentifier(\"_i\");\n//# sourceMappingURL=createLoopVariable.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,kBAAkB,GAAG,CAAC,uBAAuB,KAAK,gBAAgB,CAAC,IAAI;;;;"}

package/lib/factory/names/createModifier.mjs

@@ -0,0 +1,25 @@
+import { createToken } from './createToken.mjs';
+
+/**
+ * Create a modifier {@link Token}: a keyword token such as `readonly` or
+ * `export` used in a modifier position.
+ *
+ * The `kind` is the keyword syntax kind to wrap. This forwards straight to
+ * {@link createToken}, so the result is a plain token whose source spelling the
+ * printer emits. The name documents intent, there is no extra modifier-specific
+ * behavior.
+ *
+ * With `kind` of the `readonly` keyword, this prints:
+ *
+ * ```ts
+ * readonly;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param kind The token kind.
+ * @returns The created {@link Token}.
+ */
+const createModifier = (kind) => createToken(kind);
+
+export { createModifier };
+//# sourceMappingURL=createModifier.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createModifier.mjs","sources":["../../../esm-tmp/factory/names/createModifier.js"],"sourcesContent":["import { createToken } from \"./createToken\";\n/**\n * Create a modifier {@link Token}: a keyword token such as `readonly` or\n * `export` used in a modifier position.\n *\n * The `kind` is the keyword syntax kind to wrap. This forwards straight to\n * {@link createToken}, so the result is a plain token whose source spelling the\n * printer emits. The name documents intent, there is no extra modifier-specific\n * behavior.\n *\n * With `kind` of the `readonly` keyword, this prints:\n *\n * ```ts\n * readonly;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param kind The token kind.\n * @returns The created {@link Token}.\n */\nexport const createModifier = (kind) => createToken(kind);\n//# sourceMappingURL=createModifier.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,cAAc,GAAG,CAAC,IAAI,KAAK,WAAW,CAAC,IAAI;;;;"}

package/lib/factory/names/createModifiersFromModifierFlags.mjs

@@ -0,0 +1,81 @@
+import { createModifier } from './createModifier.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * Legacy `ts.ModifierFlags` bit values, kept as module-local constants (not an
+ * exported enum) so callers can pass the same numeric bitmask.
+ */
+const FLAG = {
+    Public: 1,
+    Private: 2,
+    Protected: 4,
+    Readonly: 8,
+    Override: 16,
+    Export: 32,
+    Abstract: 64,
+    Ambient: 128,
+    Static: 256,
+    Accessor: 512,
+    Async: 1024,
+    Default: 2048,
+    Const: 4096,
+    In: 8192,
+};
+/**
+ * Create an ordered list of modifier tokens from a legacy `ts.ModifierFlags`
+ * bitmask.
+ *
+ * The `flags` is read bit by bit, and one modifier token is appended for each
+ * bit that is set. The tokens come out in canonical declaration order
+ * regardless of bit order in the input, so `export` precedes `readonly` no
+ * matter how the mask was assembled. When no recognized bit is set, the result
+ * is `undefined` rather than an empty array.
+ *
+ * The legacy `out` modifier is omitted because this package's `SyntaxKind` has
+ * no `OutKeyword` member.
+ *
+ * With `flags` of `Export | Readonly`, the tokens print in order as:
+ *
+ * ```ts
+ * export readonly
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param flags The modifier flags bitmask (legacy `ts.ModifierFlags`).
+ * @returns The created modifier tokens, or `undefined` when none apply.
+ */
+const createModifiersFromModifierFlags = (flags) => {
+    const result = [];
+    if (flags & FLAG.Export)
+        result.push(createModifier(SyntaxKind.ExportKeyword));
+    if (flags & FLAG.Ambient)
+        result.push(createModifier(SyntaxKind.DeclareKeyword));
+    if (flags & FLAG.Default)
+        result.push(createModifier(SyntaxKind.DefaultKeyword));
+    if (flags & FLAG.Const)
+        result.push(createModifier(SyntaxKind.ConstKeyword));
+    if (flags & FLAG.Public)
+        result.push(createModifier(SyntaxKind.PublicKeyword));
+    if (flags & FLAG.Private)
+        result.push(createModifier(SyntaxKind.PrivateKeyword));
+    if (flags & FLAG.Protected)
+        result.push(createModifier(SyntaxKind.ProtectedKeyword));
+    if (flags & FLAG.Abstract)
+        result.push(createModifier(SyntaxKind.AbstractKeyword));
+    if (flags & FLAG.Static)
+        result.push(createModifier(SyntaxKind.StaticKeyword));
+    if (flags & FLAG.Override)
+        result.push(createModifier(SyntaxKind.OverrideKeyword));
+    if (flags & FLAG.Readonly)
+        result.push(createModifier(SyntaxKind.ReadonlyKeyword));
+    if (flags & FLAG.Accessor)
+        result.push(createModifier(SyntaxKind.AccessorKeyword));
+    if (flags & FLAG.Async)
+        result.push(createModifier(SyntaxKind.AsyncKeyword));
+    if (flags & FLAG.In)
+        result.push(createModifier(SyntaxKind.InKeyword));
+    return result.length ? result : undefined;
+};
+
+export { createModifiersFromModifierFlags };
+//# sourceMappingURL=createModifiersFromModifierFlags.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createModifiersFromModifierFlags.mjs","sources":["../../../esm-tmp/factory/names/createModifiersFromModifierFlags.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createModifier } from \"./createModifier\";\n/**\n * Legacy `ts.ModifierFlags` bit values, kept as module-local constants (not an\n * exported enum) so callers can pass the same numeric bitmask.\n */\nconst FLAG = {\n    Public: 1,\n    Private: 2,\n    Protected: 4,\n    Readonly: 8,\n    Override: 16,\n    Export: 32,\n    Abstract: 64,\n    Ambient: 128,\n    Static: 256,\n    Accessor: 512,\n    Async: 1024,\n    Default: 2048,\n    Const: 4096,\n    In: 8192,\n};\n/**\n * Create an ordered list of modifier tokens from a legacy `ts.ModifierFlags`\n * bitmask.\n *\n * The `flags` is read bit by bit, and one modifier token is appended for each\n * bit that is set. The tokens come out in canonical declaration order\n * regardless of bit order in the input, so `export` precedes `readonly` no\n * matter how the mask was assembled. When no recognized bit is set, the result\n * is `undefined` rather than an empty array.\n *\n * The legacy `out` modifier is omitted because this package's `SyntaxKind` has\n * no `OutKeyword` member.\n *\n * With `flags` of `Export | Readonly`, the tokens print in order as:\n *\n * ```ts\n * export readonly\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param flags The modifier flags bitmask (legacy `ts.ModifierFlags`).\n * @returns The created modifier tokens, or `undefined` when none apply.\n */\nexport const createModifiersFromModifierFlags = (flags) => {\n    const result = [];\n    if (flags & FLAG.Export)\n        result.push(createModifier(SyntaxKind.ExportKeyword));\n    if (flags & FLAG.Ambient)\n        result.push(createModifier(SyntaxKind.DeclareKeyword));\n    if (flags & FLAG.Default)\n        result.push(createModifier(SyntaxKind.DefaultKeyword));\n    if (flags & FLAG.Const)\n        result.push(createModifier(SyntaxKind.ConstKeyword));\n    if (flags & FLAG.Public)\n        result.push(createModifier(SyntaxKind.PublicKeyword));\n    if (flags & FLAG.Private)\n        result.push(createModifier(SyntaxKind.PrivateKeyword));\n    if (flags & FLAG.Protected)\n        result.push(createModifier(SyntaxKind.ProtectedKeyword));\n    if (flags & FLAG.Abstract)\n        result.push(createModifier(SyntaxKind.AbstractKeyword));\n    if (flags & FLAG.Static)\n        result.push(createModifier(SyntaxKind.StaticKeyword));\n    if (flags & FLAG.Override)\n        result.push(createModifier(SyntaxKind.OverrideKeyword));\n    if (flags & FLAG.Readonly)\n        result.push(createModifier(SyntaxKind.ReadonlyKeyword));\n    if (flags & FLAG.Accessor)\n        result.push(createModifier(SyntaxKind.AccessorKeyword));\n    if (flags & FLAG.Async)\n        result.push(createModifier(SyntaxKind.AsyncKeyword));\n    if (flags & FLAG.In)\n        result.push(createModifier(SyntaxKind.InKeyword));\n    return result.length ? result : undefined;\n};\n//# sourceMappingURL=createModifiersFromModifierFlags.js.map"],"names":[],"mappings":"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"}

package/lib/factory/names/createNull.mjs

@@ -0,0 +1,22 @@
+import { createToken } from './createToken.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * Create the `null` keyword as a {@link Token}.
+ *
+ * This takes no arguments and wraps the `NullKeyword` syntax kind. The printer
+ * emits the keyword as the `null` literal.
+ *
+ * This prints:
+ *
+ * ```ts
+ * null;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link Token}.
+ */
+const createNull = () => createToken(SyntaxKind.NullKeyword);
+
+export { createNull };
+//# sourceMappingURL=createNull.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createNull.mjs","sources":["../../../esm-tmp/factory/names/createNull.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createToken } from \"./createToken\";\n/**\n * Create the `null` keyword as a {@link Token}.\n *\n * This takes no arguments and wraps the `NullKeyword` syntax kind. The printer\n * emits the keyword as the `null` literal.\n *\n * This prints:\n *\n * ```ts\n * null;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link Token}.\n */\nexport const createNull = () => createToken(SyntaxKind.NullKeyword);\n//# sourceMappingURL=createNull.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,UAAU,GAAG,MAAM,WAAW,CAAC,UAAU,CAAC,WAAW;;;;"}

package/lib/factory/names/createPrivateIdentifier.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link PrivateIdentifier}: a class private name beginning with `#`.
+ *
+ * The `text` is the name content. The leading `#` is added automatically when
+ * it is missing, so both `secret` and `#secret` yield the same node. The
+ * printer emits the name with exactly one `#`.
+ *
+ * With `text` of `secret`, this prints:
+ *
+ * ```ts
+ * #secret;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The textual content.
+ * @returns The created {@link PrivateIdentifier}.
+ */
+const createPrivateIdentifier = (text) => make("PrivateIdentifier", { text: text.startsWith("#") ? text : `#${text}` });
+
+export { createPrivateIdentifier };
+//# sourceMappingURL=createPrivateIdentifier.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPrivateIdentifier.mjs","sources":["../../../esm-tmp/factory/names/createPrivateIdentifier.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link PrivateIdentifier}: a class private name beginning with `#`.\n *\n * The `text` is the name content. The leading `#` is added automatically when\n * it is missing, so both `secret` and `#secret` yield the same node. The\n * printer emits the name with exactly one `#`.\n *\n * With `text` of `secret`, this prints:\n *\n * ```ts\n * #secret;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The textual content.\n * @returns The created {@link PrivateIdentifier}.\n */\nexport const createPrivateIdentifier = (text) => make(\"PrivateIdentifier\", { text: text.startsWith(\"#\") ? text : `#${text}` });\n//# sourceMappingURL=createPrivateIdentifier.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,mBAAmB,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE;;;;"}

package/lib/factory/names/createQualifiedName.mjs

@@ -0,0 +1,28 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link QualifiedName}: a dotted name path such as `A.b` used in type
+ * positions.
+ *
+ * The `left` is an entity name, either a single identifier or a nested
+ * qualified name, which lets you chain segments like `A.B.c`. The `right` is
+ * the final segment, accepted as a string or an {@link Identifier}; a string is
+ * wrapped into an identifier automatically. The printer joins the two sides
+ * with a dot.
+ *
+ * With `left` of `A` and `right` of `b`, this prints:
+ *
+ * ```ts
+ * A.b;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param left The left-hand operand.
+ * @param right The right-hand operand.
+ * @returns The created {@link QualifiedName}.
+ */
+const createQualifiedName = (left, right) => make("QualifiedName", { left, right: asName(right) });
+
+export { createQualifiedName };
+//# sourceMappingURL=createQualifiedName.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createQualifiedName.mjs","sources":["../../../esm-tmp/factory/names/createQualifiedName.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link QualifiedName}: a dotted name path such as `A.b` used in type\n * positions.\n *\n * The `left` is an entity name, either a single identifier or a nested\n * qualified name, which lets you chain segments like `A.B.c`. The `right` is\n * the final segment, accepted as a string or an {@link Identifier}; a string is\n * wrapped into an identifier automatically. The printer joins the two sides\n * with a dot.\n *\n * With `left` of `A` and `right` of `b`, this prints:\n *\n * ```ts\n * A.b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param left The left-hand operand.\n * @param right The right-hand operand.\n * @returns The created {@link QualifiedName}.\n */\nexport const createQualifiedName = (left, right) => make(\"QualifiedName\", { left, right: asName(right) });\n//# sourceMappingURL=createQualifiedName.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,mBAAmB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE;;;;"}