@ttsc/factory 0.15.10 → 0.15.11

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

@@ -1 +1 @@
-{"version":3,"file":"createJsxExpression.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxExpression}: a `{...}` brace embedding a JavaScript\n * expression in JSX.\n *\n * This is how a dynamic value is dropped into a child position or an attribute\n * value. Pass the `expression` to render inside the braces; pass `undefined`\n * for an empty `{}`. The optional `dotDotDotToken` (the `...` token) turns it\n * into a spread child, prefixing the expression with `...` inside the braces.\n *\n * Given no spread token and the expression `value`, the printer emits:\n *\n * ```tsx\n * {value}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param dotDotDotToken The `...` token, if a spread.\n * @param expression The expression, if any.\n * @returns The created {@link JsxExpression}.\n */\nexport const createJsxExpression = (dotDotDotToken, expression) => make(\"JsxExpression\", {\n    dotDotDotToken,\n    expression,\n});\n//# sourceMappingURL=createJsxExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,cAAc,EAAE,UAAU,KAAK,IAAI,CAAC,eAAe,EAAE;AACzF,IAAI,cAAc;AAClB,IAAI,UAAU;AACd,CAAC;;;;"}
+{"version":3,"file":"createJsxExpression.mjs","sources":["../../../src/factory/jsx/createJsxExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,mBAAmB,GAAG,CACjC,cAAiC,EACjC,UAAkC,KAElC,IAAI,CAAC,eAAe,EAAE;IACpB,cAAc;IACd,UAAU;AACX,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJsxFragment.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxFragment.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxFragment}: a `<>...</>` fragment grouping children without\n * a wrapping element.\n *\n * The fragment is built from an empty {@link JsxOpeningFragment} (`<>`), the\n * list of children, and an empty {@link JsxClosingFragment} (`</>`). It exists\n * to render several siblings where a single root is required, without emitting\n * an extra DOM tag. The children follow the same rules as a {@link JsxElement}.\n *\n * Given an opening fragment, a single `Hello` text child, and a closing\n * fragment, the printer emits:\n *\n * ```tsx\n * <>Hello</>\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param openingFragment The opening fragment.\n * @param children The children.\n * @param closingFragment The closing fragment.\n * @returns The created {@link JsxFragment}.\n */\nexport const createJsxFragment = (openingFragment, children, closingFragment) => make(\"JsxFragment\", {\n    openingFragment,\n    children,\n    closingFragment,\n});\n//# sourceMappingURL=createJsxFragment.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,iBAAiB,GAAG,CAAC,eAAe,EAAE,QAAQ,EAAE,eAAe,KAAK,IAAI,CAAC,aAAa,EAAE;AACrG,IAAI,eAAe;AACnB,IAAI,QAAQ;AACZ,IAAI,eAAe;AACnB,CAAC;;;;"}
+{"version":3,"file":"createJsxFragment.mjs","sources":["../../../src/factory/jsx/createJsxFragment.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,iBAAiB,GAAG,CAC/B,eAAmC,EACnC,QAA6B,EAC7B,eAAmC,KAEnC,IAAI,CAAC,aAAa,EAAE;IAClB,eAAe;IACf,QAAQ;IACR,eAAe;AAChB,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJsxJsxClosingFragment.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxJsxClosingFragment.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxClosingFragment}: the `</>` that closes a\n * {@link JsxFragment}.\n *\n * It takes no arguments and is the empty trailing delimiter of a `<>...</>`\n * pair. Pair it with a {@link JsxOpeningFragment} through\n * {@link createJsxFragment}.\n *\n * With no inputs, the printer emits:\n *\n * ```tsx\n * </>\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link JsxClosingFragment}.\n */\nexport const createJsxJsxClosingFragment = () => make(\"JsxClosingFragment\", {});\n//# sourceMappingURL=createJsxJsxClosingFragment.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,2BAA2B,GAAG,MAAM,IAAI,CAAC,oBAAoB,EAAE,EAAE;;;;"}
+{"version":3,"file":"createJsxJsxClosingFragment.mjs","sources":["../../../src/factory/jsx/createJsxJsxClosingFragment.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,2BAA2B,GAAG,MACzC,IAAI,CAAC,oBAAoB,EAAE,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJsxNamespacedName.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxNamespacedName.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxNamespacedName}: a colon-separated `namespace:name` used in\n * tag or attribute names.\n *\n * Both parts are identifiers; the result reads `namespace:name`. It appears\n * where namespaced JSX names are valid, most commonly as an attribute name such\n * as `xlink:href` on an SVG element, or as a namespaced tag name.\n *\n * Given the namespace `ns` and the name `name`, the printer emits:\n *\n * ```tsx\n * ns: name;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param namespace The namespace.\n * @param name The name.\n * @returns The created {@link JsxNamespacedName}.\n */\nexport const createJsxNamespacedName = (namespace, name) => make(\"JsxNamespacedName\", {\n    namespace,\n    name,\n});\n//# sourceMappingURL=createJsxNamespacedName.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,uBAAuB,GAAG,CAAC,SAAS,EAAE,IAAI,KAAK,IAAI,CAAC,mBAAmB,EAAE;AACtF,IAAI,SAAS;AACb,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createJsxNamespacedName.mjs","sources":["../../../src/factory/jsx/createJsxNamespacedName.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,uBAAuB,GAAG,CACrC,SAAqB,EACrB,IAAgB,KAEhB,IAAI,CAAC,mBAAmB,EAAE;IACxB,SAAS;IACT,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJsxOpeningElement.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxOpeningElement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxOpeningElement}: the `<Tag>` that opens a paired\n * {@link JsxElement}.\n *\n * This is the leading half of a `<Tag>...</Tag>` pair; it carries the tag name,\n * optional generic `typeArguments`, and the attributes, but no children and no\n * trailing slash. Pair it with a matching {@link JsxClosingElement} through\n * {@link createJsxElement}.\n *\n * Given the tag name `Foo`, no type arguments, and attributes holding a single\n * `bar=\"x\"`, the printer emits:\n *\n * ```tsx\n * <Foo bar=\"x\">\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name.\n * @param typeArguments The generic type arguments, if any.\n * @param attributes The attributes.\n * @returns The created {@link JsxOpeningElement}.\n */\nexport const createJsxOpeningElement = (tagName, typeArguments, attributes) => make(\"JsxOpeningElement\", {\n    tagName,\n    typeArguments,\n    attributes,\n});\n//# sourceMappingURL=createJsxOpeningElement.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,uBAAuB,GAAG,CAAC,OAAO,EAAE,aAAa,EAAE,UAAU,KAAK,IAAI,CAAC,mBAAmB,EAAE;AACzG,IAAI,OAAO;AACX,IAAI,aAAa;AACjB,IAAI,UAAU;AACd,CAAC;;;;"}
+{"version":3,"file":"createJsxOpeningElement.mjs","sources":["../../../src/factory/jsx/createJsxOpeningElement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,uBAAuB,GAAG,CACrC,OAAmB,EACnB,aAA8C,EAC9C,UAAyB,KAEzB,IAAI,CAAC,mBAAmB,EAAE;IACxB,OAAO;IACP,aAAa;IACb,UAAU;AACX,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJsxOpeningFragment.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxOpeningFragment.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxOpeningFragment}: the `<>` that opens a {@link JsxFragment}.\n *\n * It takes no arguments and carries no tag name or attributes; it is the empty\n * leading delimiter of a `<>...</>` pair. Pair it with a\n * {@link JsxClosingFragment} through {@link createJsxFragment}.\n *\n * With no inputs, the printer emits:\n *\n * ```tsx\n * <>\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link JsxOpeningFragment}.\n */\nexport const createJsxOpeningFragment = () => make(\"JsxOpeningFragment\", {});\n//# sourceMappingURL=createJsxOpeningFragment.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,wBAAwB,GAAG,MAAM,IAAI,CAAC,oBAAoB,EAAE,EAAE;;;;"}
+{"version":3,"file":"createJsxOpeningFragment.mjs","sources":["../../../src/factory/jsx/createJsxOpeningFragment.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;AAeG;AACI,MAAM,wBAAwB,GAAG,MACtC,IAAI,CAAC,oBAAoB,EAAE,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJsxSelfClosingElement.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxSelfClosingElement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxSelfClosingElement}: a `<Tag />` element with no children.\n *\n * The tag name accepts a plain identifier, a property-access chain like\n * `Foo.Bar`, or a {@link JsxNamespacedName}. Optional `typeArguments` render as\n * a generic argument list right after the tag name. The attributes carry the\n * element's props; pass an empty {@link JsxAttributes} for none.\n *\n * Given the tag name `Foo`, no type arguments, and attributes holding a single\n * `bar=\"x\"`, the printer emits:\n *\n * ```tsx\n * <Foo bar=\"x\" />\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name.\n * @param typeArguments The generic type arguments, if any.\n * @param attributes The attributes.\n * @returns The created {@link JsxSelfClosingElement}.\n */\nexport const createJsxSelfClosingElement = (tagName, typeArguments, attributes) => make(\"JsxSelfClosingElement\", {\n    tagName,\n    typeArguments,\n    attributes,\n});\n//# sourceMappingURL=createJsxSelfClosingElement.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,2BAA2B,GAAG,CAAC,OAAO,EAAE,aAAa,EAAE,UAAU,KAAK,IAAI,CAAC,uBAAuB,EAAE;AACjH,IAAI,OAAO;AACX,IAAI,aAAa;AACjB,IAAI,UAAU;AACd,CAAC;;;;"}
+{"version":3,"file":"createJsxSelfClosingElement.mjs","sources":["../../../src/factory/jsx/createJsxSelfClosingElement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,2BAA2B,GAAG,CACzC,OAAmB,EACnB,aAA8C,EAC9C,UAAyB,KAEzB,IAAI,CAAC,uBAAuB,EAAE;IAC5B,OAAO;IACP,aAAa;IACb,UAAU;AACX,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJsxSpreadAttribute.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxSpreadAttribute.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxSpreadAttribute}: a `{...expr}` prop that spreads an\n * object's members onto a JSX element.\n *\n * The expression evaluates to the object whose own properties become\n * attributes. It sits among ordinary {@link JsxAttribute} entries inside a\n * {@link JsxAttributes} list.\n *\n * Given the expression `props`, the printer emits:\n *\n * ```tsx\n * {...props}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @returns The created {@link JsxSpreadAttribute}.\n */\nexport const createJsxSpreadAttribute = (expression) => make(\"JsxSpreadAttribute\", { expression });\n//# sourceMappingURL=createJsxSpreadAttribute.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,wBAAwB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,oBAAoB,EAAE,EAAE,UAAU,EAAE;;;;"}
+{"version":3,"file":"createJsxSpreadAttribute.mjs","sources":["../../../src/factory/jsx/createJsxSpreadAttribute.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,wBAAwB,GAAG,CACtC,UAAsB,KACC,IAAI,CAAC,oBAAoB,EAAE,EAAE,UAAU,EAAE;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createJsxText.mjs","sources":["../../../src/factory/jsx/createJsxText.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,aAAa,GAAG,CAC3B,IAAY,EACZ,6BAAuC,KAEvC,IAAI,CAAC,SAAS,EAAE;IACd,IAAI;IACJ,6BAA6B,EAAE,CAAC,CAAC,6BAA6B;AAC/D,CAAA;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createBigIntLiteral.mjs","sources":["../../../src/factory/literals/createBigIntLiteral.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,mBAAmB,GAAG,CAAC,KAAa,KAC/C,IAAI,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,KAAK,GAAG,CAAA,EAAG,KAAK,CAAA,CAAA,CAAG,EAAE;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createNoSubstitutionTemplateLiteral.mjs","sources":["../../../src/factory/literals/createNoSubstitutionTemplateLiteral.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,mCAAmC,GAAG,CACjD,IAAY,KAEZ,IAAI,CAAC,+BAA+B,EAAE,EAAE,IAAI,EAAE;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createNumericLiteral.mjs","sources":["../../../src/factory/literals/createNumericLiteral.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;MACU,oBAAoB,GAAG,CAAC,KAAsB,KACzD,IAAI,CAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createStringLiteral.mjs","sources":["../../../src/factory/literals/createStringLiteral.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;AAsBG;MACU,mBAAmB,GAAG,CACjC,IAAY,EACZ,aAAuB,KACL,IAAI,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,aAAa,EAAE;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createStringLiteralFromNode.mjs","sources":["../../../src/factory/literals/createStringLiteralFromNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,2BAA2B,GAAG,CACzC,UAA2E,KACzD,mBAAmB,CAAC,UAAU,CAAC,IAAI;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createTemplateHead.mjs","sources":["../../../src/factory/literals/createTemplateHead.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,kBAAkB,GAAG,CAChC,IAAY,EACZ,OAAgB,KACC,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createTemplateMiddle.mjs","sources":["../../../src/factory/literals/createTemplateMiddle.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,oBAAoB,GAAG,CAAC,IAAY,KAC/C,IAAI,CAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createTemplateTail.mjs","sources":["../../../src/factory/literals/createTemplateTail.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,kBAAkB,GAAG,CAAC,IAAY,KAC7C,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createDecorator.mjs","sources":["../../../src/factory/names/createDecorator.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,eAAe,GAAG,CAAC,UAAsB,KACpD,IAAI,CAAC,WAAW,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/names/createFalse.mjs

@@ -1,5 +1,6 @@
-import { createToken } from './createToken.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createToken } from './createToken.mjs';
 
 /**
  * Create the `false` keyword as a {@link Token}.

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createFalse.mjs","sources":["../../../src/factory/names/createFalse.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,WAAW,GAAG,MAAa,WAAW,CAAC,UAAU,CAAC,YAAY;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createIdentifier.mjs","sources":["../../../src/factory/names/createIdentifier.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,gBAAgB,GAAG,CAAC,IAAY,KAC3C,IAAI,CAAC,YAAY,EAAE,EAAE,IAAI,EAAE;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createLoopVariable.mjs","sources":["../../../src/factory/names/createLoopVariable.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,kBAAkB,GAAG,CAChC,uBAAiC,KAClB,gBAAgB,CAAC,IAAI;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createModifier.mjs","sources":["../../../src/factory/names/createModifier.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,cAAc,GAAG,CAC5B,IAAW,KACM,WAAW,CAAC,IAAI;;;;"}

package/lib/factory/names/createModifiersFromModifierFlags.mjs

@@ -1,5 +1,6 @@
-import { createModifier } from './createModifier.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createModifier } from './createModifier.mjs';
 
 /**
  * Legacy `ts.ModifierFlags` bit values, kept as module-local constants (not an

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

@@ -1 +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":";;;AAEA;AACA;AACA;AACA;AACA,MAAM,IAAI,GAAG;AACb,IAAI,MAAM,EAAE,CAAC;AACb,IAAI,OAAO,EAAE,CAAC;AACd,IAAI,SAAS,EAAE,CAAC;AAChB,IAAI,QAAQ,EAAE,CAAC;AACf,IAAI,QAAQ,EAAE,EAAE;AAChB,IAAI,MAAM,EAAE,EAAE;AACd,IAAI,QAAQ,EAAE,EAAE;AAChB,IAAI,OAAO,EAAE,GAAG;AAChB,IAAI,MAAM,EAAE,GAAG;AACf,IAAI,QAAQ,EAAE,GAAG;AACjB,IAAI,KAAK,EAAE,IAAI;AACf,IAAI,OAAO,EAAE,IAAI;AACjB,IAAI,KAAK,EAAE,IAAI;AACf,IAAI,EAAE,EAAE,IAAI;AACZ,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gCAAgC,GAAG,CAAC,KAAK,KAAK;AAC3D,IAAI,MAAM,MAAM,GAAG,EAAE;AACrB,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM;AAC3B,QAAQ,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;AAC7D,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO;AAC5B,QAAQ,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;AAC9D,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO;AAC5B,QAAQ,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;AAC9D,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK;AAC1B,QAAQ,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;AAC5D,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM;AAC3B,QAAQ,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;AAC7D,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO;AAC5B,QAAQ,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;AAC9D,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,SAAS;AAC9B,QAAQ,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;AAChE,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ;AAC7B,QAAQ,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;AAC/D,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM;AAC3B,QAAQ,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;AAC7D,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ;AAC7B,QAAQ,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;AAC/D,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ;AAC7B,QAAQ,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;AAC/D,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ;AAC7B,QAAQ,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;AAC/D,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK;AAC1B,QAAQ,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;AAC5D,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,EAAE;AACvB,QAAQ,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;AACzD,IAAI,OAAO,MAAM,CAAC,MAAM,GAAG,MAAM,GAAG,SAAS;AAC7C;;;;"}
+{"version":3,"file":"createModifiersFromModifierFlags.mjs","sources":["../../../src/factory/names/createModifiersFromModifierFlags.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;AAGG;AACH,MAAM,IAAI,GAAG;AACX,IAAA,MAAM,EAAE,CAAC;AACT,IAAA,OAAO,EAAE,CAAC;AACV,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,QAAQ,EAAE,CAAC;AACX,IAAA,QAAQ,EAAE,EAAE;AACZ,IAAA,MAAM,EAAE,EAAE;AACV,IAAA,QAAQ,EAAE,EAAE;AACZ,IAAA,OAAO,EAAE,GAAG;AACZ,IAAA,MAAM,EAAE,GAAG;AACX,IAAA,QAAQ,EAAE,GAAG;AACb,IAAA,KAAK,EAAE,IAAI;AACX,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,KAAK,EAAE,IAAI;AACX,IAAA,EAAE,EAAE,IAAI;CACA;AAEV;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,gCAAgC,GAAG,CAC9C,KAAa,KACsB;IACnC,MAAM,MAAM,GAAe,EAAE;AAC7B,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM;QACrB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;AACvD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO;QACtB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;AACxD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO;QACtB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;AACxD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK;QAAE,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;AAC5E,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM;QACrB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;AACvD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO;QACtB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;AACxD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,SAAS;QACxB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;AAC1D,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ;QACvB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;AACzD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM;QACrB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;AACvD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ;QACvB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;AACzD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ;QACvB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;AACzD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ;QACvB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;AACzD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK;QAAE,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;AAC5E,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IACtE,OAAO,MAAM,CAAC,MAAM,GAAG,MAAM,GAAG,SAAS;AAC3C;;;;"}

package/lib/factory/names/createNull.mjs

@@ -1,5 +1,6 @@
-import { createToken } from './createToken.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createToken } from './createToken.mjs';
 
 /**
  * Create the `null` keyword as a {@link Token}.

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createNull.mjs","sources":["../../../src/factory/names/createNull.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,UAAU,GAAG,MAAa,WAAW,CAAC,UAAU,CAAC,WAAW;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createPrivateIdentifier.mjs","sources":["../../../src/factory/names/createPrivateIdentifier.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,uBAAuB,GAAG,CAAC,IAAY,KAClD,IAAI,CAAC,mBAAmB,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,CAAA,CAAA,EAAI,IAAI,CAAA,CAAE,EAAE;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createQualifiedName.mjs","sources":["../../../src/factory/names/createQualifiedName.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,mBAAmB,GAAG,CACjC,IAAgB,EAChB,KAA0B,KAE1B,IAAI,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAe,EAAE;;;;"}

package/lib/factory/names/createSuper.mjs

@@ -1,5 +1,6 @@
-import { createToken } from './createToken.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createToken } from './createToken.mjs';
 
 /**
  * Create the `super` keyword as a {@link Token}.

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

@@ -1 +1 @@
-{"version":3,"file":"createSuper.mjs","sources":["../../../esm-tmp/factory/names/createSuper.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createToken } from \"./createToken\";\n/**\n * Create the `super` keyword as a {@link Token}.\n *\n * This takes no arguments and wraps the `SuperKeyword` syntax kind. The printer\n * emits the keyword as the `super` expression.\n *\n * This prints:\n *\n * ```ts\n * super\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created node.\n */\nexport const createSuper = () => createToken(SyntaxKind.SuperKeyword);\n//# sourceMappingURL=createSuper.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;;;;"}
+{"version":3,"file":"createSuper.mjs","sources":["../../../src/factory/names/createSuper.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,WAAW,GAAG,MAAa,WAAW,CAAC,UAAU,CAAC,YAAY;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createTempVariable.mjs","sources":["../../../esm-tmp/factory/names/createTempVariable.js"],"sourcesContent":["import { createIdentifier } from \"./createIdentifier\";\n/**\n * Create a temporary 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 and records it via `recordTempVariable`. This\n * package is stateless, so this is a simplified placeholder: it does not track\n * or guarantee uniqueness, it just returns an identifier built from a fixed\n * `_temp` base with the optional `prefix` and `suffix` wrapped around it.\n *\n * The `recordTempVariable` and `reservedInNestedScopes` parameters belong to\n * the stateful generator and are accepted for signature parity but ignored. Two\n * calls with the same arguments produce the same name, so the caller must keep\n * names distinct.\n *\n * With no arguments, this prints:\n *\n * ```ts\n * _temp;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param _recordTempVariable Ignored; kept for signature parity.\n * @param _reservedInNestedScopes Ignored; kept for signature parity.\n * @param prefix An optional name prefix.\n * @param suffix An optional name suffix.\n * @returns The created {@link Identifier}.\n */\nexport const createTempVariable = (_recordTempVariable, _reservedInNestedScopes, prefix, suffix) => createIdentifier(`${prefix ?? \"\"}_temp${suffix ?? \"\"}`);\n//# sourceMappingURL=createTempVariable.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,CAAC,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,EAAE,MAAM,KAAK,gBAAgB,CAAC,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC;;;;"}
+{"version":3,"file":"createTempVariable.mjs","sources":["../../../src/factory/names/createTempVariable.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,kBAAkB,GAAG,CAChC,mBAA6B,EAC7B,uBAAiC,EACjC,MAAe,EACf,MAAe,KACA,gBAAgB,CAAC,CAAA,EAAG,MAAM,IAAI,EAAE,CAAA,KAAA,EAAQ,MAAM,IAAI,EAAE,CAAA,CAAE;;;;"}

package/lib/factory/names/createThis.mjs

@@ -1,5 +1,6 @@
-import { createToken } from './createToken.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createToken } from './createToken.mjs';
 
 /**
  * Create the `this` keyword as a {@link Token}.

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

@@ -1 +1 @@
-{"version":3,"file":"createThis.mjs","sources":["../../../esm-tmp/factory/names/createThis.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createToken } from \"./createToken\";\n/**\n * Create the `this` keyword as a {@link Token}.\n *\n * This takes no arguments and wraps the `ThisKeyword` syntax kind. The printer\n * emits the keyword as the `this` expression.\n *\n * This prints:\n *\n * ```ts\n * this;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link Token}.\n */\nexport const createThis = () => createToken(SyntaxKind.ThisKeyword);\n//# sourceMappingURL=createThis.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;;;;"}
+{"version":3,"file":"createThis.mjs","sources":["../../../src/factory/names/createThis.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,UAAU,GAAG,MAAa,WAAW,CAAC,UAAU,CAAC,WAAW;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createToken.mjs","sources":["../../../esm-tmp/factory/names/createToken.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link Token}: a node that wraps a single {@link SyntaxKind}.\n *\n * The `token` is the syntax kind to wrap, such as a punctuation or keyword\n * kind. The printer emits the source spelling tied to that kind, so a question\n * mark token prints as `?` and a keyword token prints as its keyword. The\n * generic `TKind` flows through to the result type for type-safe consumers.\n *\n * With `token` of the question-mark kind, this prints:\n *\n * ```ts\n * ?\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param token The token.\n * @returns The created {@link Token}.\n */\nexport const createToken = (token) => make(\"Token\", { token });\n//# sourceMappingURL=createToken.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,WAAW,GAAG,CAAC,KAAK,KAAK,IAAI,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE;;;;"}
+{"version":3,"file":"createToken.mjs","sources":["../../../src/factory/names/createToken.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,WAAW,GAAG,CACzB,KAAY,KACK,IAAI,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE;;;;"}

package/lib/factory/names/createTrue.mjs

@@ -1,5 +1,6 @@
-import { createToken } from './createToken.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createToken } from './createToken.mjs';
 
 /**
  * Create the `true` keyword as a {@link Token}.

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

@@ -1 +1 @@
-{"version":3,"file":"createTrue.mjs","sources":["../../../esm-tmp/factory/names/createTrue.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createToken } from \"./createToken\";\n/**\n * Create the `true` keyword as a {@link Token}.\n *\n * This takes no arguments and wraps the `TrueKeyword` syntax kind. The printer\n * emits the keyword as the boolean literal `true`.\n *\n * This prints:\n *\n * ```ts\n * true;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link Token}.\n */\nexport const createTrue = () => createToken(SyntaxKind.TrueKeyword);\n//# sourceMappingURL=createTrue.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;;;;"}
+{"version":3,"file":"createTrue.mjs","sources":["../../../src/factory/names/createTrue.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,UAAU,GAAG,MAAa,WAAW,CAAC,UAAU,CAAC,WAAW;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createUniqueName.mjs","sources":["../../../esm-tmp/factory/names/createUniqueName.js"],"sourcesContent":["import { createIdentifier } from \"./createIdentifier\";\n/**\n * Create a unique identifier name as a plain {@link Identifier}.\n *\n * The legacy compiler uses a stateful name generator that guarantees the\n * returned identifier is unique within its scope. This package is stateless, so\n * this is a simplified placeholder: it does not guarantee uniqueness, it just\n * returns the given `text` with the optional `prefix` and `suffix` wrapped\n * around it.\n *\n * The `flags` parameter belongs to the stateful generator and is accepted for\n * signature parity but ignored. Two calls with the same arguments produce the\n * same name, so the caller is responsible for avoiding collisions.\n *\n * With `text` of `base` and no prefix or suffix, this prints:\n *\n * ```ts\n * base;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The base name text.\n * @param _flags Ignored; kept for signature parity.\n * @param prefix An optional name prefix.\n * @param suffix An optional name suffix.\n * @returns The created {@link Identifier}.\n */\nexport const createUniqueName = (text, _flags, prefix, suffix) => createIdentifier(`${prefix ?? \"\"}${text}${suffix ?? \"\"}`);\n//# sourceMappingURL=createUniqueName.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,gBAAgB,CAAC,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC;;;;"}
+{"version":3,"file":"createUniqueName.mjs","sources":["../../../src/factory/names/createUniqueName.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,gBAAgB,GAAG,CAC9B,IAAY,EACZ,MAAe,EACf,MAAe,EACf,MAAe,KACA,gBAAgB,CAAC,CAAA,EAAG,MAAM,IAAI,EAAE,CAAA,EAAG,IAAI,CAAA,EAAG,MAAM,IAAI,EAAE,CAAA,CAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createUniquePrivateName.mjs","sources":["../../../esm-tmp/factory/names/createUniquePrivateName.js"],"sourcesContent":["import { createPrivateIdentifier } from \"./createPrivateIdentifier\";\n/**\n * Create a unique private identifier name as a plain {@link PrivateIdentifier}.\n *\n * The legacy compiler uses a stateful name generator that guarantees the\n * returned private identifier is unique within its scope. This package is\n * stateless, so this is a simplified placeholder: it does not guarantee\n * uniqueness, it assembles a name from the optional `prefix`, the `text` (or\n * the fallback `_unique` when omitted), and the optional `suffix`, then\n * delegates to {@link createPrivateIdentifier}. Any leading `#` on `text` is\n * stripped first so the delegate adds exactly one.\n *\n * With no arguments, the fallback applies and this prints:\n *\n * ```ts\n * #_unique;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The base name text, if any.\n * @param prefix An optional name prefix.\n * @param suffix An optional name suffix.\n * @returns The created {@link PrivateIdentifier}.\n */\nexport const createUniquePrivateName = (text, prefix, suffix) => createPrivateIdentifier(`#${prefix ?? \"\"}${text ? text.replace(/^#/, \"\") : \"_unique\"}${suffix ?? \"\"}`);\n//# sourceMappingURL=createUniquePrivateName.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,uBAAuB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,KAAK,uBAAuB,CAAC,CAAC,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC;;;;"}
+{"version":3,"file":"createUniquePrivateName.mjs","sources":["../../../src/factory/names/createUniquePrivateName.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,uBAAuB,GAAG,CACrC,IAAa,EACb,MAAe,EACf,MAAe,KAEf,uBAAuB,CACrB,IAAI,MAAM,IAAI,EAAE,CAAA,EAAG,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,SAAS,CAAA,EAAG,MAAM,IAAI,EAAE,CAAA,CAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createBlock.mjs","sources":["../../../esm-tmp/factory/statements/createBlock.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link Block}: a `{ ... }` statement block.\n *\n * The `statements` become the body, in order. The `multiLine` flag controls how\n * the printer lays the block out: when `true` (the default here), each\n * statement sits on its own indented line between braces; when `false`, the\n * printer keeps the body compact on a single line.\n *\n * With `statements` printing `a()` and `b()` and `multiLine` left at its\n * default, the result is:\n *\n * ```ts\n * {\n *   a();\n *   b();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param statements The statements.\n * @param multiLine When `true`, print one entry per line.\n * @returns The created {@link Block}.\n */\nexport const createBlock = (statements, multiLine) => make(\"Block\", { statements, multiLine: multiLine ?? true });\n//# sourceMappingURL=createBlock.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,WAAW,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,CAAC,OAAO,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,IAAI,IAAI,EAAE;;;;"}
+{"version":3,"file":"createBlock.mjs","sources":["../../../src/factory/statements/createBlock.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,WAAW,GAAG,CACzB,UAAgC,EAChC,SAAmB,KACT,IAAI,CAAC,OAAO,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,IAAI,IAAI,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createBreakStatement.mjs","sources":["../../../esm-tmp/factory/statements/createBreakStatement.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link BreakStatement}: a `break;` statement.\n *\n * The optional `label` names an enclosing labeled statement to break out of. A\n * string is wrapped into an identifier; pass nothing for a plain `break`.\n *\n * With no label the result is:\n *\n * ```ts\n * break;\n * ```\n *\n * With `label` of `outer` the result is:\n *\n * ```ts\n * break outer;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param label The label.\n * @returns The created {@link BreakStatement}.\n */\nexport const createBreakStatement = (label) => make(\"BreakStatement\", {\n    label: label === undefined ? undefined : asName(label),\n});\n//# sourceMappingURL=createBreakStatement.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,oBAAoB,GAAG,CAAC,KAAK,KAAK,IAAI,CAAC,gBAAgB,EAAE;AACtE,IAAI,KAAK,EAAE,KAAK,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC;AAC1D,CAAC;;;;"}
+{"version":3,"file":"createBreakStatement.mjs","sources":["../../../src/factory/statements/createBreakStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,oBAAoB,GAAG,CAClC,KAA2B,KAE3B,IAAI,CAAC,gBAAgB,EAAE;AACrB,IAAA,KAAK,EAAE,KAAK,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC;AACvD,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createCaseBlock.mjs","sources":["../../../esm-tmp/factory/statements/createCaseBlock.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link CaseBlock}: the braced body of a switch statement.\n *\n * The `clauses` are the `case` and `default` arms, printed in the given order\n * between braces. This is the body you hand to {@link createSwitchStatement}; on\n * its own it carries no switch subject.\n *\n * With `clauses` of a `case 1:` arm (calling `a()` then `break`) and a\n * `default:` arm (calling `b()`), the result is:\n *\n * ```ts\n * {\n *   case 1:\n *     a();\n *     break;\n *   default:\n *     b();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param clauses The clauses.\n * @returns The created {@link CaseBlock}.\n */\nexport const createCaseBlock = (clauses) => make(\"CaseBlock\", { clauses });\n//# sourceMappingURL=createCaseBlock.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,eAAe,GAAG,CAAC,OAAO,KAAK,IAAI,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE;;;;"}
+{"version":3,"file":"createCaseBlock.mjs","sources":["../../../src/factory/statements/createCaseBlock.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,eAAe,GAAG,CAC7B,OAAuC,KACzB,IAAI,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createCaseClause.mjs","sources":["../../../esm-tmp/factory/statements/createCaseClause.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link CaseClause}: one `case ...:` arm of a switch.\n *\n * The `expression` is the value matched against the switch subject, and\n * `statements` is the body that runs on a match. Fall-through is the default,\n * so include an explicit `break` in `statements` when you want the arm to\n * stop.\n *\n * With `expression` of `1` and `statements` of `a()` followed by a `break`, the\n * result is:\n *\n * ```ts\n * case 1:\n *   a();\n *   break;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @param statements The statements.\n * @returns The created {@link CaseClause}.\n */\nexport const createCaseClause = (expression, statements) => make(\"CaseClause\", { expression, statements });\n//# sourceMappingURL=createCaseClause.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,gBAAgB,GAAG,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC,YAAY,EAAE,EAAE,UAAU,EAAE,UAAU,EAAE;;;;"}
+{"version":3,"file":"createCaseClause.mjs","sources":["../../../src/factory/statements/createCaseClause.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;AAqBG;MACU,gBAAgB,GAAG,CAC9B,UAAsB,EACtB,UAAgC,KACjB,IAAI,CAAC,YAAY,EAAE,EAAE,UAAU,EAAE,UAAU,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createCatchClause.mjs","sources":["../../../esm-tmp/factory/statements/createCatchClause.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createVariableDeclaration } from \"./createVariableDeclaration\";\n/**\n * Create a {@link CatchClause}: the `catch (...) { ... }` arm of a try.\n *\n * The `variableDeclaration` binds the caught value. Pass a string for the\n * common `catch (e)` case and it is turned into a bare binding; pass a full\n * {@link VariableDeclaration} when you need a type or destructuring pattern;\n * pass `undefined` for the binding-less `catch { ... }` form. The `block` is\n * the handler body.\n *\n * With `variableDeclaration` of `e` and a `block` calling `handle(e)`, the\n * result is:\n *\n * ```ts\n * catch (e) {\n *   handle(e);\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param variableDeclaration The variableDeclaration.\n * @param block The block.\n * @returns The created {@link CatchClause}.\n */\nexport const createCatchClause = (variableDeclaration, block) => make(\"CatchClause\", {\n    variableDeclaration: typeof variableDeclaration === \"string\"\n        ? createVariableDeclaration(variableDeclaration, undefined, undefined, undefined)\n        : variableDeclaration,\n    block,\n});\n//# sourceMappingURL=createCatchClause.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,iBAAiB,GAAG,CAAC,mBAAmB,EAAE,KAAK,KAAK,IAAI,CAAC,aAAa,EAAE;AACrF,IAAI,mBAAmB,EAAE,OAAO,mBAAmB,KAAK;AACxD,UAAU,yBAAyB,CAAC,mBAAmB,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS;AACxF,UAAU,mBAAmB;AAC7B,IAAI,KAAK;AACT,CAAC;;;;"}
+{"version":3,"file":"createCatchClause.mjs","sources":["../../../src/factory/statements/createCatchClause.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,iBAAiB,GAAG,CAC/B,mBAA6D,EAC7D,KAAY,KAEZ,IAAI,CAAC,aAAa,EAAE;AAClB,IAAA,mBAAmB,EACjB,OAAO,mBAAmB,KAAK;UAC3B,yBAAyB,CACvB,mBAAmB,EACnB,SAAS,EACT,SAAS,EACT,SAAS;AAEb,UAAE,mBAAmB;IACzB,KAAK;AACN,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createContinueStatement.mjs","sources":["../../../esm-tmp/factory/statements/createContinueStatement.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link ContinueStatement}: a `continue;` statement.\n *\n * The optional `label` names an enclosing labeled loop to continue. A string is\n * wrapped into an identifier; pass nothing for a plain `continue`.\n *\n * With no label the result is:\n *\n * ```ts\n * continue;\n * ```\n *\n * With `label` of `outer` the result is:\n *\n * ```ts\n * continue outer;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param label The label.\n * @returns The created {@link ContinueStatement}.\n */\nexport const createContinueStatement = (label) => make(\"ContinueStatement\", {\n    label: label === undefined ? undefined : asName(label),\n});\n//# sourceMappingURL=createContinueStatement.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,KAAK,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC5E,IAAI,KAAK,EAAE,KAAK,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC;AAC1D,CAAC;;;;"}
+{"version":3,"file":"createContinueStatement.mjs","sources":["../../../src/factory/statements/createContinueStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,uBAAuB,GAAG,CACrC,KAA2B,KAE3B,IAAI,CAAC,mBAAmB,EAAE;AACxB,IAAA,KAAK,EAAE,KAAK,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC;AACvD,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createDebuggerStatement.mjs","sources":["../../../esm-tmp/factory/statements/createDebuggerStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link DebuggerStatement}: a `debugger;` statement.\n *\n * The statement takes no inputs and triggers a breakpoint when a debugger is\n * attached.\n *\n * The result is always:\n *\n * ```ts\n * debugger;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link DebuggerStatement}.\n */\nexport const createDebuggerStatement = () => make(\"DebuggerStatement\", {});\n//# sourceMappingURL=createDebuggerStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,MAAM,IAAI,CAAC,mBAAmB,EAAE,EAAE;;;;"}
+{"version":3,"file":"createDebuggerStatement.mjs","sources":["../../../src/factory/statements/createDebuggerStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;AAcG;AACI,MAAM,uBAAuB,GAAG,MACrC,IAAI,CAAC,mBAAmB,EAAE,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createDefaultClause.mjs","sources":["../../../esm-tmp/factory/statements/createDefaultClause.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link DefaultClause}: the `default:` arm of a switch.\n *\n * The `statements` form the body that runs when no `case` matches. As with\n * `case` arms, fall-through is the default, so add an explicit `break` when the\n * arm should stop.\n *\n * With `statements` of a single `b()` call, the result is:\n *\n * ```ts\n * default:\n *   b();\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param statements The statements.\n * @returns The created {@link DefaultClause}.\n */\nexport const createDefaultClause = (statements) => make(\"DefaultClause\", { statements });\n//# sourceMappingURL=createDefaultClause.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,UAAU,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE;;;;"}
+{"version":3,"file":"createDefaultClause.mjs","sources":["../../../src/factory/statements/createDefaultClause.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,mBAAmB,GAAG,CACjC,UAAgC,KACd,IAAI,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createDoStatement.mjs","sources":["../../../esm-tmp/factory/statements/createDoStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link DoStatement}: a `do ... while (...)` loop.\n *\n * The `statement` is the loop body and `expression` is the condition tested\n * after each pass, so the body always runs at least once. Note the argument\n * order: the body comes before the condition, matching the source layout.\n *\n * With a `statement` block calling `a()` and an `expression` of `cond`, the\n * result is:\n *\n * ```ts\n * do {\n *   a();\n * } while (cond);\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param statement The statement.\n * @param expression The expression.\n * @returns The created {@link DoStatement}.\n */\nexport const createDoStatement = (statement, expression) => make(\"DoStatement\", { statement, expression });\n//# sourceMappingURL=createDoStatement.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,iBAAiB,GAAG,CAAC,SAAS,EAAE,UAAU,KAAK,IAAI,CAAC,aAAa,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE;;;;"}
+{"version":3,"file":"createDoStatement.mjs","sources":["../../../src/factory/statements/createDoStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,iBAAiB,GAAG,CAC/B,SAAoB,EACpB,UAAsB,KACN,IAAI,CAAC,aAAa,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createEmptyStatement.mjs","sources":["../../../esm-tmp/factory/statements/createEmptyStatement.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createEmptyStatement = () => make(\"EmptyStatement\", {});\n//# sourceMappingURL=createEmptyStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,MAAM,IAAI,CAAC,gBAAgB,EAAE,EAAE;;;;"}
+{"version":3,"file":"createEmptyStatement.mjs","sources":["../../../src/factory/statements/createEmptyStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;AAcG;AACI,MAAM,oBAAoB,GAAG,MAClC,IAAI,CAAC,gBAAgB,EAAE,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createExpressionStatement.mjs","sources":["../../../esm-tmp/factory/statements/createExpressionStatement.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createExpressionStatement = (expression) => make(\"ExpressionStatement\", { expression });\n//# sourceMappingURL=createExpressionStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,yBAAyB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,qBAAqB,EAAE,EAAE,UAAU,EAAE;;;;"}
+{"version":3,"file":"createExpressionStatement.mjs","sources":["../../../src/factory/statements/createExpressionStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,yBAAyB,GAAG,CACvC,UAAsB,KACE,IAAI,CAAC,qBAAqB,EAAE,EAAE,UAAU,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createForInStatement.mjs","sources":["../../../esm-tmp/factory/statements/createForInStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ForInStatement}: a `for (... in ...)` loop.\n *\n * The `initializer` is the binding that receives each enumerable key (a\n * declaration list such as `const key`, or an assignment target), `expression`\n * is the object being enumerated, and `statement` is the loop body. The loop\n * walks the object's enumerable property keys as strings.\n *\n * With an `initializer` of `const key`, an `expression` of `obj`, and a\n * `statement` block calling `use(key)`, the result is:\n *\n * ```ts\n * for (const key in obj) {\n *   use(key);\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param initializer The initializer.\n * @param expression The expression.\n * @param statement The statement.\n * @returns The created {@link ForInStatement}.\n */\nexport const createForInStatement = (initializer, expression, statement) => make(\"ForInStatement\", { initializer, expression, statement });\n//# sourceMappingURL=createForInStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,SAAS,KAAK,IAAI,CAAC,gBAAgB,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}
+{"version":3,"file":"createForInStatement.mjs","sources":["../../../src/factory/statements/createForInStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,oBAAoB,GAAG,CAClC,WAA2B,EAC3B,UAAsB,EACtB,SAAoB,KAEpB,IAAI,CAAC,gBAAgB,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createForOfStatement.mjs","sources":["../../../esm-tmp/factory/statements/createForOfStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ForOfStatement}: a `for (... of ...)` loop.\n *\n * The `initializer` is the binding that receives each element, `expression` is\n * the iterable being walked, and `statement` is the loop body. Pass an `await`\n * token as `awaitModifier` to emit `for await (...)` for async iterables, or\n * `undefined` for the plain form.\n *\n * With `awaitModifier` of `undefined`, an `initializer` of `const item`, an\n * `expression` of `list`, and a `statement` block calling `use(item)`, the\n * result is:\n *\n * ```ts\n * for (const item of list) {\n *   use(item);\n * }\n * ```\n *\n * Passing an `await` token as `awaitModifier` instead yields:\n *\n * ```ts\n * for await (const item of list) {\n *   use(item);\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param awaitModifier The awaitModifier.\n * @param initializer The initializer.\n * @param expression The expression.\n * @param statement The statement.\n * @returns The created {@link ForOfStatement}.\n */\nexport const createForOfStatement = (awaitModifier, initializer, expression, statement) => make(\"ForOfStatement\", { awaitModifier, initializer, expression, statement });\n//# sourceMappingURL=createForOfStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,CAAC,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,KAAK,IAAI,CAAC,gBAAgB,EAAE,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}
+{"version":3,"file":"createForOfStatement.mjs","sources":["../../../src/factory/statements/createForOfStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACI,MAAM,oBAAoB,GAAG,CAClC,aAAgC,EAChC,WAA2B,EAC3B,UAAsB,EACtB,SAAoB,KAEpB,IAAI,CAAC,gBAAgB,EAAE,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createForStatement.mjs","sources":["../../../esm-tmp/factory/statements/createForStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ForStatement}: a C-style `for (init; cond; inc) ...` loop.\n *\n * The `initializer` runs once before the loop (a declaration list or an\n * expression), `condition` is tested before each pass, and `incrementor` runs\n * after each pass; `statement` is the body. Each of the three header parts is\n * optional, so passing `undefined` for all of them yields the infinite `for (;\n * ; )` form.\n *\n * With an `initializer` of `let i = 0`, a `condition` of `i < 10`, an\n * `incrementor` of `i++`, and a `statement` block calling `use(i)`, the result\n * is:\n *\n * ```ts\n * for (let i = 0; i < 10; i++) {\n *   use(i);\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param initializer The initializer.\n * @param condition The condition.\n * @param incrementor The incrementor.\n * @param statement The statement.\n * @returns The created {@link ForStatement}.\n */\nexport const createForStatement = (initializer, condition, incrementor, statement) => make(\"ForStatement\", { initializer, condition, incrementor, statement });\n//# sourceMappingURL=createForStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,CAAC,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE;;;;"}
+{"version":3,"file":"createForStatement.mjs","sources":["../../../src/factory/statements/createForStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,kBAAkB,GAAG,CAChC,WAAuC,EACvC,SAAiC,EACjC,WAAmC,EACnC,SAAoB,KAEpB,IAAI,CAAC,cAAc,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createIfStatement.mjs","sources":["../../../esm-tmp/factory/statements/createIfStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link IfStatement}: an `if (...) ... else ...` statement.\n *\n * The `expression` is the condition, `thenStatement` runs when it holds, and\n * the optional `elseStatement` runs otherwise. Omit `elseStatement` for a bare\n * `if`; to build an `else if` chain, pass another `IfStatement` as\n * `elseStatement`.\n *\n * With an `expression` of `x`, a `thenStatement` block calling `a()`, and an\n * `elseStatement` block calling `b()`, the result is:\n *\n * ```ts\n * if (x) {\n *   a();\n * } else {\n *   b();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @param thenStatement The statement run when the condition holds.\n * @param elseStatement The statement run otherwise, if any.\n * @returns The created {@link IfStatement}.\n */\nexport const createIfStatement = (expression, thenStatement, elseStatement) => make(\"IfStatement\", { expression, thenStatement, elseStatement });\n//# sourceMappingURL=createIfStatement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,iBAAiB,GAAG,CAAC,UAAU,EAAE,aAAa,EAAE,aAAa,KAAK,IAAI,CAAC,aAAa,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE;;;;"}
+{"version":3,"file":"createIfStatement.mjs","sources":["../../../src/factory/statements/createIfStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACI,MAAM,iBAAiB,GAAG,CAC/B,UAAsB,EACtB,aAAwB,EACxB,aAAyB,KAEzB,IAAI,CAAC,aAAa,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE;;;;"}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/lib/factory/statements/createVariableDeclarationList.mjs

@@ -1,5 +1,6 @@
-import { make } from '../internal/make.mjs';
+import '../../syntax/SyntaxKind.mjs';
 import { NodeFlags } from '../../syntax/NodeFlags.mjs';
+import { make } from '../internal/make.mjs';
 
 /**
  * Create a {@link VariableDeclarationList}: the `const x = 1` group.

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

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