@ttsc/factory 0.15.9 → 0.15.10

package/lib/factory/types/createRestTypeNode.mjs

@@ -0,0 +1,22 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link RestTypeNode}: a `...T` rest element inside a tuple type.
+ *
+ * A leading `...` prints in front of the type. This form is only valid in tuple
+ * element position, for example `[string, ...number[]]`.
+ *
+ * Given a `string[]` element type, the printer renders:
+ *
+ * ```ts
+ * ...string[]
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The rest element type.
+ * @returns The created {@link RestTypeNode}.
+ */
+const createRestTypeNode = (type) => make("RestTypeNode", { type });
+
+export { createRestTypeNode };
+//# sourceMappingURL=createRestTypeNode.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createRestTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createRestTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link RestTypeNode}: a `...T` rest element inside a tuple type.\n *\n * A leading `...` prints in front of the type. This form is only valid in tuple\n * element position, for example `[string, ...number[]]`.\n *\n * Given a `string[]` element type, the printer renders:\n *\n * ```ts\n * ...string[]\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The rest element type.\n * @returns The created {@link RestTypeNode}.\n */\nexport const createRestTypeNode = (type) => make(\"RestTypeNode\", { type });\n//# sourceMappingURL=createRestTypeNode.js.map"],"names":[],"mappings":";;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/types/createTemplateLiteralType.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TemplateLiteralTypeNode}: a ``id-${string}`` template literal
+ * type.
+ *
+ * The head supplies the leading text up to the first `${`, then each span
+ * contributes an interpolated type followed by the literal text up to the next
+ * `${` or the closing backtick. The spans print back to back, so the whole
+ * thing reads as one template string.
+ *
+ * Given the head text `id-` and a single span of `string` ending the template,
+ * the printer renders:
+ *
+ * ```ts
+ * `id-${string}`;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param head The leading text up to the first interpolation.
+ * @param templateSpans The interpolated spans.
+ * @returns The created {@link TemplateLiteralTypeNode}.
+ */
+const createTemplateLiteralType = (head, templateSpans) => make("TemplateLiteralType", { head, templateSpans });
+
+export { createTemplateLiteralType };
+//# sourceMappingURL=createTemplateLiteralType.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTemplateLiteralType.mjs","sources":["../../../esm-tmp/factory/types/createTemplateLiteralType.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TemplateLiteralTypeNode}: a ``id-${string}`` template literal\n * type.\n *\n * The head supplies the leading text up to the first `${`, then each span\n * contributes an interpolated type followed by the literal text up to the next\n * `${` or the closing backtick. The spans print back to back, so the whole\n * thing reads as one template string.\n *\n * Given the head text `id-` and a single span of `string` ending the template,\n * the printer renders:\n *\n * ```ts\n * `id-${string}`;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param head The leading text up to the first interpolation.\n * @param templateSpans The interpolated spans.\n * @returns The created {@link TemplateLiteralTypeNode}.\n */\nexport const createTemplateLiteralType = (head, templateSpans) => make(\"TemplateLiteralType\", { head, templateSpans });\n//# sourceMappingURL=createTemplateLiteralType.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,yBAAyB,GAAG,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC,qBAAqB,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE;;;;"}

package/lib/factory/types/createTemplateLiteralTypeSpan.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TemplateLiteralTypeSpan}: one interpolation of a template
+ * literal type, an interpolated type plus the literal text that follows it.
+ *
+ * The type prints first, then the trailing literal. The literal is a
+ * {@link TemplateMiddle} when another span follows and a {@link TemplateTail}
+ * when it closes the template. A span only renders meaningfully inside a
+ * template literal type; on its own it is just a fragment.
+ *
+ * Given a `number` type and a `px` tail inside a ``width:${...}`` template, the
+ * printer renders:
+ *
+ * ```ts
+ * `width:${number}px`;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The interpolated type.
+ * @param literal The trailing middle or tail literal.
+ * @returns The created {@link TemplateLiteralTypeSpan}.
+ */
+const createTemplateLiteralTypeSpan = (type, literal) => make("TemplateLiteralTypeSpan", { type, literal });
+
+export { createTemplateLiteralTypeSpan };
+//# sourceMappingURL=createTemplateLiteralTypeSpan.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTemplateLiteralTypeSpan.mjs","sources":["../../../esm-tmp/factory/types/createTemplateLiteralTypeSpan.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TemplateLiteralTypeSpan}: one interpolation of a template\n * literal type, an interpolated type plus the literal text that follows it.\n *\n * The type prints first, then the trailing literal. The literal is a\n * {@link TemplateMiddle} when another span follows and a {@link TemplateTail}\n * when it closes the template. A span only renders meaningfully inside a\n * template literal type; on its own it is just a fragment.\n *\n * Given a `number` type and a `px` tail inside a ``width:${...}`` template, the\n * printer renders:\n *\n * ```ts\n * `width:${number}px`;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The interpolated type.\n * @param literal The trailing middle or tail literal.\n * @returns The created {@link TemplateLiteralTypeSpan}.\n */\nexport const createTemplateLiteralTypeSpan = (type, literal) => make(\"TemplateLiteralTypeSpan\", { type, literal });\n//# sourceMappingURL=createTemplateLiteralTypeSpan.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,6BAA6B,GAAG,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC,yBAAyB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/types/createThisTypeNode.mjs

@@ -0,0 +1,22 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ThisTypeNode}: the `this` type.
+ *
+ * It takes no inputs and the printer always emits the single keyword `this`,
+ * the polymorphic this-type used in fluent method return positions and type
+ * predicates.
+ *
+ * The printer renders:
+ *
+ * ```ts
+ * this;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link ThisTypeNode}.
+ */
+const createThisTypeNode = () => make("ThisTypeNode", {});
+
+export { createThisTypeNode };
+//# sourceMappingURL=createThisTypeNode.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createThisTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createThisTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ThisTypeNode}: the `this` type.\n *\n * It takes no inputs and the printer always emits the single keyword `this`,\n * the polymorphic this-type used in fluent method return positions and type\n * predicates.\n *\n * The printer renders:\n *\n * ```ts\n * this;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link ThisTypeNode}.\n */\nexport const createThisTypeNode = () => make(\"ThisTypeNode\", {});\n//# sourceMappingURL=createThisTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,MAAM,IAAI,CAAC,cAAc,EAAE,EAAE;;;;"}

package/lib/factory/types/createTupleTypeNode.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TupleTypeNode}: a `[A, B]` tuple type.
+ *
+ * The elements print inside `[...]`, comma separated. The list is width-aware:
+ * inline it stays on one line with no trailing comma, and when it breaks each
+ * element goes on its own line with a trailing comma after the last. Elements
+ * may include named, optional, and rest members.
+ *
+ * Given the elements `string` and `number`, the printer renders:
+ *
+ * ```ts
+ * [string, number];
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param elements The tuple element types.
+ * @returns The created {@link TupleTypeNode}.
+ */
+const createTupleTypeNode = (elements) => make("TupleTypeNode", { elements });
+
+export { createTupleTypeNode };
+//# sourceMappingURL=createTupleTypeNode.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTupleTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createTupleTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TupleTypeNode}: a `[A, B]` tuple type.\n *\n * The elements print inside `[...]`, comma separated. The list is width-aware:\n * inline it stays on one line with no trailing comma, and when it breaks each\n * element goes on its own line with a trailing comma after the last. Elements\n * may include named, optional, and rest members.\n *\n * Given the elements `string` and `number`, the printer renders:\n *\n * ```ts\n * [string, number];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elements The tuple element types.\n * @returns The created {@link TupleTypeNode}.\n */\nexport const createTupleTypeNode = (elements) => make(\"TupleTypeNode\", { elements });\n//# sourceMappingURL=createTupleTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,QAAQ,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/types/createTypeLiteralNode.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TypeLiteralNode}: an inline object type such as `{ name:
+ * string }`.
+ *
+ * The members print inside `{ ... }` and may be any type element: property and
+ * method signatures, index and call signatures, and so on. The member block is
+ * width-aware, staying inline when it fits and breaking onto separate lines
+ * when it does not. The member list defaults to empty, which renders as `{}`.
+ *
+ * Given a single `name: string` property, the printer renders:
+ *
+ * ```ts
+ * { name: string }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param members The type members.
+ * @returns The created {@link TypeLiteralNode}.
+ */
+const createTypeLiteralNode = (members = []) => make("TypeLiteralNode", { members });
+
+export { createTypeLiteralNode };
+//# sourceMappingURL=createTypeLiteralNode.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeLiteralNode.mjs","sources":["../../../esm-tmp/factory/types/createTypeLiteralNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TypeLiteralNode}: an inline object type such as `{ name:\n * string }`.\n *\n * The members print inside `{ ... }` and may be any type element: property and\n * method signatures, index and call signatures, and so on. The member block is\n * width-aware, staying inline when it fits and breaking onto separate lines\n * when it does not. The member list defaults to empty, which renders as `{}`.\n *\n * Given a single `name: string` property, the printer renders:\n *\n * ```ts\n * { name: string }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param members The type members.\n * @returns The created {@link TypeLiteralNode}.\n */\nexport const createTypeLiteralNode = (members = []) => make(\"TypeLiteralNode\", { members });\n//# sourceMappingURL=createTypeLiteralNode.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,qBAAqB,GAAG,CAAC,OAAO,GAAG,EAAE,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/types/createTypeOperatorNode.mjs

@@ -0,0 +1,26 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TypeOperatorNode}: a prefix type operator such as `keyof T`,
+ * `typeof x`, `readonly T[]`, or `unique symbol`.
+ *
+ * The operator keyword prints first, then a space, then the operand type. In
+ * postfix and array positions the surrounding printer wraps the operator type
+ * in parentheses so the operator does not bind to the postfix instead of the
+ * operand.
+ *
+ * Given the `KeyOfKeyword` operator and a `T` operand, the printer renders:
+ *
+ * ```ts
+ * keyof T
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param operator The operator token.
+ * @param type The operand type.
+ * @returns The created {@link TypeOperatorNode}.
+ */
+const createTypeOperatorNode = (operator, type) => make("TypeOperatorNode", { operator, type });
+
+export { createTypeOperatorNode };
+//# sourceMappingURL=createTypeOperatorNode.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeOperatorNode.mjs","sources":["../../../esm-tmp/factory/types/createTypeOperatorNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TypeOperatorNode}: a prefix type operator such as `keyof T`,\n * `typeof x`, `readonly T[]`, or `unique symbol`.\n *\n * The operator keyword prints first, then a space, then the operand type. In\n * postfix and array positions the surrounding printer wraps the operator type\n * in parentheses so the operator does not bind to the postfix instead of the\n * operand.\n *\n * Given the `KeyOfKeyword` operator and a `T` operand, the printer renders:\n *\n * ```ts\n * keyof T\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param operator The operator token.\n * @param type The operand type.\n * @returns The created {@link TypeOperatorNode}.\n */\nexport const createTypeOperatorNode = (operator, type) => make(\"TypeOperatorNode\", { operator, type });\n//# sourceMappingURL=createTypeOperatorNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,QAAQ,EAAE,IAAI,KAAK,IAAI,CAAC,kBAAkB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createTypeParameterDeclaration.mjs

@@ -0,0 +1,34 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TypeParameterDeclaration}: a generic parameter such as `T
+ * extends string = number`.
+ *
+ * Any modifiers print first (for example `const`, `in`, `out`), then the name.
+ * A constraint adds ` extends Type` and a default adds ` = Type`, each only
+ * when present. A string name is normalized to an identifier.
+ *
+ * Given the name `T`, a `string` constraint, and a `number` default, the
+ * printer renders:
+ *
+ * ```ts
+ * T extends string = number
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param name The parameter name.
+ * @param constraint The `extends` constraint, if any.
+ * @param defaultType The default type, if any.
+ * @returns The created {@link TypeParameterDeclaration}.
+ */
+const createTypeParameterDeclaration = (modifiers, name, constraint, defaultType) => make("TypeParameterDeclaration", {
+    modifiers,
+    name: asName(name),
+    constraint,
+    default: defaultType,
+});
+
+export { createTypeParameterDeclaration };
+//# sourceMappingURL=createTypeParameterDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeParameterDeclaration.mjs","sources":["../../../esm-tmp/factory/types/createTypeParameterDeclaration.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link TypeParameterDeclaration}: a generic parameter such as `T\n * extends string = number`.\n *\n * Any modifiers print first (for example `const`, `in`, `out`), then the name.\n * A constraint adds ` extends Type` and a default adds ` = Type`, each only\n * when present. A string name is normalized to an identifier.\n *\n * Given the name `T`, a `string` constraint, and a `number` default, the\n * printer renders:\n *\n * ```ts\n * T extends string = number\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The parameter name.\n * @param constraint The `extends` constraint, if any.\n * @param defaultType The default type, if any.\n * @returns The created {@link TypeParameterDeclaration}.\n */\nexport const createTypeParameterDeclaration = (modifiers, name, constraint, defaultType) => make(\"TypeParameterDeclaration\", {\n    modifiers,\n    name: asName(name),\n    constraint,\n    default: defaultType,\n});\n//# sourceMappingURL=createTypeParameterDeclaration.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,8BAA8B,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,KAAK,IAAI,CAAC,0BAA0B,EAAE;AAC7H,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;AACtB,IAAI,UAAU;AACd,IAAI,OAAO,EAAE,WAAW;AACxB,CAAC;;;;"}

package/lib/factory/types/createTypePredicateNode.mjs

@@ -0,0 +1,35 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link TypePredicateNode}: a `x is T` type guard return type, or an
+ * `asserts x is T` / `asserts x` assertion form.
+ *
+ * A leading `asserts ` prints when the asserts modifier is present, then the
+ * parameter name, then ` is Type` when a type is present. The assertion form
+ * with no type (just `asserts x`) is produced by passing the modifier and
+ * omitting the type. A string parameter name is normalized to an identifier.
+ *
+ * Given no asserts modifier, parameter `x`, and a `string` type, the printer
+ * renders:
+ *
+ * ```ts
+ * x is string
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param assertsModifier The `asserts` modifier, if any.
+ * @param parameterName The guarded parameter name, or `this`.
+ * @param type The narrowed type, if any.
+ * @returns The created {@link TypePredicateNode}.
+ */
+const createTypePredicateNode = (assertsModifier, parameterName, type) => make("TypePredicateNode", {
+    assertsModifier,
+    parameterName: typeof parameterName === "string"
+        ? createIdentifier(parameterName)
+        : parameterName,
+    type,
+});
+
+export { createTypePredicateNode };
+//# sourceMappingURL=createTypePredicateNode.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTypePredicateNode.mjs","sources":["../../../esm-tmp/factory/types/createTypePredicateNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link TypePredicateNode}: a `x is T` type guard return type, or an\n * `asserts x is T` / `asserts x` assertion form.\n *\n * A leading `asserts ` prints when the asserts modifier is present, then the\n * parameter name, then ` is Type` when a type is present. The assertion form\n * with no type (just `asserts x`) is produced by passing the modifier and\n * omitting the type. A string parameter name is normalized to an identifier.\n *\n * Given no asserts modifier, parameter `x`, and a `string` type, the printer\n * renders:\n *\n * ```ts\n * x is string\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param assertsModifier The `asserts` modifier, if any.\n * @param parameterName The guarded parameter name, or `this`.\n * @param type The narrowed type, if any.\n * @returns The created {@link TypePredicateNode}.\n */\nexport const createTypePredicateNode = (assertsModifier, parameterName, type) => make(\"TypePredicateNode\", {\n    assertsModifier,\n    parameterName: typeof parameterName === \"string\"\n        ? createIdentifier(parameterName)\n        : parameterName,\n    type,\n});\n//# sourceMappingURL=createTypePredicateNode.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,eAAe,EAAE,aAAa,EAAE,IAAI,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC3G,IAAI,eAAe;AACnB,IAAI,aAAa,EAAE,OAAO,aAAa,KAAK;AAC5C,UAAU,gBAAgB,CAAC,aAAa;AACxC,UAAU,aAAa;AACvB,IAAI,IAAI;AACR,CAAC;;;;"}

package/lib/factory/types/createTypeQueryNode.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TypeQueryNode}: a `typeof x` type query.
+ *
+ * The `typeof ` keyword prints in front of the queried entity name, which may
+ * be a qualified name such as `typeof ns.value`. This yields the type of a
+ * value rather than referencing a type directly.
+ *
+ * Given the entity name `foo`, the printer renders:
+ *
+ * ```ts
+ * typeof foo;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param exprName The queried entity name.
+ * @returns The created {@link TypeQueryNode}.
+ */
+const createTypeQueryNode = (exprName) => make("TypeQueryNode", { exprName });
+
+export { createTypeQueryNode };
+//# sourceMappingURL=createTypeQueryNode.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeQueryNode.mjs","sources":["../../../esm-tmp/factory/types/createTypeQueryNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TypeQueryNode}: a `typeof x` type query.\n *\n * The `typeof ` keyword prints in front of the queried entity name, which may\n * be a qualified name such as `typeof ns.value`. This yields the type of a\n * value rather than referencing a type directly.\n *\n * Given the entity name `foo`, the printer renders:\n *\n * ```ts\n * typeof foo;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param exprName The queried entity name.\n * @returns The created {@link TypeQueryNode}.\n */\nexport const createTypeQueryNode = (exprName) => make(\"TypeQueryNode\", { exprName });\n//# sourceMappingURL=createTypeQueryNode.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,QAAQ,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/types/createTypeReferenceNode.mjs

@@ -0,0 +1,30 @@
+import { asEntityName } from '../internal/asEntityName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TypeReferenceNode}: a named type reference such as
+ * `Array<string>` or `ns.Foo`.
+ *
+ * The type name prints first and may be a qualified name, followed by the type
+ * arguments as `<...>` when present. With no type arguments only the bare name
+ * prints. A string name is normalized to an entity name.
+ *
+ * Given the name `Array` and a single `string` type argument, the printer
+ * renders:
+ *
+ * ```ts
+ * Array<string>;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param typeName The referenced type name.
+ * @param typeArguments The generic type arguments, if any.
+ * @returns The created {@link TypeReferenceNode}.
+ */
+const createTypeReferenceNode = (typeName, typeArguments) => make("TypeReferenceNode", {
+    typeName: asEntityName(typeName),
+    typeArguments,
+});
+
+export { createTypeReferenceNode };
+//# sourceMappingURL=createTypeReferenceNode.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeReferenceNode.mjs","sources":["../../../esm-tmp/factory/types/createTypeReferenceNode.js"],"sourcesContent":["import { asEntityName } from \"../internal/asEntityName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link TypeReferenceNode}: a named type reference such as\n * `Array<string>` or `ns.Foo`.\n *\n * The type name prints first and may be a qualified name, followed by the type\n * arguments as `<...>` when present. With no type arguments only the bare name\n * prints. A string name is normalized to an entity name.\n *\n * Given the name `Array` and a single `string` type argument, the printer\n * renders:\n *\n * ```ts\n * Array<string>;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeName The referenced type name.\n * @param typeArguments The generic type arguments, if any.\n * @returns The created {@link TypeReferenceNode}.\n */\nexport const createTypeReferenceNode = (typeName, typeArguments) => make(\"TypeReferenceNode\", {\n    typeName: asEntityName(typeName),\n    typeArguments,\n});\n//# sourceMappingURL=createTypeReferenceNode.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC9F,IAAI,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC;AACpC,IAAI,aAAa;AACjB,CAAC;;;;"}

package/lib/factory/types/createUnionTypeNode.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link UnionTypeNode}: an `A | B` type.
+ *
+ * The constituents are joined with `|`. The printer is width-aware: when the
+ * whole union fits on one line it stays inline as `A | B`, and when it has to
+ * break it indents and puts each constituent on its own line with a leading
+ * `|`, including a leading `|` before the first member.
+ *
+ * Given the constituents `string` and `number`, the printer renders:
+ *
+ * ```ts
+ * string | number;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param types The constituent types.
+ * @returns The created {@link UnionTypeNode}.
+ */
+const createUnionTypeNode = (types) => make("UnionTypeNode", { types });
+
+export { createUnionTypeNode };
+//# sourceMappingURL=createUnionTypeNode.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createUnionTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createUnionTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link UnionTypeNode}: an `A | B` type.\n *\n * The constituents are joined with `|`. The printer is width-aware: when the\n * whole union fits on one line it stays inline as `A | B`, and when it has to\n * break it indents and puts each constituent on its own line with a leading\n * `|`, including a leading `|` before the first member.\n *\n * Given the constituents `string` and `number`, the printer renders:\n *\n * ```ts\n * string | number;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param types The constituent types.\n * @returns The created {@link UnionTypeNode}.\n */\nexport const createUnionTypeNode = (types) => make(\"UnionTypeNode\", { types });\n//# sourceMappingURL=createUnionTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,KAAK,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,KAAK,EAAE;;;;"}

package/lib/index.mjs

@@ -0,0 +1,10 @@
+import * as index from './factory/index.mjs';
+export { TsPrinter } from './TsPrinter.mjs';
+export { addSyntheticLeadingComment, addSyntheticTrailingComment, getSyntheticLeadingComments, getSyntheticTrailingComments, setSyntheticLeadingComments, setSyntheticTrailingComments } from './comments.mjs';
+export { NodeFlags } from './syntax/NodeFlags.mjs';
+export { SyntaxKind } from './syntax/SyntaxKind.mjs';
+
+
+
+export { index as default, index as factory };
+//# sourceMappingURL=index.mjs.map

package/lib/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/lib/internal/doc.mjs

@@ -0,0 +1,171 @@
+/** Concatenate documents. */
+const concat = (parts) => ({ type: "concat", parts });
+/** A group: printed flat when it fits, broken otherwise. */
+const group = (doc, shouldBreak = false) => ({
+    type: "group",
+    doc,
+    break: shouldBreak,
+});
+/** Increase indentation of the inner document by one level. */
+const indent = (doc) => ({ type: "indent", doc });
+/** A space when flat, a newline when broken. */
+const line = { type: "line" };
+/** Nothing when flat, a newline when broken. */
+const softline = { type: "softline" };
+/** Always a newline; forces every enclosing group to break. */
+const hardline = { type: "hardline" };
+/** Print `broken` when the enclosing group breaks, `flat` otherwise. */
+const ifBreak = (broken, flat = "") => ({
+    type: "ifBreak",
+    broken,
+    flat,
+});
+/** Interleave `items` with `separator`. */
+const join = (separator, items) => {
+    const parts = [];
+    items.forEach((item, i) => {
+        if (i !== 0)
+            parts.push(separator);
+        parts.push(item);
+    });
+    return concat(parts);
+};
+const MODE_BREAK = 1;
+const MODE_FLAT = 2;
+/** Mark every group that (transitively) contains a hardline as broken. */
+const propagateBreaks = (doc) => {
+    if (typeof doc === "string")
+        return false;
+    switch (doc.type) {
+        case "concat": {
+            let broke = false;
+            for (const part of doc.parts)
+                broke = propagateBreaks(part) || broke;
+            return broke;
+        }
+        case "indent":
+            return propagateBreaks(doc.doc);
+        case "group": {
+            const broke = propagateBreaks(doc.doc);
+            doc.break = doc.break || broke;
+            return doc.break;
+        }
+        case "ifBreak":
+            propagateBreaks(doc.broken);
+            propagateBreaks(doc.flat);
+            return false;
+        case "hardline":
+            return true;
+        default:
+            return false;
+    }
+};
+/** Does `next` (followed by `rest`) fit flat within `remaining` columns? */
+const fits = (next, rest, remaining) => {
+    let width = remaining;
+    const cmds = [next];
+    let restIndex = rest.length;
+    while (width >= 0) {
+        if (cmds.length === 0) {
+            if (restIndex === 0)
+                return true;
+            cmds.push(rest[--restIndex]);
+            continue;
+        }
+        const [ind, mode, doc] = cmds.pop();
+        if (typeof doc === "string") {
+            width -= doc.length;
+            continue;
+        }
+        switch (doc.type) {
+            case "concat":
+                for (let i = doc.parts.length - 1; i >= 0; i--)
+                    cmds.push([ind, mode, doc.parts[i]]);
+                break;
+            case "indent":
+                cmds.push([ind + 1, mode, doc.doc]);
+                break;
+            case "group":
+                cmds.push([ind, doc.break ? MODE_BREAK : mode, doc.doc]);
+                break;
+            case "ifBreak":
+                cmds.push([ind, mode, mode === MODE_BREAK ? doc.broken : doc.flat]);
+                break;
+            case "line":
+                if (mode === MODE_FLAT)
+                    width -= 1;
+                else
+                    return true;
+                break;
+            case "softline":
+                if (mode !== MODE_FLAT)
+                    return true;
+                break;
+            case "hardline":
+                return true;
+        }
+    }
+    return false;
+};
+/** Lay a {@link Doc} out into source text. */
+const printDocToString = (doc, options) => {
+    propagateBreaks(doc);
+    const { printWidth, newLine, indent: tab } = options;
+    const out = [];
+    let pos = 0;
+    const cmds = [[0, MODE_BREAK, doc]];
+    const newlineTo = (ind) => {
+        if (out.length)
+            out[out.length - 1] = out[out.length - 1].replace(/[ \t]+$/, "");
+        out.push(newLine + tab.repeat(ind));
+        pos = tab.length * ind;
+    };
+    while (cmds.length) {
+        const [ind, mode, d] = cmds.pop();
+        if (typeof d === "string") {
+            out.push(d);
+            pos += d.length;
+            continue;
+        }
+        switch (d.type) {
+            case "concat":
+                for (let i = d.parts.length - 1; i >= 0; i--)
+                    cmds.push([ind, mode, d.parts[i]]);
+                break;
+            case "indent":
+                cmds.push([ind + 1, mode, d.doc]);
+                break;
+            case "group":
+                if (mode === MODE_FLAT && !d.break)
+                    cmds.push([ind, MODE_FLAT, d.doc]);
+                else if (!d.break &&
+                    fits([ind, MODE_FLAT, d.doc], cmds, printWidth - pos))
+                    cmds.push([ind, MODE_FLAT, d.doc]);
+                else
+                    cmds.push([ind, MODE_BREAK, d.doc]);
+                break;
+            case "ifBreak":
+                cmds.push([ind, mode, mode === MODE_BREAK ? d.broken : d.flat]);
+                break;
+            case "line":
+                if (mode === MODE_FLAT) {
+                    out.push(" ");
+                    pos += 1;
+                }
+                else
+                    newlineTo(ind);
+                break;
+            case "softline":
+                if (mode !== MODE_FLAT)
+                    newlineTo(ind);
+                break;
+            case "hardline":
+                newlineTo(ind);
+                break;
+        }
+    }
+    return out.join("");
+};
+
+export { concat, group, hardline, ifBreak, indent, join, line, printDocToString, softline };
+//# sourceMappingURL=doc.mjs.map

package/lib/internal/doc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc.mjs","sources":["../../esm-tmp/internal/doc.js"],"sourcesContent":["/** Concatenate documents. */\nexport const concat = (parts) => ({ type: \"concat\", parts });\n/** A group: printed flat when it fits, broken otherwise. */\nexport const group = (doc, shouldBreak = false) => ({\n    type: \"group\",\n    doc,\n    break: shouldBreak,\n});\n/** Increase indentation of the inner document by one level. */\nexport const indent = (doc) => ({ type: \"indent\", doc });\n/** A space when flat, a newline when broken. */\nexport const line = { type: \"line\" };\n/** Nothing when flat, a newline when broken. */\nexport const softline = { type: \"softline\" };\n/** Always a newline; forces every enclosing group to break. */\nexport const hardline = { type: \"hardline\" };\n/** Print `broken` when the enclosing group breaks, `flat` otherwise. */\nexport const ifBreak = (broken, flat = \"\") => ({\n    type: \"ifBreak\",\n    broken,\n    flat,\n});\n/** Interleave `items` with `separator`. */\nexport const join = (separator, items) => {\n    const parts = [];\n    items.forEach((item, i) => {\n        if (i !== 0)\n            parts.push(separator);\n        parts.push(item);\n    });\n    return concat(parts);\n};\nconst MODE_BREAK = 1;\nconst MODE_FLAT = 2;\n/** Mark every group that (transitively) contains a hardline as broken. */\nconst propagateBreaks = (doc) => {\n    if (typeof doc === \"string\")\n        return false;\n    switch (doc.type) {\n        case \"concat\": {\n            let broke = false;\n            for (const part of doc.parts)\n                broke = propagateBreaks(part) || broke;\n            return broke;\n        }\n        case \"indent\":\n            return propagateBreaks(doc.doc);\n        case \"group\": {\n            const broke = propagateBreaks(doc.doc);\n            doc.break = doc.break || broke;\n            return doc.break;\n        }\n        case \"ifBreak\":\n            propagateBreaks(doc.broken);\n            propagateBreaks(doc.flat);\n            return false;\n        case \"hardline\":\n            return true;\n        default:\n            return false;\n    }\n};\n/** Does `next` (followed by `rest`) fit flat within `remaining` columns? */\nconst fits = (next, rest, remaining) => {\n    let width = remaining;\n    const cmds = [next];\n    let restIndex = rest.length;\n    while (width >= 0) {\n        if (cmds.length === 0) {\n            if (restIndex === 0)\n                return true;\n            cmds.push(rest[--restIndex]);\n            continue;\n        }\n        const [ind, mode, doc] = cmds.pop();\n        if (typeof doc === \"string\") {\n            width -= doc.length;\n            continue;\n        }\n        switch (doc.type) {\n            case \"concat\":\n                for (let i = doc.parts.length - 1; i >= 0; i--)\n                    cmds.push([ind, mode, doc.parts[i]]);\n                break;\n            case \"indent\":\n                cmds.push([ind + 1, mode, doc.doc]);\n                break;\n            case \"group\":\n                cmds.push([ind, doc.break ? MODE_BREAK : mode, doc.doc]);\n                break;\n            case \"ifBreak\":\n                cmds.push([ind, mode, mode === MODE_BREAK ? doc.broken : doc.flat]);\n                break;\n            case \"line\":\n                if (mode === MODE_FLAT)\n                    width -= 1;\n                else\n                    return true;\n                break;\n            case \"softline\":\n                if (mode !== MODE_FLAT)\n                    return true;\n                break;\n            case \"hardline\":\n                return true;\n        }\n    }\n    return false;\n};\n/** Lay a {@link Doc} out into source text. */\nexport const printDocToString = (doc, options) => {\n    propagateBreaks(doc);\n    const { printWidth, newLine, indent: tab } = options;\n    const out = [];\n    let pos = 0;\n    const cmds = [[0, MODE_BREAK, doc]];\n    const newlineTo = (ind) => {\n        if (out.length)\n            out[out.length - 1] = out[out.length - 1].replace(/[ \\t]+$/, \"\");\n        out.push(newLine + tab.repeat(ind));\n        pos = tab.length * ind;\n    };\n    while (cmds.length) {\n        const [ind, mode, d] = cmds.pop();\n        if (typeof d === \"string\") {\n            out.push(d);\n            pos += d.length;\n            continue;\n        }\n        switch (d.type) {\n            case \"concat\":\n                for (let i = d.parts.length - 1; i >= 0; i--)\n                    cmds.push([ind, mode, d.parts[i]]);\n                break;\n            case \"indent\":\n                cmds.push([ind + 1, mode, d.doc]);\n                break;\n            case \"group\":\n                if (mode === MODE_FLAT && !d.break)\n                    cmds.push([ind, MODE_FLAT, d.doc]);\n                else if (!d.break &&\n                    fits([ind, MODE_FLAT, d.doc], cmds, printWidth - pos))\n                    cmds.push([ind, MODE_FLAT, d.doc]);\n                else\n                    cmds.push([ind, MODE_BREAK, d.doc]);\n                break;\n            case \"ifBreak\":\n                cmds.push([ind, mode, mode === MODE_BREAK ? d.broken : d.flat]);\n                break;\n            case \"line\":\n                if (mode === MODE_FLAT) {\n                    out.push(\" \");\n                    pos += 1;\n                }\n                else\n                    newlineTo(ind);\n                break;\n            case \"softline\":\n                if (mode !== MODE_FLAT)\n                    newlineTo(ind);\n                break;\n            case \"hardline\":\n                newlineTo(ind);\n                break;\n        }\n    }\n    return out.join(\"\");\n};\n//# sourceMappingURL=doc.js.map"],"names":[],"mappings":"AAAA;AACY,MAAC,MAAM,GAAG,CAAC,KAAK,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE;AAC3D;AACY,MAAC,KAAK,GAAG,CAAC,GAAG,EAAE,WAAW,GAAG,KAAK,MAAM;AACpD,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,GAAG;AACP,IAAI,KAAK,EAAE,WAAW;AACtB,CAAC;AACD;AACY,MAAC,MAAM,GAAG,CAAC,GAAG,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE;AACvD;AACY,MAAC,IAAI,GAAG,EAAE,IAAI,EAAE,MAAM;AAClC;AACY,MAAC,QAAQ,GAAG,EAAE,IAAI,EAAE,UAAU;AAC1C;AACY,MAAC,QAAQ,GAAG,EAAE,IAAI,EAAE,UAAU;AAC1C;AACY,MAAC,OAAO,GAAG,CAAC,MAAM,EAAE,IAAI,GAAG,EAAE,MAAM;AAC/C,IAAI,IAAI,EAAE,SAAS;AACnB,IAAI,MAAM;AACV,IAAI,IAAI;AACR,CAAC;AACD;AACY,MAAC,IAAI,GAAG,CAAC,SAAS,EAAE,KAAK,KAAK;AAC1C,IAAI,MAAM,KAAK,GAAG,EAAE;AACpB,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK;AAC/B,QAAQ,IAAI,CAAC,KAAK,CAAC;AACnB,YAAY,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC;AACjC,QAAQ,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;AACxB,IAAI,CAAC,CAAC;AACN,IAAI,OAAO,MAAM,CAAC,KAAK,CAAC;AACxB;AACA,MAAM,UAAU,GAAG,CAAC;AACpB,MAAM,SAAS,GAAG,CAAC;AACnB;AACA,MAAM,eAAe,GAAG,CAAC,GAAG,KAAK;AACjC,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ;AAC/B,QAAQ,OAAO,KAAK;AACpB,IAAI,QAAQ,GAAG,CAAC,IAAI;AACpB,QAAQ,KAAK,QAAQ,EAAE;AACvB,YAAY,IAAI,KAAK,GAAG,KAAK;AAC7B,YAAY,KAAK,MAAM,IAAI,IAAI,GAAG,CAAC,KAAK;AACxC,gBAAgB,KAAK,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,KAAK;AACtD,YAAY,OAAO,KAAK;AACxB,QAAQ;AACR,QAAQ,KAAK,QAAQ;AACrB,YAAY,OAAO,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC;AAC3C,QAAQ,KAAK,OAAO,EAAE;AACtB,YAAY,MAAM,KAAK,GAAG,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC;AAClD,YAAY,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,IAAI,KAAK;AAC1C,YAAY,OAAO,GAAG,CAAC,KAAK;AAC5B,QAAQ;AACR,QAAQ,KAAK,SAAS;AACtB,YAAY,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC;AACvC,YAAY,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC;AACrC,YAAY,OAAO,KAAK;AACxB,QAAQ,KAAK,UAAU;AACvB,YAAY,OAAO,IAAI;AACvB,QAAQ;AACR,YAAY,OAAO,KAAK;AACxB;AACA,CAAC;AACD;AACA,MAAM,IAAI,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,KAAK;AACxC,IAAI,IAAI,KAAK,GAAG,SAAS;AACzB,IAAI,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC;AACvB,IAAI,IAAI,SAAS,GAAG,IAAI,CAAC,MAAM;AAC/B,IAAI,OAAO,KAAK,IAAI,CAAC,EAAE;AACvB,QAAQ,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;AAC/B,YAAY,IAAI,SAAS,KAAK,CAAC;AAC/B,gBAAgB,OAAO,IAAI;AAC3B,YAAY,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,CAAC;AACxC,YAAY;AACZ,QAAQ;AACR,QAAQ,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE;AAC3C,QAAQ,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE;AACrC,YAAY,KAAK,IAAI,GAAG,CAAC,MAAM;AAC/B,YAAY;AACZ,QAAQ;AACR,QAAQ,QAAQ,GAAG,CAAC,IAAI;AACxB,YAAY,KAAK,QAAQ;AACzB,gBAAgB,KAAK,IAAI,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;AAC9D,oBAAoB,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACxD,gBAAgB;AAChB,YAAY,KAAK,QAAQ;AACzB,gBAAgB,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;AACnD,gBAAgB;AAChB,YAAY,KAAK,OAAO;AACxB,gBAAgB,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,GAAG,UAAU,GAAG,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;AACxE,gBAAgB;AAChB,YAAY,KAAK,SAAS;AAC1B,gBAAgB,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,KAAK,UAAU,GAAG,GAAG,CAAC,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;AACnF,gBAAgB;AAChB,YAAY,KAAK,MAAM;AACvB,gBAAgB,IAAI,IAAI,KAAK,SAAS;AACtC,oBAAoB,KAAK,IAAI,CAAC;AAC9B;AACA,oBAAoB,OAAO,IAAI;AAC/B,gBAAgB;AAChB,YAAY,KAAK,UAAU;AAC3B,gBAAgB,IAAI,IAAI,KAAK,SAAS;AACtC,oBAAoB,OAAO,IAAI;AAC/B,gBAAgB;AAChB,YAAY,KAAK,UAAU;AAC3B,gBAAgB,OAAO,IAAI;AAC3B;AACA,IAAI;AACJ,IAAI,OAAO,KAAK;AAChB,CAAC;AACD;AACY,MAAC,gBAAgB,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK;AAClD,IAAI,eAAe,CAAC,GAAG,CAAC;AACxB,IAAI,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,OAAO;AACxD,IAAI,MAAM,GAAG,GAAG,EAAE;AAClB,IAAI,IAAI,GAAG,GAAG,CAAC;AACf,IAAI,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;AACvC,IAAI,MAAM,SAAS,GAAG,CAAC,GAAG,KAAK;AAC/B,QAAQ,IAAI,GAAG,CAAC,MAAM;AACtB,YAAY,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC;AAC5E,QAAQ,GAAG,CAAC,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3C,QAAQ,GAAG,GAAG,GAAG,CAAC,MAAM,GAAG,GAAG;AAC9B,IAAI,CAAC;AACL,IAAI,OAAO,IAAI,CAAC,MAAM,EAAE;AACxB,QAAQ,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE;AACzC,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE;AACnC,YAAY,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;AACvB,YAAY,GAAG,IAAI,CAAC,CAAC,MAAM;AAC3B,YAAY;AACZ,QAAQ;AACR,QAAQ,QAAQ,CAAC,CAAC,IAAI;AACtB,YAAY,KAAK,QAAQ;AACzB,gBAAgB,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;AAC5D,oBAAoB,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACtD,gBAAgB;AAChB,YAAY,KAAK,QAAQ;AACzB,gBAAgB,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;AACjD,gBAAgB;AAChB,YAAY,KAAK,OAAO;AACxB,gBAAgB,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,CAAC,CAAC,KAAK;AAClD,oBAAoB,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;AACtD,qBAAqB,IAAI,CAAC,CAAC,CAAC,KAAK;AACjC,oBAAoB,IAAI,CAAC,CAAC,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,UAAU,GAAG,GAAG,CAAC;AACzE,oBAAoB,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;AACtD;AACA,oBAAoB,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,UAAU,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;AACvD,gBAAgB;AAChB,YAAY,KAAK,SAAS;AAC1B,gBAAgB,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,KAAK,UAAU,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;AAC/E,gBAAgB;AAChB,YAAY,KAAK,MAAM;AACvB,gBAAgB,IAAI,IAAI,KAAK,SAAS,EAAE;AACxC,oBAAoB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC;AACjC,oBAAoB,GAAG,IAAI,CAAC;AAC5B,gBAAgB;AAChB;AACA,oBAAoB,SAAS,CAAC,GAAG,CAAC;AAClC,gBAAgB;AAChB,YAAY,KAAK,UAAU;AAC3B,gBAAgB,IAAI,IAAI,KAAK,SAAS;AACtC,oBAAoB,SAAS,CAAC,GAAG,CAAC;AAClC,gBAAgB;AAChB,YAAY,KAAK,UAAU;AAC3B,gBAAgB,SAAS,CAAC,GAAG,CAAC;AAC9B,gBAAgB;AAChB;AACA,IAAI;AACJ,IAAI,OAAO,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;AACvB;;;;"}

package/lib/syntax/NodeFlags.mjs

@@ -0,0 +1,23 @@
+/**
+ * Flags for {@link factory.createVariableDeclarationList} and
+ * {@link factory.createModuleDeclaration}.
+ *
+ * An outline of the relevant subset of the legacy `ts.NodeFlags`. Each member's
+ * value is the keyword it implies (`Let = "let"`, `Const = "const"`), so the
+ * printer reads it directly. `Namespace` is accepted for API parity — the
+ * printer renders the `module` / `namespace` keyword from the module name kind,
+ * not from this flag. A string-valued enum (deliberately not `const enum`, so
+ * consumers compiled with `isolatedModules` can still reference its members).
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+var NodeFlags;
+(function (NodeFlags) {
+    NodeFlags["None"] = "";
+    NodeFlags["Let"] = "let";
+    NodeFlags["Const"] = "const";
+    NodeFlags["Namespace"] = "namespace";
+})(NodeFlags || (NodeFlags = {}));
+
+export { NodeFlags };
+//# sourceMappingURL=NodeFlags.mjs.map

package/lib/syntax/NodeFlags.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeFlags.mjs","sources":["../../esm-tmp/syntax/NodeFlags.js"],"sourcesContent":["/**\n * Flags for {@link factory.createVariableDeclarationList} and\n * {@link factory.createModuleDeclaration}.\n *\n * An outline of the relevant subset of the legacy `ts.NodeFlags`. Each member's\n * value is the keyword it implies (`Let = \"let\"`, `Const = \"const\"`), so the\n * printer reads it directly. `Namespace` is accepted for API parity — the\n * printer renders the `module` / `namespace` keyword from the module name kind,\n * not from this flag. A string-valued enum (deliberately not `const enum`, so\n * consumers compiled with `isolatedModules` can still reference its members).\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport var NodeFlags;\n(function (NodeFlags) {\n    NodeFlags[\"None\"] = \"\";\n    NodeFlags[\"Let\"] = \"let\";\n    NodeFlags[\"Const\"] = \"const\";\n    NodeFlags[\"Namespace\"] = \"namespace\";\n})(NodeFlags || (NodeFlags = {}));\n//# sourceMappingURL=NodeFlags.js.map"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACU,IAAC;AACX,CAAC,UAAU,SAAS,EAAE;AACtB,IAAI,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE;AAC1B,IAAI,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK;AAC5B,IAAI,SAAS,CAAC,OAAO,CAAC,GAAG,OAAO;AAChC,IAAI,SAAS,CAAC,WAAW,CAAC,GAAG,WAAW;AACxC,CAAC,EAAE,SAAS,KAAK,SAAS,GAAG,EAAE,CAAC,CAAC;;;;"}