@ttsc/factory 0.15.10 → 0.15.11

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

@@ -1 +1 @@
-{"version":3,"file":"createVariableStatement.mjs","sources":["../../../esm-tmp/factory/statements/createVariableStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createVariableDeclarationList } from \"./createVariableDeclarationList\";\n/**\n * Create a {@link VariableStatement}: a full `const x = 1;` statement.\n *\n * The optional `modifiers` are leading keywords such as `export` or `declare`.\n * The `declarationList` carries the keyword and declarators; pass a\n * {@link VariableDeclarationList} directly, or pass a plain array of\n * declarations and it is wrapped into a list for you (defaulting to `var`, so\n * build the list yourself when you need `const` or `let`).\n *\n * This is the statement-level wrapper that adds the trailing semicolon. With no\n * modifiers and a `const` declaration list of `x = 1`, the result is:\n *\n * ```ts\n * const x = 1;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param declarationList The declaration list.\n * @returns The created {@link VariableStatement}.\n */\nexport const createVariableStatement = (modifiers, declarationList) => make(\"VariableStatement\", {\n    modifiers,\n    declarationList: Array.isArray(declarationList)\n        ? createVariableDeclarationList(declarationList)\n        : declarationList,\n});\n//# sourceMappingURL=createVariableStatement.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,uBAAuB,GAAG,CAAC,SAAS,EAAE,eAAe,KAAK,IAAI,CAAC,mBAAmB,EAAE;AACjG,IAAI,SAAS;AACb,IAAI,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,eAAe;AAClD,UAAU,6BAA6B,CAAC,eAAe;AACvD,UAAU,eAAe;AACzB,CAAC;;;;"}
+{"version":3,"file":"createVariableStatement.mjs","sources":["../../../src/factory/statements/createVariableStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,uBAAuB,GAAG,CACrC,SAA8C,EAC9C,eAAyE,KAEzE,IAAI,CAAC,mBAAmB,EAAE;IACxB,SAAS;AACT,IAAA,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,eAAe;AAC5C,UAAE,6BAA6B,CAC3B,eAAiD;AAErD,UAAG,eAA2C;AACjD,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createWhileStatement.mjs","sources":["../../../esm-tmp/factory/statements/createWhileStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link WhileStatement}: a `while (...) ...` loop.\n *\n * The `expression` is the condition tested before each pass and `statement` is\n * the loop body. The body runs zero or more times, only while the condition\n * holds.\n *\n * With an `expression` of `cond` and a `statement` block calling `a()`, the\n * result is:\n *\n * ```ts\n * while (cond) {\n *   a();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @param statement The statement.\n * @returns The created {@link WhileStatement}.\n */\nexport const createWhileStatement = (expression, statement) => make(\"WhileStatement\", { expression, statement });\n//# sourceMappingURL=createWhileStatement.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,oBAAoB,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,CAAC,gBAAgB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}
+{"version":3,"file":"createWhileStatement.mjs","sources":["../../../src/factory/statements/createWhileStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,oBAAoB,GAAG,CAClC,UAAsB,EACtB,SAAoB,KACD,IAAI,CAAC,gBAAgB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createWithStatement.mjs","sources":["../../../esm-tmp/factory/statements/createWithStatement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link WithStatement}: a `with (...) ...` statement.\n *\n * The `expression` supplies the object whose properties join the scope of\n * `statement`, the body. `with` is disallowed in strict mode and in ES modules,\n * so this exists mainly for completeness and faithful round-tripping.\n *\n * With an `expression` of `obj` and a `statement` block calling `a()`, the\n * result is:\n *\n * ```ts\n * with (obj) {\n *   a();\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @param statement The statement.\n * @returns The created {@link WithStatement}.\n */\nexport const createWithStatement = (expression, statement) => make(\"WithStatement\", { expression, statement });\n//# sourceMappingURL=createWithStatement.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,mBAAmB,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}
+{"version":3,"file":"createWithStatement.mjs","sources":["../../../src/factory/statements/createWithStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,mBAAmB,GAAG,CACjC,UAAsB,EACtB,SAAoB,KACF,IAAI,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createArrayTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createArrayTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ArrayTypeNode}: a `T[]` postfix array type.\n *\n * The element type is emitted in postfix-operand position, so a\n * lower-precedence form that would otherwise re-associate gets wrapped in\n * parentheses first. A union, intersection, function, constructor, conditional,\n * infer, or type-operator element prints as `(...)[]`; anything else prints\n * bare.\n *\n * Given a `string` element, the printer renders:\n *\n * ```ts\n * string[]\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elementType The element type.\n * @returns The created {@link ArrayTypeNode}.\n */\nexport const createArrayTypeNode = (elementType) => make(\"ArrayTypeNode\", { elementType });\n//# sourceMappingURL=createArrayTypeNode.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,mBAAmB,GAAG,CAAC,WAAW,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,WAAW,EAAE;;;;"}
+{"version":3,"file":"createArrayTypeNode.mjs","sources":["../../../src/factory/types/createArrayTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,mBAAmB,GAAG,CAAC,WAAqB,KACvD,IAAI,CAAC,eAAe,EAAE,EAAE,WAAW,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createCallSignature.mjs","sources":["../../../esm-tmp/factory/types/createCallSignature.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link CallSignature}: a `(params): ReturnType` call signature for an\n * interface or type literal.\n *\n * Optional type parameters print first as `<...>`, then the parameter list,\n * then the return type as `: Type` when present.\n *\n * Given one `x: number` parameter and a `string` return type, the printer\n * renders:\n *\n * ```ts\n * (x: number): string\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type, if any.\n * @returns The created {@link CallSignature}.\n */\nexport const createCallSignature = (typeParameters, parameters, type) => make(\"CallSignature\", { typeParameters, parameters, type });\n//# sourceMappingURL=createCallSignature.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,EAAE,IAAI,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createCallSignature.mjs","sources":["../../../src/factory/types/createCallSignature.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,mBAAmB,GAAG,CACjC,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,KAE1B,IAAI,CAAC,eAAe,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createConditionalTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createConditionalTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ConditionalTypeNode}: a `C extends E ? X : Y` conditional\n * type.\n *\n * The four type arms print in order, joined by `extends`, `?`, and `:`. The\n * printer emits each arm as-is without adding parentheses, so the caller is\n * responsible for wrapping any arm that needs grouping.\n *\n * Given check `T`, extends `U`, true `string`, and false `number`, the printer\n * renders:\n *\n * ```ts\n * T extends U ? string : number\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param checkType The type being tested.\n * @param extendsType The type tested against.\n * @param trueType The branch type when the test passes.\n * @param falseType The branch type when the test fails.\n * @returns The created {@link ConditionalTypeNode}.\n */\nexport const createConditionalTypeNode = (checkType, extendsType, trueType, falseType) => make(\"ConditionalTypeNode\", { checkType, extendsType, trueType, falseType });\n//# sourceMappingURL=createConditionalTypeNode.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,yBAAyB,GAAG,CAAC,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,KAAK,IAAI,CAAC,qBAAqB,EAAE,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE;;;;"}
+{"version":3,"file":"createConditionalTypeNode.mjs","sources":["../../../src/factory/types/createConditionalTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,yBAAyB,GAAG,CACvC,SAAmB,EACnB,WAAqB,EACrB,QAAkB,EAClB,SAAmB,KAEnB,IAAI,CAAC,qBAAqB,EAAE,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createConstructSignature.mjs","sources":["../../../esm-tmp/factory/types/createConstructSignature.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ConstructSignature}: a `new (params): T` construct signature\n * for an interface or type literal.\n *\n * The `new ` keyword prints first, then optional type parameters as `<...>`,\n * the parameter list, and the return type as `: Type` when present.\n *\n * Given one `x: number` parameter and a `Foo` return type, the printer renders:\n *\n * ```ts\n * new (x: number): Foo\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type, if any.\n * @returns The created {@link ConstructSignature}.\n */\nexport const createConstructSignature = (typeParameters, parameters, type) => make(\"ConstructSignature\", { typeParameters, parameters, type });\n//# sourceMappingURL=createConstructSignature.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,wBAAwB,GAAG,CAAC,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,oBAAoB,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createConstructSignature.mjs","sources":["../../../src/factory/types/createConstructSignature.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,wBAAwB,GAAG,CACtC,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,KAE1B,IAAI,CAAC,oBAAoB,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createConstructorTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createConstructorTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ConstructorTypeNode}: a `new (params) => T` constructor type.\n *\n * Any modifiers print first (for example `abstract`), then the `new ` keyword,\n * then optional type parameters as `<...>`, the parameter list, and finally\n * `=>` followed by the return type.\n *\n * Given no modifiers, one `x: number` parameter, and a `Foo` return type, the\n * printer renders:\n *\n * ```ts\n * new (x: number) => Foo\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers, if any.\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type.\n * @returns The created {@link ConstructorTypeNode}.\n */\nexport const createConstructorTypeNode = (modifiers, typeParameters, parameters, type) => make(\"ConstructorTypeNode\", { modifiers, typeParameters, parameters, type });\n//# sourceMappingURL=createConstructorTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,yBAAyB,GAAG,CAAC,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,qBAAqB,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createConstructorTypeNode.mjs","sources":["../../../src/factory/types/createConstructorTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AASA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,yBAAyB,GAAG,CACvC,SAA0C,EAC1C,cAA+D,EAC/D,UAA2C,EAC3C,IAAc,KAEd,IAAI,CAAC,qBAAqB,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createExpressionWithTypeArguments.mjs","sources":["../../../esm-tmp/factory/types/createExpressionWithTypeArguments.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ExpressionWithTypeArguments}: an `Expr<TypeArgs>` form used\n * in heritage clauses such as `extends Base<T>`.\n *\n * The expression prints first, followed by the type arguments as `<...>` when\n * present. With no type arguments only the bare expression prints.\n *\n * Given a `Foo` expression and a single `string` type argument, the printer\n * renders:\n *\n * ```ts\n * Foo<string>;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The base expression.\n * @param typeArguments The generic type arguments, if any.\n * @returns The created {@link ExpressionWithTypeArguments}.\n */\nexport const createExpressionWithTypeArguments = (expression, typeArguments) => make(\"ExpressionWithTypeArguments\", { expression, typeArguments });\n//# sourceMappingURL=createExpressionWithTypeArguments.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,iCAAiC,GAAG,CAAC,UAAU,EAAE,aAAa,KAAK,IAAI,CAAC,6BAA6B,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE;;;;"}
+{"version":3,"file":"createExpressionWithTypeArguments.mjs","sources":["../../../src/factory/types/createExpressionWithTypeArguments.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAOA;;;;;;;;;;;;;;;;;;AAkBG;MACU,iCAAiC,GAAG,CAC/C,UAAsB,EACtB,aAA8C,KAE9C,IAAI,CAAC,6BAA6B,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createFunctionTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createFunctionTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link FunctionTypeNode}: a `(params) => T` function type.\n *\n * Optional type parameters print first as `<...>`, then the parameter list,\n * then `=>` followed by the return type. In postfix and array positions the\n * surrounding printer wraps a function type in parentheses, since `() => T[]`\n * would otherwise read as an array of the return type.\n *\n * Given one `x: number` parameter and a `string` return type, the printer\n * renders:\n *\n * ```ts\n * (x: number) => string;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type.\n * @returns The created {@link FunctionTypeNode}.\n */\nexport const createFunctionTypeNode = (typeParameters, parameters, type) => make(\"FunctionTypeNode\", { typeParameters, parameters, type });\n//# sourceMappingURL=createFunctionTypeNode.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,sBAAsB,GAAG,CAAC,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,kBAAkB,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createFunctionTypeNode.mjs","sources":["../../../src/factory/types/createFunctionTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,sBAAsB,GAAG,CACpC,cAA+D,EAC/D,UAA2C,EAC3C,IAAc,KAEd,IAAI,CAAC,kBAAkB,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createImportTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createImportTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ImportTypeNode}: an `import(\"module\").Qualifier<Args>` type.\n *\n * The `argument` is the module specifier inside `import(...)`. A `qualifier`\n * adds a `.Member` access, and type arguments add `<...>`. When `isTypeOf` is\n * true the whole thing is prefixed with `typeof ` to query a value's type.\n *\n * Given the module `\"foo\"`, qualifier `Bar`, and a single `string` type\n * argument, the printer renders:\n *\n * ```ts\n * import(\"foo\").Bar<string>;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param argument The module specifier inside `import(...)`.\n * @param qualifier The `.Member` access on the import, if any.\n * @param typeArguments The generic type arguments, if any.\n * @param isTypeOf Whether to prefix the type with `typeof`.\n * @returns The created {@link ImportTypeNode}.\n */\nexport const createImportTypeNode = (argument, qualifier, typeArguments, isTypeOf = false) => make(\"ImportTypeNode\", { argument, qualifier, typeArguments, isTypeOf });\n//# sourceMappingURL=createImportTypeNode.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,oBAAoB,GAAG,CAAC,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,GAAG,KAAK,KAAK,IAAI,CAAC,gBAAgB,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,EAAE;;;;"}
+{"version":3,"file":"createImportTypeNode.mjs","sources":["../../../src/factory/types/createImportTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,oBAAoB,GAAG,CAClC,QAAkB,EAClB,SAAsB,EACtB,aAAmC,EACnC,QAAA,GAAoB,KAAK,KAEzB,IAAI,CAAC,gBAAgB,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createIndexSignature.mjs","sources":["../../../esm-tmp/factory/types/createIndexSignature.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link IndexSignatureDeclaration}: a `[key: K]: V` index signature.\n *\n * Any modifiers print first (for example `readonly`), then the single key\n * parameter inside `[...]`, then `: ` followed by the value type.\n *\n * Given no modifiers, a `key: string` parameter, and a `number` value type, the\n * printer renders:\n *\n * ```ts\n * [key: string]: number\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param parameters The index parameter list.\n * @param type The value type.\n * @returns The created {@link IndexSignatureDeclaration}.\n */\nexport const createIndexSignature = (modifiers, parameters, type) => make(\"IndexSignature\", { modifiers, parameters, type });\n//# sourceMappingURL=createIndexSignature.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,SAAS,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,gBAAgB,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createIndexSignature.mjs","sources":["../../../src/factory/types/createIndexSignature.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,oBAAoB,GAAG,CAClC,SAA8C,EAC9C,UAA2C,EAC3C,IAAc,KAEd,IAAI,CAAC,gBAAgB,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createIndexedAccessTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createIndexedAccessTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link IndexedAccessTypeNode}: a `T[K]` indexed access type.\n *\n * The object type is emitted in postfix-operand position, so a lower-precedence\n * form (union, intersection, function, constructor, conditional, infer, or\n * type-operator) gets wrapped in parentheses before the `[...]`. The index type\n * prints bare inside the brackets.\n *\n * Given a `T` object type and a `\"key\"` index, the printer renders:\n *\n * ```ts\n * T[\"key\"];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param objectType The object type being indexed.\n * @param indexType The index type.\n * @returns The created {@link IndexedAccessTypeNode}.\n */\nexport const createIndexedAccessTypeNode = (objectType, indexType) => make(\"IndexedAccessTypeNode\", { objectType, indexType });\n//# sourceMappingURL=createIndexedAccessTypeNode.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,EAAE,SAAS,KAAK,IAAI,CAAC,uBAAuB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}
+{"version":3,"file":"createIndexedAccessTypeNode.mjs","sources":["../../../src/factory/types/createIndexedAccessTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;MACU,2BAA2B,GAAG,CACzC,UAAoB,EACpB,SAAmB,KAEnB,IAAI,CAAC,uBAAuB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createInferTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createInferTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link InferTypeNode}: an `infer R` type used inside the extends\n * clause of a conditional type.\n *\n * The `infer ` keyword prints in front of the type parameter's name. In postfix\n * and array positions the surrounding printer wraps the infer type in\n * parentheses so `infer R[]` does not read as an array.\n *\n * Given a type parameter named `R`, the printer renders:\n *\n * ```ts\n * infer R\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameter The type parameter to infer.\n * @returns The created {@link InferTypeNode}.\n */\nexport const createInferTypeNode = (typeParameter) => make(\"InferTypeNode\", { typeParameter });\n//# sourceMappingURL=createInferTypeNode.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,aAAa,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,aAAa,EAAE;;;;"}
+{"version":3,"file":"createInferTypeNode.mjs","sources":["../../../src/factory/types/createInferTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,mBAAmB,GAAG,CACjC,aAAuC,KACrB,IAAI,CAAC,eAAe,EAAE,EAAE,aAAa,EAAE;;;;"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"createKeywordTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createKeywordTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link KeywordTypeNode}: a built-in keyword type such as `string` or\n * `number`.\n *\n * The kind is a keyword {@link SyntaxKind} like `StringKeyword`,\n * `NumberKeyword`, `BooleanKeyword`, `VoidKeyword`, `AnyKeyword`, or\n * `UnknownKeyword`. The printer emits the keyword's own source text directly,\n * so the node renders as that single word with no surrounding tokens.\n *\n * Given the `StringKeyword` kind, the printer renders:\n *\n * ```ts\n * string;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param kind The token kind.\n * @returns The created {@link KeywordTypeNode}.\n */\nexport const createKeywordTypeNode = (kind) => make(\"KeywordTypeNode\", { keyword: kind });\n//# sourceMappingURL=createKeywordTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createKeywordTypeNode.mjs","sources":["../../../src/factory/types/createKeywordTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,qBAAqB,GAAG,CAAC,IAAgB,KACpD,IAAI,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createLiteralTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createLiteralTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link LiteralTypeNode}: a literal used in type position such as\n * `\"foo\"`, `42`, `true`, or `null`.\n *\n * The printer emits the wrapped literal directly, so the rendered text is\n * exactly that literal's own source. A {@link PrefixUnaryExpression} covers\n * negative numeric literals such as `-1`, and a {@link Token} covers keyword\n * literals such as `true`, `false`, and `null`.\n *\n * Given a `\"foo\"` string literal, the printer renders:\n *\n * ```ts\n * \"foo\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param literal The literal; a {@link PrefixUnaryExpression} covers negative\n *   numeric literals such as `-1`.\n * @returns The created {@link LiteralTypeNode}.\n */\nexport const createLiteralTypeNode = (literal) => make(\"LiteralTypeNode\", { literal });\n//# sourceMappingURL=createLiteralTypeNode.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,qBAAqB,GAAG,CAAC,OAAO,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE;;;;"}
+{"version":3,"file":"createLiteralTypeNode.mjs","sources":["../../../src/factory/types/createLiteralTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAUA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,qBAAqB,GAAG,CACnC,OAKS,KACW,IAAI,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createMappedTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createMappedTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link MappedTypeNode}: a `{ [K in keyof T]: T[K] }` mapped type.\n *\n * The type parameter supplies the key variable and its `in` constraint. When\n * `nameType` is present it adds an `as` key remap, and when `type` is present\n * it adds the `: ValueType` value. The whole thing renders inside `{ ... }` on\n * one line.\n *\n * The `readonlyToken` and `questionToken` carry optional modifier polarity. A\n * plain `readonly` or `?` token prints as `readonly ` and `?`; a `+` or `-`\n * token prefixes the modifier, so it prints as `+readonly`/`-readonly` and\n * `+?`/`-?`.\n *\n * Given a `K in keyof T` parameter and a `T[K]` value with no modifiers, the\n * printer renders:\n *\n * ```ts\n * { [K in keyof T]: T[K] }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param readonlyToken The `readonly` modifier with optional `+`/`-` polarity,\n *   if any.\n * @param typeParameter The key type parameter holding the `in` constraint.\n * @param nameType The `as` key remap type, if any.\n * @param questionToken The optional-marker `?` with optional `+`/`-` polarity,\n *   if any.\n * @param type The mapped value type, if any.\n * @param members The members, if any.\n * @returns The created {@link MappedTypeNode}.\n */\nexport const createMappedTypeNode = (readonlyToken, typeParameter, nameType, questionToken, type, members) => make(\"MappedTypeNode\", {\n    readonlyToken,\n    typeParameter,\n    nameType,\n    questionToken,\n    type,\n    members,\n});\n//# sourceMappingURL=createMappedTypeNode.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;AACY,MAAC,oBAAoB,GAAG,CAAC,aAAa,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC,gBAAgB,EAAE;AACrI,IAAI,aAAa;AACjB,IAAI,aAAa;AACjB,IAAI,QAAQ;AACZ,IAAI,aAAa;AACjB,IAAI,IAAI;AACR,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createMappedTypeNode.mjs","sources":["../../../src/factory/types/createMappedTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;MACU,oBAAoB,GAAG,CAClC,aAAgC,EAChC,aAAuC,EACvC,QAA8B,EAC9B,aAAgC,EAChC,IAA0B,EAC1B,OAA2C,KAE3C,IAAI,CAAC,gBAAgB,EAAE;IACrB,aAAa;IACb,aAAa;IACb,QAAQ;IACR,aAAa;IACb,IAAI;IACJ,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createMethodSignature.mjs","sources":["../../../esm-tmp/factory/types/createMethodSignature.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link MethodSignature}: a `name(params): T` method signature for an\n * interface or type literal.\n *\n * Any modifiers print first, then the name, then a `?` when the question token\n * is present, then optional type parameters as `<...>`, the parameter list, and\n * the return type as `: Type` when present. A string name is normalized to a\n * property name node.\n *\n * Given the name `greet`, one `name: string` parameter, and a `void` return\n * type, the printer renders:\n *\n * ```ts\n * greet(name: string): void\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The method name.\n * @param questionToken The optional marker (`?`), if any.\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type, if any.\n * @returns The created {@link MethodSignature}.\n */\nexport const createMethodSignature = (modifiers, name, questionToken, typeParameters, parameters, type) => make(\"MethodSignature\", {\n    modifiers,\n    name: asPropertyName(name),\n    questionToken,\n    typeParameters,\n    parameters,\n    type,\n});\n//# sourceMappingURL=createMethodSignature.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;AACY,MAAC,qBAAqB,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,iBAAiB,EAAE;AACnI,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;AAC9B,IAAI,aAAa;AACjB,IAAI,cAAc;AAClB,IAAI,UAAU;AACd,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createMethodSignature.mjs","sources":["../../../src/factory/types/createMethodSignature.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAYA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;MACU,qBAAqB,GAAG,CACnC,SAA8C,EAC9C,IAA2B,EAC3B,aAAgC,EAChC,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,KAE1B,IAAI,CAAC,iBAAiB,EAAE;IACtB,SAAS;AACT,IAAA,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;IAC1B,aAAa;IACb,cAAc;IACd,UAAU;IACV,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createNamedTupleMember.mjs","sources":["../../../esm-tmp/factory/types/createNamedTupleMember.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link NamedTupleMember}: a labeled tuple element such as `name:\n * string`.\n *\n * A leading `...` prints when the rest token is present, then the label, then a\n * `?` when the question token is present, then `: ` followed by the type. A\n * string name is normalized to an identifier.\n *\n * Given the label `name` and a `string` type, the printer renders:\n *\n * ```ts\n * name: string;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param dotDotDotToken The rest marker (`...`), if any.\n * @param name The element label.\n * @param questionToken The optional marker (`?`), if any.\n * @param type The element type.\n * @returns The created {@link NamedTupleMember}.\n */\nexport const createNamedTupleMember = (dotDotDotToken, name, questionToken, type) => make(\"NamedTupleMember\", {\n    dotDotDotToken,\n    name: asName(name),\n    questionToken,\n    type,\n});\n//# sourceMappingURL=createNamedTupleMember.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,cAAc,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,KAAK,IAAI,CAAC,kBAAkB,EAAE;AAC9G,IAAI,cAAc;AAClB,IAAI,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;AACtB,IAAI,aAAa;AACjB,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createNamedTupleMember.mjs","sources":["../../../src/factory/types/createNamedTupleMember.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,sBAAsB,GAAG,CACpC,cAAiC,EACjC,IAAyB,EACzB,aAAgC,EAChC,IAAc,KAEd,IAAI,CAAC,kBAAkB,EAAE;IACvB,cAAc;AACd,IAAA,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;IAClB,aAAa;IACb,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createNotEmittedTypeElement.mjs","sources":["../../../esm-tmp/factory/types/createNotEmittedTypeElement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link NotEmittedTypeElement}: a placeholder type-element that\n * carries no syntax of its own.\n *\n * It exists to hold position and attached comments inside a member list without\n * contributing any text. The printer emits the empty string for it, so the\n * rendered output is empty:\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link NotEmittedTypeElement}.\n */\nexport const createNotEmittedTypeElement = () => make(\"NotEmittedTypeElement\", {});\n//# sourceMappingURL=createNotEmittedTypeElement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,2BAA2B,GAAG,MAAM,IAAI,CAAC,uBAAuB,EAAE,EAAE;;;;"}
+{"version":3,"file":"createNotEmittedTypeElement.mjs","sources":["../../../src/factory/types/createNotEmittedTypeElement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;AAUG;AACI,MAAM,2BAA2B,GAAG,MACzC,IAAI,CAAC,uBAAuB,EAAE,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createOptionalTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createOptionalTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link OptionalTypeNode}: a `T?` optional element inside a tuple\n * type.\n *\n * The element type prints first, immediately followed by a `?`. This form is\n * only valid in tuple element position, for example `[string, number?]`.\n *\n * Given a `string` element type, the printer renders:\n *\n * ```ts\n * string?\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The element type.\n * @returns The created {@link OptionalTypeNode}.\n */\nexport const createOptionalTypeNode = (type) => make(\"OptionalTypeNode\", { type });\n//# sourceMappingURL=createOptionalTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createOptionalTypeNode.mjs","sources":["../../../src/factory/types/createOptionalTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,sBAAsB,GAAG,CAAC,IAAc,KACnD,IAAI,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createParenthesizedType.mjs","sources":["../../../esm-tmp/factory/types/createParenthesizedType.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ParenthesizedTypeNode}: a `(T)` explicitly parenthesized type.\n *\n * The printer always wraps the inner type in literal parentheses, so this is\n * the way to force grouping the surrounding printer would not add on its own,\n * for example to disambiguate a union inside a larger type.\n *\n * Given an `A | B` inner type, the printer renders:\n *\n * ```ts\n * A | B;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The inner type to parenthesize.\n * @returns The created {@link ParenthesizedTypeNode}.\n */\nexport const createParenthesizedType = (type) => make(\"ParenthesizedTypeNode\", { type });\n//# sourceMappingURL=createParenthesizedType.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,uBAAuB,EAAE,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createParenthesizedType.mjs","sources":["../../../src/factory/types/createParenthesizedType.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,uBAAuB,GAAG,CACrC,IAAc,KACY,IAAI,CAAC,uBAAuB,EAAE,EAAE,IAAI,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createPropertySignature.mjs","sources":["../../../esm-tmp/factory/types/createPropertySignature.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link PropertySignature}: a `name?: T` property in an interface or\n * type literal.\n *\n * Any modifiers print first (for example `readonly`), then the name, then a `?`\n * when the question token is present, then `: ` followed by the type when\n * present. A string name is normalized to a property name node.\n *\n * Given the name `name`, a present question token, and a `string` type, the\n * printer renders:\n *\n * ```ts\n * name?: string\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The property name.\n * @param questionToken The optional marker (`?`), if any.\n * @param type The property type, if any.\n * @returns The created {@link PropertySignature}.\n */\nexport const createPropertySignature = (modifiers, name, questionToken, type) => make(\"PropertySignature\", {\n    modifiers,\n    name: asPropertyName(name),\n    questionToken,\n    type,\n});\n//# sourceMappingURL=createPropertySignature.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,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC3G,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;AAC9B,IAAI,aAAa;AACjB,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createPropertySignature.mjs","sources":["../../../src/factory/types/createPropertySignature.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,uBAAuB,GAAG,CACrC,SAA8C,EAC9C,IAA2B,EAC3B,aAAgC,EAChC,IAA0B,KAE1B,IAAI,CAAC,mBAAmB,EAAE;IACxB,SAAS;AACT,IAAA,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;IAC1B,aAAa;IACb,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createRestTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createRestTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link RestTypeNode}: a `...T` rest element inside a tuple type.\n *\n * A leading `...` prints in front of the type. This form is only valid in tuple\n * element position, for example `[string, ...number[]]`.\n *\n * Given a `string[]` element type, the printer renders:\n *\n * ```ts\n * ...string[]\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The rest element type.\n * @returns The created {@link RestTypeNode}.\n */\nexport const createRestTypeNode = (type) => make(\"RestTypeNode\", { type });\n//# sourceMappingURL=createRestTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createRestTypeNode.mjs","sources":["../../../src/factory/types/createRestTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;AAeG;AACI,MAAM,kBAAkB,GAAG,CAAC,IAAc,KAC/C,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE;;;;"}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/lib/index.d.ts

@@ -21,7 +21,6 @@ import * as factory from "./factory/index";
 export * as factory from "./factory/index";
 export { SyntaxKind, NodeFlags } from "./syntax";
 export { TsPrinter } from "./TsPrinter";
-export type { TsPrinterOptions } from "./TsPrinter";
 export { addSyntheticLeadingComment, addSyntheticTrailingComment, getSyntheticLeadingComments, getSyntheticTrailingComments, setSyntheticLeadingComments, setSyntheticTrailingComments, } from "./comments";
 export type { SynthesizedComment } from "./comments";
 export type * from "./ast";

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,MAAY,OAAO,4CAAwB;AAE3C;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAY,OAAO,4CAAwB;AAC3C,mCAAiD;AAAxC,oGAAA,UAAU,OAAA;AAAE,mGAAA,SAAS,OAAA;AAC9B,yCAAwC;AAA/B,sGAAA,SAAS,OAAA;AAElB,uCAOoB;AANlB,sHAAA,0BAA0B,OAAA;AAC1B,uHAAA,2BAA2B,OAAA;AAC3B,uHAAA,2BAA2B,OAAA;AAC3B,wHAAA,4BAA4B,OAAA;AAC5B,uHAAA,2BAA2B,OAAA;AAC3B,wHAAA,4BAA4B,OAAA;kBAQf,OAAO"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,MAAY,OAAO,4CAAwB;AAE3C;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAY,OAAO,4CAAwB;AAC3C,mCAAiD;AAAxC,oGAAA,UAAU,OAAA;AAAE,mGAAA,SAAS,OAAA;AAC9B,yCAAwC;AAA/B,sGAAA,SAAS,OAAA;AAClB,uCAOoB;AANlB,sHAAA,0BAA0B,OAAA;AAC1B,uHAAA,2BAA2B,OAAA;AAC3B,uHAAA,2BAA2B,OAAA;AAC3B,wHAAA,4BAA4B,OAAA;AAC5B,uHAAA,2BAA2B,OAAA;AAC3B,wHAAA,4BAA4B,OAAA;kBAQf,OAAO"}

package/lib/index.mjs

@@ -1,8 +1,8 @@
 import * as index from './factory/index.mjs';
+export { SyntaxKind } from './syntax/SyntaxKind.mjs';
+export { NodeFlags } from './syntax/NodeFlags.mjs';
 export { TsPrinter } from './TsPrinter.mjs';
 export { addSyntheticLeadingComment, addSyntheticTrailingComment, getSyntheticLeadingComments, getSyntheticTrailingComments, setSyntheticLeadingComments, setSyntheticTrailingComments } from './comments.mjs';
-export { NodeFlags } from './syntax/NodeFlags.mjs';
-export { SyntaxKind } from './syntax/SyntaxKind.mjs';
 
 
 

package/lib/internal/doc.mjs.map

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

package/lib/syntax/NodeFlags.mjs.map

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

package/lib/syntax/SyntaxKind.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"SyntaxKind.mjs","sources":["../../esm-tmp/syntax/SyntaxKind.js"],"sourcesContent":["/**\n * Token kinds used by {@link factory} and {@link TsPrinter}.\n *\n * An outline of the legacy `ts.SyntaxKind`: it enumerates only the keyword /\n * modifier / operator tokens this hand-written factory and printer understand.\n * Each member's value is its **own source text** (e.g. `QuestionToken = \"?\"`),\n * so a token renders to source by reading its value directly — no lookup table.\n * It is a string-valued enum (deliberately not `const enum`, so consumers\n * compiled with `isolatedModules` can still reference its members).\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport var SyntaxKind;\n(function (SyntaxKind) {\n    // keyword type nodes & literal keywords\n    SyntaxKind[\"AnyKeyword\"] = \"any\";\n    SyntaxKind[\"UnknownKeyword\"] = \"unknown\";\n    SyntaxKind[\"NumberKeyword\"] = \"number\";\n    SyntaxKind[\"BigIntKeyword\"] = \"bigint\";\n    SyntaxKind[\"ObjectKeyword\"] = \"object\";\n    SyntaxKind[\"BooleanKeyword\"] = \"boolean\";\n    SyntaxKind[\"StringKeyword\"] = \"string\";\n    SyntaxKind[\"SymbolKeyword\"] = \"symbol\";\n    SyntaxKind[\"VoidKeyword\"] = \"void\";\n    SyntaxKind[\"UndefinedKeyword\"] = \"undefined\";\n    SyntaxKind[\"NullKeyword\"] = \"null\";\n    SyntaxKind[\"NeverKeyword\"] = \"never\";\n    SyntaxKind[\"TrueKeyword\"] = \"true\";\n    SyntaxKind[\"FalseKeyword\"] = \"false\";\n    SyntaxKind[\"ThisKeyword\"] = \"this\";\n    // modifiers\n    SyntaxKind[\"ExportKeyword\"] = \"export\";\n    SyntaxKind[\"DefaultKeyword\"] = \"default\";\n    SyntaxKind[\"DeclareKeyword\"] = \"declare\";\n    SyntaxKind[\"AbstractKeyword\"] = \"abstract\";\n    SyntaxKind[\"AsyncKeyword\"] = \"async\";\n    SyntaxKind[\"ConstKeyword\"] = \"const\";\n    SyntaxKind[\"PublicKeyword\"] = \"public\";\n    SyntaxKind[\"PrivateKeyword\"] = \"private\";\n    SyntaxKind[\"ProtectedKeyword\"] = \"protected\";\n    SyntaxKind[\"ReadonlyKeyword\"] = \"readonly\";\n    SyntaxKind[\"StaticKeyword\"] = \"static\";\n    SyntaxKind[\"OverrideKeyword\"] = \"override\";\n    SyntaxKind[\"AccessorKeyword\"] = \"accessor\";\n    // heritage / type operators / word operators\n    SyntaxKind[\"ExtendsKeyword\"] = \"extends\";\n    SyntaxKind[\"ImplementsKeyword\"] = \"implements\";\n    SyntaxKind[\"KeyOfKeyword\"] = \"keyof\";\n    SyntaxKind[\"UniqueKeyword\"] = \"unique\";\n    SyntaxKind[\"AssertsKeyword\"] = \"asserts\";\n    SyntaxKind[\"AwaitKeyword\"] = \"await\";\n    SyntaxKind[\"ImportKeyword\"] = \"import\";\n    SyntaxKind[\"NewKeyword\"] = \"new\";\n    SyntaxKind[\"SuperKeyword\"] = \"super\";\n    SyntaxKind[\"InKeyword\"] = \"in\";\n    SyntaxKind[\"InstanceOfKeyword\"] = \"instanceof\";\n    SyntaxKind[\"AsKeyword\"] = \"as\";\n    SyntaxKind[\"SatisfiesKeyword\"] = \"satisfies\";\n    SyntaxKind[\"TypeOfKeyword\"] = \"typeof\";\n    // punctuation\n    SyntaxKind[\"DotDotDotToken\"] = \"...\";\n    SyntaxKind[\"QuestionToken\"] = \"?\";\n    SyntaxKind[\"QuestionDotToken\"] = \"?.\";\n    SyntaxKind[\"ColonToken\"] = \":\";\n    SyntaxKind[\"CommaToken\"] = \",\";\n    SyntaxKind[\"EqualsGreaterThanToken\"] = \"=>\";\n    // arithmetic / unary\n    SyntaxKind[\"PlusToken\"] = \"+\";\n    SyntaxKind[\"MinusToken\"] = \"-\";\n    SyntaxKind[\"AsteriskToken\"] = \"*\";\n    SyntaxKind[\"AsteriskAsteriskToken\"] = \"**\";\n    SyntaxKind[\"SlashToken\"] = \"/\";\n    SyntaxKind[\"PercentToken\"] = \"%\";\n    SyntaxKind[\"PlusPlusToken\"] = \"++\";\n    SyntaxKind[\"MinusMinusToken\"] = \"--\";\n    SyntaxKind[\"ExclamationToken\"] = \"!\";\n    SyntaxKind[\"TildeToken\"] = \"~\";\n    // bitwise\n    SyntaxKind[\"AmpersandToken\"] = \"&\";\n    SyntaxKind[\"BarToken\"] = \"|\";\n    SyntaxKind[\"CaretToken\"] = \"^\";\n    SyntaxKind[\"LessThanLessThanToken\"] = \"<<\";\n    SyntaxKind[\"GreaterThanGreaterThanToken\"] = \">>\";\n    SyntaxKind[\"GreaterThanGreaterThanGreaterThanToken\"] = \">>>\";\n    // relational / equality / logical\n    SyntaxKind[\"LessThanToken\"] = \"<\";\n    SyntaxKind[\"LessThanEqualsToken\"] = \"<=\";\n    SyntaxKind[\"GreaterThanToken\"] = \">\";\n    SyntaxKind[\"GreaterThanEqualsToken\"] = \">=\";\n    SyntaxKind[\"EqualsEqualsToken\"] = \"==\";\n    SyntaxKind[\"EqualsEqualsEqualsToken\"] = \"===\";\n    SyntaxKind[\"ExclamationEqualsToken\"] = \"!=\";\n    SyntaxKind[\"ExclamationEqualsEqualsToken\"] = \"!==\";\n    SyntaxKind[\"AmpersandAmpersandToken\"] = \"&&\";\n    SyntaxKind[\"BarBarToken\"] = \"||\";\n    SyntaxKind[\"QuestionQuestionToken\"] = \"??\";\n    // assignment\n    SyntaxKind[\"EqualsToken\"] = \"=\";\n    SyntaxKind[\"PlusEqualsToken\"] = \"+=\";\n    SyntaxKind[\"MinusEqualsToken\"] = \"-=\";\n    SyntaxKind[\"AsteriskEqualsToken\"] = \"*=\";\n    SyntaxKind[\"SlashEqualsToken\"] = \"/=\";\n    SyntaxKind[\"QuestionQuestionEqualsToken\"] = \"??=\";\n    // comment trivia (not real tokens; unique sentinels for the comment API)\n    SyntaxKind[\"SingleLineCommentTrivia\"] = \"//\";\n    SyntaxKind[\"MultiLineCommentTrivia\"] = \"/*\";\n})(SyntaxKind || (SyntaxKind = {}));\n//# sourceMappingURL=SyntaxKind.js.map"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACU,IAAC;AACX,CAAC,UAAU,UAAU,EAAE;AACvB;AACA,IAAI,UAAU,CAAC,YAAY,CAAC,GAAG,KAAK;AACpC,IAAI,UAAU,CAAC,gBAAgB,CAAC,GAAG,SAAS;AAC5C,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,QAAQ;AAC1C,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,QAAQ;AAC1C,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,QAAQ;AAC1C,IAAI,UAAU,CAAC,gBAAgB,CAAC,GAAG,SAAS;AAC5C,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,QAAQ;AAC1C,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,QAAQ;AAC1C,IAAI,UAAU,CAAC,aAAa,CAAC,GAAG,MAAM;AACtC,IAAI,UAAU,CAAC,kBAAkB,CAAC,GAAG,WAAW;AAChD,IAAI,UAAU,CAAC,aAAa,CAAC,GAAG,MAAM;AACtC,IAAI,UAAU,CAAC,cAAc,CAAC,GAAG,OAAO;AACxC,IAAI,UAAU,CAAC,aAAa,CAAC,GAAG,MAAM;AACtC,IAAI,UAAU,CAAC,cAAc,CAAC,GAAG,OAAO;AACxC,IAAI,UAAU,CAAC,aAAa,CAAC,GAAG,MAAM;AACtC;AACA,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,QAAQ;AAC1C,IAAI,UAAU,CAAC,gBAAgB,CAAC,GAAG,SAAS;AAC5C,IAAI,UAAU,CAAC,gBAAgB,CAAC,GAAG,SAAS;AAC5C,IAAI,UAAU,CAAC,iBAAiB,CAAC,GAAG,UAAU;AAC9C,IAAI,UAAU,CAAC,cAAc,CAAC,GAAG,OAAO;AACxC,IAAI,UAAU,CAAC,cAAc,CAAC,GAAG,OAAO;AACxC,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,QAAQ;AAC1C,IAAI,UAAU,CAAC,gBAAgB,CAAC,GAAG,SAAS;AAC5C,IAAI,UAAU,CAAC,kBAAkB,CAAC,GAAG,WAAW;AAChD,IAAI,UAAU,CAAC,iBAAiB,CAAC,GAAG,UAAU;AAC9C,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,QAAQ;AAC1C,IAAI,UAAU,CAAC,iBAAiB,CAAC,GAAG,UAAU;AAC9C,IAAI,UAAU,CAAC,iBAAiB,CAAC,GAAG,UAAU;AAC9C;AACA,IAAI,UAAU,CAAC,gBAAgB,CAAC,GAAG,SAAS;AAC5C,IAAI,UAAU,CAAC,mBAAmB,CAAC,GAAG,YAAY;AAClD,IAAI,UAAU,CAAC,cAAc,CAAC,GAAG,OAAO;AACxC,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,QAAQ;AAC1C,IAAI,UAAU,CAAC,gBAAgB,CAAC,GAAG,SAAS;AAC5C,IAAI,UAAU,CAAC,cAAc,CAAC,GAAG,OAAO;AACxC,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,QAAQ;AAC1C,IAAI,UAAU,CAAC,YAAY,CAAC,GAAG,KAAK;AACpC,IAAI,UAAU,CAAC,cAAc,CAAC,GAAG,OAAO;AACxC,IAAI,UAAU,CAAC,WAAW,CAAC,GAAG,IAAI;AAClC,IAAI,UAAU,CAAC,mBAAmB,CAAC,GAAG,YAAY;AAClD,IAAI,UAAU,CAAC,WAAW,CAAC,GAAG,IAAI;AAClC,IAAI,UAAU,CAAC,kBAAkB,CAAC,GAAG,WAAW;AAChD,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,QAAQ;AAC1C;AACA,IAAI,UAAU,CAAC,gBAAgB,CAAC,GAAG,KAAK;AACxC,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,GAAG;AACrC,IAAI,UAAU,CAAC,kBAAkB,CAAC,GAAG,IAAI;AACzC,IAAI,UAAU,CAAC,YAAY,CAAC,GAAG,GAAG;AAClC,IAAI,UAAU,CAAC,YAAY,CAAC,GAAG,GAAG;AAClC,IAAI,UAAU,CAAC,wBAAwB,CAAC,GAAG,IAAI;AAC/C;AACA,IAAI,UAAU,CAAC,WAAW,CAAC,GAAG,GAAG;AACjC,IAAI,UAAU,CAAC,YAAY,CAAC,GAAG,GAAG;AAClC,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,GAAG;AACrC,IAAI,UAAU,CAAC,uBAAuB,CAAC,GAAG,IAAI;AAC9C,IAAI,UAAU,CAAC,YAAY,CAAC,GAAG,GAAG;AAClC,IAAI,UAAU,CAAC,cAAc,CAAC,GAAG,GAAG;AACpC,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,IAAI;AACtC,IAAI,UAAU,CAAC,iBAAiB,CAAC,GAAG,IAAI;AACxC,IAAI,UAAU,CAAC,kBAAkB,CAAC,GAAG,GAAG;AACxC,IAAI,UAAU,CAAC,YAAY,CAAC,GAAG,GAAG;AAClC;AACA,IAAI,UAAU,CAAC,gBAAgB,CAAC,GAAG,GAAG;AACtC,IAAI,UAAU,CAAC,UAAU,CAAC,GAAG,GAAG;AAChC,IAAI,UAAU,CAAC,YAAY,CAAC,GAAG,GAAG;AAClC,IAAI,UAAU,CAAC,uBAAuB,CAAC,GAAG,IAAI;AAC9C,IAAI,UAAU,CAAC,6BAA6B,CAAC,GAAG,IAAI;AACpD,IAAI,UAAU,CAAC,wCAAwC,CAAC,GAAG,KAAK;AAChE;AACA,IAAI,UAAU,CAAC,eAAe,CAAC,GAAG,GAAG;AACrC,IAAI,UAAU,CAAC,qBAAqB,CAAC,GAAG,IAAI;AAC5C,IAAI,UAAU,CAAC,kBAAkB,CAAC,GAAG,GAAG;AACxC,IAAI,UAAU,CAAC,wBAAwB,CAAC,GAAG,IAAI;AAC/C,IAAI,UAAU,CAAC,mBAAmB,CAAC,GAAG,IAAI;AAC1C,IAAI,UAAU,CAAC,yBAAyB,CAAC,GAAG,KAAK;AACjD,IAAI,UAAU,CAAC,wBAAwB,CAAC,GAAG,IAAI;AAC/C,IAAI,UAAU,CAAC,8BAA8B,CAAC,GAAG,KAAK;AACtD,IAAI,UAAU,CAAC,yBAAyB,CAAC,GAAG,IAAI;AAChD,IAAI,UAAU,CAAC,aAAa,CAAC,GAAG,IAAI;AACpC,IAAI,UAAU,CAAC,uBAAuB,CAAC,GAAG,IAAI;AAC9C;AACA,IAAI,UAAU,CAAC,aAAa,CAAC,GAAG,GAAG;AACnC,IAAI,UAAU,CAAC,iBAAiB,CAAC,GAAG,IAAI;AACxC,IAAI,UAAU,CAAC,kBAAkB,CAAC,GAAG,IAAI;AACzC,IAAI,UAAU,CAAC,qBAAqB,CAAC,GAAG,IAAI;AAC5C,IAAI,UAAU,CAAC,kBAAkB,CAAC,GAAG,IAAI;AACzC,IAAI,UAAU,CAAC,6BAA6B,CAAC,GAAG,KAAK;AACrD;AACA,IAAI,UAAU,CAAC,yBAAyB,CAAC,GAAG,IAAI;AAChD,IAAI,UAAU,CAAC,wBAAwB,CAAC,GAAG,IAAI;AAC/C,CAAC,EAAE,UAAU,KAAK,UAAU,GAAG,EAAE,CAAC,CAAC;;;;"}
+{"version":3,"file":"SyntaxKind.mjs","sources":["../../src/syntax/SyntaxKind.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ttsc/factory",
-  "version": "0.15.10",
+  "version": "0.15.11",
   "description": "Self-contained legacy-style TypeScript AST factory and printer for source code generation, surviving the TypeScript-Go (tsgo) migration. Zero dependencies, no `typescript` import.",
   "main": "lib/index.js",
   "exports": {
     ".": {
       "types": "./lib/index.d.ts",
       "import": "./lib/index.mjs",
-      "require": "./lib/index.js"
+      "default": "./lib/index.js"
     },
     "./package.json": "./package.json"
   },
@@ -22,14 +22,9 @@
   },
   "homepage": "https://ttsc.dev",
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^29.0.0",
-    "@rollup/plugin-node-resolve": "^16.0.3",
-    "@typescript/native-preview": "7.0.0-dev.20260617.2",
+    "@typescript/native-preview": "7.0.0-dev.20260618.1",
     "rimraf": "^6.1.2",
-    "rollup": "^4.56.0",
-    "rollup-plugin-auto-external": "^2.0.0",
-    "rollup-plugin-node-externals": "^8.1.2",
-    "tinyglobby": "^0.2.12"
+    "rollup": "^4.56.0"
   },
   "sideEffects": false,
   "files": [
@@ -57,7 +52,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rimraf lib esm-tmp && tsgo -p . && tsgo -p tsconfig.esm.json && rollup -c && rimraf esm-tmp",
+    "build": "rimraf lib && tsgo && rollup -c",
     "dev": "tsgo -p . --watch"
   },
   "module": "lib/index.mjs",