@kubb/parser-ts 3.16.1 → 3.16.3

package/dist/index.js

@@ -1,40 +1,59 @@
-export { factory_exports as factory } from './chunk-BEHWCDCH.js';
-import ts from 'typescript';
-import { format as format$1 } from 'prettier';
-import pluginTypescript from 'prettier/plugins/typescript';
+import { factory_exports } from "./factory-CTKjALU5.js";
+import ts from "typescript";
+import { format as format$1 } from "prettier";
+import pluginTypescript from "prettier/plugins/typescript";
 
-var { factory } = ts;
-var escapeNewLines = (code) => code.replace(/\n\n/g, "\n/* :newline: */");
-var restoreNewLines = (code) => code.replace(/\/\* :newline: \*\//g, "\n");
+//#region src/print.ts
+const { factory } = ts;
+/**
+* Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}
+* @param code The code to escape new lines in
+* @returns The same code but with new lines escaped using block comments
+*/
+const escapeNewLines = (code) => code.replace(/\n\n/g, "\n/* :newline: */");
+/**
+* Reverses {@link escapeNewLines} and restores new lines
+* @param code The code with escaped new lines
+* @returns The same code with new lines restored
+*/
+const restoreNewLines = (code) => code.replace(/\/\* :newline: \*\//g, "\n");
+/**
+* Convert AST TypeScript nodes to a string based on the TypeScript printer.
+* Ensures consistent output across environments.
+*/
 function print(elements, { source = "", baseName = "print.ts", removeComments, noEmitHelpers, newLine = ts.NewLineKind.LineFeed, scriptKind = ts.ScriptKind.TS } = {}) {
-  const sourceFile = ts.createSourceFile(baseName, escapeNewLines(source), ts.ScriptTarget.ES2022, false, scriptKind);
-  const printer = ts.createPrinter({
-    omitTrailingSemicolon: true,
-    newLine,
-    removeComments,
-    noEmitHelpers
-  });
-  const nodes = (Array.isArray(elements) ? elements : [elements]).filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0));
-  const output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile);
-  return restoreNewLines(output).replace(/\r\n/g, "\n");
+	const sourceFile = ts.createSourceFile(baseName, escapeNewLines(source), ts.ScriptTarget.ES2022, false, scriptKind);
+	const printer = ts.createPrinter({
+		omitTrailingSemicolon: true,
+		newLine,
+		removeComments,
+		noEmitHelpers
+	});
+	const nodes = (Array.isArray(elements) ? elements : [elements]).filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0));
+	const output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile);
+	return restoreNewLines(output).replace(/\r\n/g, "\n");
 }
-var formatOptions = {
-  tabWidth: 2,
-  printWidth: 160,
-  parser: "typescript",
-  singleQuote: true,
-  semi: false,
-  bracketSameLine: false,
-  endOfLine: "auto",
-  plugins: [pluginTypescript]
+
+//#endregion
+//#region src/format.ts
+const formatOptions = {
+	tabWidth: 2,
+	printWidth: 160,
+	parser: "typescript",
+	singleQuote: true,
+	semi: false,
+	bracketSameLine: false,
+	endOfLine: "auto",
+	plugins: [pluginTypescript]
 };
+/**
+* Format the generated code based on Prettier
+*/
 async function format(source) {
-  if (!source) {
-    return "";
-  }
-  return format$1(source, formatOptions);
+	if (!source) return "";
+	return format$1(source, formatOptions);
 }
 
-export { format, print };
-//# sourceMappingURL=index.js.map
+//#endregion
+export { factory_exports as factory, format, print };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/print.ts","../src/format.ts"],"names":["prettierFormat"],"mappings":";;;;;AAIA,IAAM,EAAE,SAAY,GAAA,EAAA;AAapB,IAAM,iBAAiB,CAAC,IAAA,KAAiB,IAAK,CAAA,OAAA,CAAQ,SAAS,mBAAmB,CAAA;AAOlF,IAAM,kBAAkB,CAAC,IAAA,KAAiB,IAAK,CAAA,OAAA,CAAQ,wBAAwB,IAAI,CAAA;AAM5E,SAAS,MACd,QACA,EAAA,EAAE,SAAS,EAAI,EAAA,QAAA,GAAW,YAAY,cAAgB,EAAA,aAAA,EAAe,UAAU,EAAG,CAAA,WAAA,CAAY,UAAU,UAAa,GAAA,EAAA,CAAG,WAAW,EAAG,EAAA,GAAkB,EAChJ,EAAA;AACR,EAAM,MAAA,UAAA,GAAa,EAAG,CAAA,gBAAA,CAAiB,QAAU,EAAA,cAAA,CAAe,MAAM,CAAA,EAAG,EAAG,CAAA,YAAA,CAAa,MAAQ,EAAA,KAAA,EAAO,UAAU,CAAA;AAElH,EAAM,MAAA,OAAA,GAAU,GAAG,aAAc,CAAA;AAAA,IAC/B,qBAAuB,EAAA,IAAA;AAAA,IACvB,OAAA;AAAA,IACA,cAAA;AAAA,IACA;AAAA,GACD,CAAA;AAED,EAAM,MAAA,KAAA,GAAA,CAAS,MAAM,OAAQ,CAAA,QAAQ,IAAI,QAAW,GAAA,CAAC,QAAQ,CAAG,EAAA,MAAA,CAAO,OAAO,CAAE,CAAA,IAAA,CAAK,CAAC,CAAG,EAAA,CAAA,KAAA,CAAO,EAAE,GAAO,IAAA,CAAA,KAAM,CAAE,CAAA,GAAA,IAAO,CAAE,CAAA,CAAA;AAE1H,EAAM,MAAA,MAAA,GAAS,OAAQ,CAAA,SAAA,CAAU,EAAG,CAAA,UAAA,CAAW,WAAW,OAAQ,CAAA,eAAA,CAAgB,KAAK,CAAA,EAAG,UAAU,CAAA;AAEpG,EAAA,OAAO,eAAgB,CAAA,MAAM,CAAE,CAAA,OAAA,CAAQ,SAAS,IAAI,CAAA;AACtD;AC3CA,IAAM,aAAyB,GAAA;AAAA,EAC7B,QAAU,EAAA,CAAA;AAAA,EACV,UAAY,EAAA,GAAA;AAAA,EACZ,MAAQ,EAAA,YAAA;AAAA,EACR,WAAa,EAAA,IAAA;AAAA,EACb,IAAM,EAAA,KAAA;AAAA,EACN,eAAiB,EAAA,KAAA;AAAA,EACjB,SAAW,EAAA,MAAA;AAAA,EACX,OAAA,EAAS,CAAC,gBAAgB;AAC5B,CAAA;AAKA,eAAsB,OAAO,MAAgB,EAAA;AAE3C,EAAA,IAAI,CAAC,MAAQ,EAAA;AACX,IAAO,OAAA,EAAA;AAAA;AAGT,EAAO,OAAAA,QAAA,CAAe,QAAQ,aAAa,CAAA;AAC7C","file":"index.js","sourcesContent":["import ts from 'typescript'\n\nimport type { PrinterOptions } from 'typescript'\n\nconst { factory } = ts\n\nexport type PrintOptions = {\n  source?: string\n  baseName?: string\n  scriptKind?: ts.ScriptKind\n} & PrinterOptions\n\n/**\n * Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}\n * @param code The code to escape new lines in\n * @returns The same code but with new lines escaped using block comments\n */\nconst escapeNewLines = (code: string) => code.replace(/\\n\\n/g, '\\n/* :newline: */')\n\n/**\n * Reverses {@link escapeNewLines} and restores new lines\n * @param code The code with escaped new lines\n * @returns The same code with new lines restored\n */\nconst restoreNewLines = (code: string) => code.replace(/\\/\\* :newline: \\*\\//g, '\\n')\n\n/**\n * Convert AST TypeScript nodes to a string based on the TypeScript printer.\n * Ensures consistent output across environments.\n */\nexport function print(\n  elements: Array<ts.Node>,\n  { source = '', baseName = 'print.ts', removeComments, noEmitHelpers, newLine = ts.NewLineKind.LineFeed, scriptKind = ts.ScriptKind.TS }: PrintOptions = {},\n): string {\n  const sourceFile = ts.createSourceFile(baseName, escapeNewLines(source), ts.ScriptTarget.ES2022, false, scriptKind)\n\n  const printer = ts.createPrinter({\n    omitTrailingSemicolon: true,\n    newLine,\n    removeComments,\n    noEmitHelpers,\n  })\n  // make sure that the nodes have the same order on every machine\n  const nodes = (Array.isArray(elements) ? elements : [elements]).filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0))\n\n  const output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile)\n\n  return restoreNewLines(output).replace(/\\r\\n/g, '\\n')\n}\n","import { format as prettierFormat } from 'prettier'\nimport pluginTypescript from 'prettier/plugins/typescript'\n\nimport type { Options } from 'prettier'\n\nconst formatOptions: Options = {\n  tabWidth: 2,\n  printWidth: 160,\n  parser: 'typescript',\n  singleQuote: true,\n  semi: false,\n  bracketSameLine: false,\n  endOfLine: 'auto',\n  plugins: [pluginTypescript],\n}\n\n/**\n * Format the generated code based on Prettier\n */\nexport async function format(source: string) {\n  // do some basic linting with the ts compiler\n  if (!source) {\n    return ''\n  }\n\n  return prettierFormat(source, formatOptions)\n}\n"]}
+{"version":3,"file":"index.js","names":["code: string","elements: Array<ts.Node>","formatOptions: Options","source: string","prettierFormat"],"sources":["../src/print.ts","../src/format.ts"],"sourcesContent":["import ts from 'typescript'\n\nimport type { PrinterOptions } from 'typescript'\n\nconst { factory } = ts\n\nexport type PrintOptions = {\n  source?: string\n  baseName?: string\n  scriptKind?: ts.ScriptKind\n} & PrinterOptions\n\n/**\n * Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}\n * @param code The code to escape new lines in\n * @returns The same code but with new lines escaped using block comments\n */\nconst escapeNewLines = (code: string) => code.replace(/\\n\\n/g, '\\n/* :newline: */')\n\n/**\n * Reverses {@link escapeNewLines} and restores new lines\n * @param code The code with escaped new lines\n * @returns The same code with new lines restored\n */\nconst restoreNewLines = (code: string) => code.replace(/\\/\\* :newline: \\*\\//g, '\\n')\n\n/**\n * Convert AST TypeScript nodes to a string based on the TypeScript printer.\n * Ensures consistent output across environments.\n */\nexport function print(\n  elements: Array<ts.Node>,\n  { source = '', baseName = 'print.ts', removeComments, noEmitHelpers, newLine = ts.NewLineKind.LineFeed, scriptKind = ts.ScriptKind.TS }: PrintOptions = {},\n): string {\n  const sourceFile = ts.createSourceFile(baseName, escapeNewLines(source), ts.ScriptTarget.ES2022, false, scriptKind)\n\n  const printer = ts.createPrinter({\n    omitTrailingSemicolon: true,\n    newLine,\n    removeComments,\n    noEmitHelpers,\n  })\n  // make sure that the nodes have the same order on every machine\n  const nodes = (Array.isArray(elements) ? elements : [elements]).filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0))\n\n  const output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile)\n\n  return restoreNewLines(output).replace(/\\r\\n/g, '\\n')\n}\n","import { format as prettierFormat } from 'prettier'\nimport pluginTypescript from 'prettier/plugins/typescript'\n\nimport type { Options } from 'prettier'\n\nconst formatOptions: Options = {\n  tabWidth: 2,\n  printWidth: 160,\n  parser: 'typescript',\n  singleQuote: true,\n  semi: false,\n  bracketSameLine: false,\n  endOfLine: 'auto',\n  plugins: [pluginTypescript],\n}\n\n/**\n * Format the generated code based on Prettier\n */\nexport async function format(source: string) {\n  // do some basic linting with the ts compiler\n  if (!source) {\n    return ''\n  }\n\n  return prettierFormat(source, formatOptions)\n}\n"],"mappings":";;;;;;AAIA,MAAM,EAAE,SAAS,GAAG;;;;;;AAapB,MAAM,iBAAiB,CAACA,SAAiB,KAAK,QAAQ,SAAS,oBAAoB;;;;;;AAOnF,MAAM,kBAAkB,CAACA,SAAiB,KAAK,QAAQ,wBAAwB,KAAK;;;;;AAMpF,SAAgB,MACdC,UACA,EAAE,SAAS,IAAI,WAAW,YAAY,gBAAgB,eAAe,UAAU,GAAG,YAAY,UAAU,aAAa,GAAG,WAAW,IAAkB,GAAG,CAAE,GAClJ;CACR,MAAM,aAAa,GAAG,iBAAiB,UAAU,eAAe,OAAO,EAAE,GAAG,aAAa,QAAQ,OAAO,WAAW;CAEnH,MAAM,UAAU,GAAG,cAAc;EAC/B,uBAAuB;EACvB;EACA;EACA;CACD,EAAC;CAEF,MAAM,SAAS,MAAM,QAAQ,SAAS,GAAG,WAAW,CAAC,QAAS,GAAE,OAAO,QAAQ,CAAC,KAAK,CAAC,GAAG,OAAO,EAAE,OAAO,MAAM,EAAE,OAAO,GAAG;CAE3H,MAAM,SAAS,QAAQ,UAAU,GAAG,WAAW,WAAW,QAAQ,gBAAgB,MAAM,EAAE,WAAW;AAErG,QAAO,gBAAgB,OAAO,CAAC,QAAQ,SAAS,KAAK;AACtD;;;;AC3CD,MAAMC,gBAAyB;CAC7B,UAAU;CACV,YAAY;CACZ,QAAQ;CACR,aAAa;CACb,MAAM;CACN,iBAAiB;CACjB,WAAW;CACX,SAAS,CAAC,gBAAiB;AAC5B;;;;AAKD,eAAsB,OAAOC,QAAgB;AAE3C,KAAI,CAAC,OACH,QAAO;AAGT,QAAOC,SAAe,QAAQ,cAAc;AAC7C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/parser-ts",
-  "version": "3.16.1",
+  "version": "3.16.3",
   "description": "TypeScript parsing and manipulation utilities for Kubb, enabling code generation with proper TypeScript syntax and formatting.",
   "keywords": [
     "typescript",
@@ -24,19 +24,16 @@
   "exports": {
     ".": {
       "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "default": "./dist/index.cjs"
+      "require": "./dist/index.cjs"
     },
     "./factory": {
       "import": "./dist/factory.js",
-      "require": "./dist/factory.cjs",
-      "default": "./dist/factory.cjs"
+      "require": "./dist/factory.cjs"
     },
-    "./package.json": "./package.json",
-    "./*": "./*"
+    "./package.json": "./package.json"
   },
-  "main": "dist/index.cjs",
-  "module": "dist/index.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.cts",
   "typesVersions": {
     "*": {
@@ -53,13 +50,12 @@
   ],
   "dependencies": {
     "prettier": "^3.6.2",
-    "remeda": "^2.26.0",
-    "typescript": "5.8.3"
+    "remeda": "^2.30.0",
+    "typescript": "5.9.2"
   },
   "devDependencies": {
-    "tsup": "^8.5.0",
-    "@kubb/config-ts": "3.16.1",
-    "@kubb/config-tsup": "3.16.1"
+    "tsdown": "^0.14.1",
+    "@kubb/config-ts": "3.16.3"
   },
   "engines": {
     "node": ">=20"
@@ -69,13 +65,13 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown",
     "clean": "npx rimraf ./dist",
     "lint": "bun biome lint .",
-    "lint:fix": "bun biome lint--fix --unsafe .",
+    "lint:fix": "bun biome lint --fix --unsafe .",
     "release": "pnpm publish --no-git-check",
     "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
-    "start": "tsup --watch",
+    "start": "tsdown --watch",
     "test": "vitest --passWithNoTests",
     "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
   }

package/src/factory.ts

@@ -442,9 +442,9 @@ export function createEnumDeclaration({
         enums
           .map(([key, value]) => {
             let initializer: ts.Expression = factory.createStringLiteral(value?.toString())
-            const isExactNumber = Number.parseInt(value.toString()) === value
+            const isExactNumber = Number.parseInt(value.toString(), 10) === value
 
-            if (isExactNumber && isNumber(Number.parseInt(value.toString()))) {
+            if (isExactNumber && isNumber(Number.parseInt(value.toString(), 10))) {
               initializer = factory.createNumericLiteral(value as number)
             }
 
@@ -452,7 +452,7 @@ export function createEnumDeclaration({
               initializer = value ? factory.createTrue() : factory.createFalse()
             }
 
-            if (isNumber(Number.parseInt(key.toString()))) {
+            if (isNumber(Number.parseInt(key.toString(), 10))) {
               return factory.createEnumMember(factory.createStringLiteral(`${typeName}_${key}`), initializer)
             }
 

package/dist/chunk-BEHWCDCH.js

@@ -1,461 +0,0 @@
-import { isNumber } from 'remeda';
-import ts from 'typescript';
-
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/factory.ts
-var factory_exports = {};
-__export(factory_exports, {
-  appendJSDocToNode: () => appendJSDocToNode,
-  createArrayDeclaration: () => createArrayDeclaration,
-  createArrayTypeNode: () => createArrayTypeNode,
-  createEnumDeclaration: () => createEnumDeclaration,
-  createExportDeclaration: () => createExportDeclaration,
-  createFalse: () => createFalse,
-  createIdentifier: () => createIdentifier,
-  createImportDeclaration: () => createImportDeclaration,
-  createIndexSignature: () => createIndexSignature,
-  createInterfaceDeclaration: () => createInterfaceDeclaration,
-  createIntersectionDeclaration: () => createIntersectionDeclaration,
-  createJSDoc: () => createJSDoc,
-  createLiteralTypeNode: () => createLiteralTypeNode,
-  createNamespaceDeclaration: () => createNamespaceDeclaration,
-  createNull: () => createNull,
-  createNumericLiteral: () => createNumericLiteral,
-  createOmitDeclaration: () => createOmitDeclaration,
-  createOptionalTypeNode: () => createOptionalTypeNode,
-  createParameterSignature: () => createParameterSignature,
-  createPropertySignature: () => createPropertySignature,
-  createQuestionToken: () => createQuestionToken,
-  createRestTypeNode: () => createRestTypeNode,
-  createStringLiteral: () => createStringLiteral,
-  createTrue: () => createTrue,
-  createTupleDeclaration: () => createTupleDeclaration,
-  createTupleTypeNode: () => createTupleTypeNode,
-  createTypeAliasDeclaration: () => createTypeAliasDeclaration,
-  createTypeDeclaration: () => createTypeDeclaration,
-  createTypeLiteralNode: () => createTypeLiteralNode,
-  createTypeReferenceNode: () => createTypeReferenceNode,
-  createUnionDeclaration: () => createUnionDeclaration,
-  keywordTypeNodes: () => keywordTypeNodes,
-  modifiers: () => modifiers,
-  syntaxKind: () => syntaxKind
-});
-var { SyntaxKind, factory } = ts;
-var modifiers = {
-  async: factory.createModifier(ts.SyntaxKind.AsyncKeyword),
-  export: factory.createModifier(ts.SyntaxKind.ExportKeyword),
-  const: factory.createModifier(ts.SyntaxKind.ConstKeyword),
-  static: factory.createModifier(ts.SyntaxKind.StaticKeyword)
-};
-var syntaxKind = {
-  union: SyntaxKind.UnionType
-};
-function isValidIdentifier(str) {
-  if (!str.length || str.trim() !== str) {
-    return false;
-  }
-  const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest);
-  return !!node && node.kind === ts.SyntaxKind.Identifier && ts.identifierToKeywordKind(node.kind) === void 0;
-}
-function propertyName(name) {
-  if (typeof name === "string") {
-    return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
-  }
-  return name;
-}
-var questionToken = factory.createToken(ts.SyntaxKind.QuestionToken);
-function createQuestionToken(token) {
-  if (!token) {
-    return void 0;
-  }
-  if (token === true) {
-    return questionToken;
-  }
-  return token;
-}
-function createIntersectionDeclaration({ nodes, withParentheses }) {
-  if (!nodes.length) {
-    return null;
-  }
-  if (nodes.length === 1) {
-    return nodes[0] || null;
-  }
-  const node = factory.createIntersectionTypeNode(nodes);
-  if (withParentheses) {
-    return factory.createParenthesizedType(node);
-  }
-  return node;
-}
-function createTupleDeclaration({ nodes, withParentheses }) {
-  if (!nodes.length) {
-    return null;
-  }
-  if (nodes.length === 1) {
-    return nodes[0] || null;
-  }
-  const node = factory.createTupleTypeNode(nodes);
-  if (withParentheses) {
-    return factory.createParenthesizedType(node);
-  }
-  return node;
-}
-function createArrayDeclaration({ nodes }) {
-  if (!nodes.length) {
-    return factory.createTupleTypeNode([]);
-  }
-  if (nodes.length === 1) {
-    return factory.createArrayTypeNode(nodes.at(0));
-  }
-  return factory.createExpressionWithTypeArguments(factory.createIdentifier("Array"), [factory.createUnionTypeNode(nodes)]);
-}
-function createUnionDeclaration({ nodes, withParentheses }) {
-  if (!nodes.length) {
-    return keywordTypeNodes.any;
-  }
-  if (nodes.length === 1) {
-    return nodes[0];
-  }
-  const node = factory.createUnionTypeNode(nodes);
-  if (withParentheses) {
-    return factory.createParenthesizedType(node);
-  }
-  return node;
-}
-function createPropertySignature({
-  readOnly,
-  modifiers: modifiers2 = [],
-  name,
-  questionToken: questionToken2,
-  type
-}) {
-  return factory.createPropertySignature(
-    [...modifiers2, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : void 0].filter(Boolean),
-    propertyName(name),
-    createQuestionToken(questionToken2),
-    type
-  );
-}
-function createParameterSignature(name, {
-  modifiers: modifiers2,
-  dotDotDotToken,
-  questionToken: questionToken2,
-  type,
-  initializer
-}) {
-  return factory.createParameterDeclaration(modifiers2, dotDotDotToken, name, createQuestionToken(questionToken2), type, initializer);
-}
-function createJSDoc({ comments }) {
-  if (!comments.length) {
-    return null;
-  }
-  return factory.createJSDocComment(
-    factory.createNodeArray(
-      comments.map((comment, i) => {
-        if (i === comments.length - 1) {
-          return factory.createJSDocText(comment);
-        }
-        return factory.createJSDocText(`${comment}
-`);
-      })
-    )
-  );
-}
-function appendJSDocToNode({ node, comments }) {
-  const filteredComments = comments.filter(Boolean);
-  if (!filteredComments.length) {
-    return node;
-  }
-  const text = filteredComments.reduce((acc = "", comment = "") => {
-    return `${acc}
- * ${comment.replaceAll("*/", "*\\/")}`;
-  }, "*");
-  return ts.addSyntheticLeadingComment({ ...node }, ts.SyntaxKind.MultiLineCommentTrivia, `${text || "*"}
-`, true);
-}
-function createIndexSignature(type, {
-  modifiers: modifiers2,
-  indexName = "key",
-  indexType = factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
-} = {}) {
-  return factory.createIndexSignature(modifiers2, [createParameterSignature(indexName, { type: indexType })], type);
-}
-function createTypeAliasDeclaration({
-  modifiers: modifiers2,
-  name,
-  typeParameters,
-  type
-}) {
-  return factory.createTypeAliasDeclaration(modifiers2, name, typeParameters, type);
-}
-function createInterfaceDeclaration({
-  modifiers: modifiers2,
-  name,
-  typeParameters,
-  members
-}) {
-  return factory.createInterfaceDeclaration(modifiers2, name, typeParameters, void 0, members);
-}
-function createTypeDeclaration({
-  syntax,
-  isExportable,
-  comments,
-  name,
-  type
-}) {
-  if (syntax === "interface" && "members" in type) {
-    const node2 = createInterfaceDeclaration({
-      members: type.members,
-      modifiers: isExportable ? [modifiers.export] : [],
-      name,
-      typeParameters: void 0
-    });
-    return appendJSDocToNode({
-      node: node2,
-      comments
-    });
-  }
-  const node = createTypeAliasDeclaration({
-    type,
-    modifiers: isExportable ? [modifiers.export] : [],
-    name,
-    typeParameters: void 0
-  });
-  return appendJSDocToNode({
-    node,
-    comments
-  });
-}
-function createNamespaceDeclaration({ statements, name }) {
-  return factory.createModuleDeclaration(
-    [factory.createToken(ts.SyntaxKind.ExportKeyword)],
-    factory.createIdentifier(name),
-    factory.createModuleBlock(statements),
-    ts.NodeFlags.Namespace
-  );
-}
-function createImportDeclaration({
-  name,
-  path,
-  isTypeOnly = false,
-  isNameSpace = false
-}) {
-  if (!Array.isArray(name)) {
-    let importPropertyName = factory.createIdentifier(name);
-    let importName;
-    if (isNameSpace) {
-      importPropertyName = void 0;
-      importName = factory.createNamespaceImport(factory.createIdentifier(name));
-    }
-    return factory.createImportDeclaration(
-      void 0,
-      factory.createImportClause(isTypeOnly, importPropertyName, importName),
-      factory.createStringLiteral(path),
-      void 0
-    );
-  }
-  return factory.createImportDeclaration(
-    void 0,
-    factory.createImportClause(
-      isTypeOnly,
-      void 0,
-      factory.createNamedImports(
-        name.map((item) => {
-          if (typeof item === "object") {
-            const obj = item;
-            if (obj.name) {
-              return factory.createImportSpecifier(false, factory.createIdentifier(obj.propertyName), factory.createIdentifier(obj.name));
-            }
-            return factory.createImportSpecifier(false, void 0, factory.createIdentifier(obj.propertyName));
-          }
-          return factory.createImportSpecifier(false, void 0, factory.createIdentifier(item));
-        })
-      )
-    ),
-    factory.createStringLiteral(path),
-    void 0
-  );
-}
-function createExportDeclaration({
-  path,
-  asAlias,
-  isTypeOnly = false,
-  name
-}) {
-  if (name && !Array.isArray(name) && !asAlias) {
-    console.warn(`When using name as string, asAlias should be true ${name}`);
-  }
-  if (!Array.isArray(name)) {
-    const parsedName = name?.match(/^\d/) ? `_${name?.slice(1)}` : name;
-    return factory.createExportDeclaration(
-      void 0,
-      isTypeOnly,
-      asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : void 0,
-      factory.createStringLiteral(path),
-      void 0
-    );
-  }
-  return factory.createExportDeclaration(
-    void 0,
-    isTypeOnly,
-    factory.createNamedExports(
-      name.map((propertyName2) => {
-        return factory.createExportSpecifier(false, void 0, typeof propertyName2 === "string" ? factory.createIdentifier(propertyName2) : propertyName2);
-      })
-    ),
-    factory.createStringLiteral(path),
-    void 0
-  );
-}
-function createEnumDeclaration({
-  type = "enum",
-  name,
-  typeName,
-  enums
-}) {
-  if (type === "literal") {
-    return [
-      void 0,
-      factory.createTypeAliasDeclaration(
-        [factory.createToken(ts.SyntaxKind.ExportKeyword)],
-        factory.createIdentifier(typeName),
-        void 0,
-        factory.createUnionTypeNode(
-          enums.map(([_key, value]) => {
-            if (isNumber(value)) {
-              return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()));
-            }
-            if (typeof value === "boolean") {
-              return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse());
-            }
-            if (value) {
-              return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()));
-            }
-            return void 0;
-          }).filter(Boolean)
-        )
-      )
-    ];
-  }
-  if (type === "enum" || type === "constEnum") {
-    return [
-      void 0,
-      factory.createEnumDeclaration(
-        [factory.createToken(ts.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(ts.SyntaxKind.ConstKeyword) : void 0].filter(Boolean),
-        factory.createIdentifier(typeName),
-        enums.map(([key, value]) => {
-          let initializer = factory.createStringLiteral(value?.toString());
-          const isExactNumber = Number.parseInt(value.toString()) === value;
-          if (isExactNumber && isNumber(Number.parseInt(value.toString()))) {
-            initializer = factory.createNumericLiteral(value);
-          }
-          if (typeof value === "boolean") {
-            initializer = value ? factory.createTrue() : factory.createFalse();
-          }
-          if (isNumber(Number.parseInt(key.toString()))) {
-            return factory.createEnumMember(factory.createStringLiteral(`${typeName}_${key}`), initializer);
-          }
-          if (key) {
-            return factory.createEnumMember(factory.createStringLiteral(`${key}`), initializer);
-          }
-          return void 0;
-        }).filter(Boolean)
-      )
-    ];
-  }
-  const identifierName = type === "asPascalConst" ? typeName : name;
-  return [
-    factory.createVariableStatement(
-      [factory.createToken(ts.SyntaxKind.ExportKeyword)],
-      factory.createVariableDeclarationList(
-        [
-          factory.createVariableDeclaration(
-            factory.createIdentifier(identifierName),
-            void 0,
-            void 0,
-            factory.createAsExpression(
-              factory.createObjectLiteralExpression(
-                enums.map(([key, value]) => {
-                  let initializer = factory.createStringLiteral(value?.toString());
-                  if (isNumber(value)) {
-                    if (value < 0) {
-                      initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
-                    } else {
-                      initializer = factory.createNumericLiteral(value);
-                    }
-                  }
-                  if (typeof value === "boolean") {
-                    initializer = value ? factory.createTrue() : factory.createFalse();
-                  }
-                  if (key) {
-                    return factory.createPropertyAssignment(factory.createStringLiteral(`${key}`), initializer);
-                  }
-                  return void 0;
-                }).filter(Boolean),
-                true
-              ),
-              factory.createTypeReferenceNode(factory.createIdentifier("const"), void 0)
-            )
-          )
-        ],
-        ts.NodeFlags.Const
-      )
-    ),
-    factory.createTypeAliasDeclaration(
-      type === "asPascalConst" ? [] : [factory.createToken(ts.SyntaxKind.ExportKeyword)],
-      factory.createIdentifier(typeName),
-      void 0,
-      factory.createIndexedAccessTypeNode(
-        factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0)),
-        factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0))
-      )
-    )
-  ];
-}
-function createOmitDeclaration({ keys, type, nonNullable }) {
-  const node = nonNullable ? factory.createTypeReferenceNode(factory.createIdentifier("NonNullable"), [type]) : type;
-  if (Array.isArray(keys)) {
-    return factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [
-      node,
-      factory.createUnionTypeNode(
-        keys.map((key) => {
-          return factory.createLiteralTypeNode(factory.createStringLiteral(key));
-        })
-      )
-    ]);
-  }
-  return factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [node, factory.createLiteralTypeNode(factory.createStringLiteral(keys))]);
-}
-var keywordTypeNodes = {
-  any: factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-  unknown: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
-  void: factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),
-  number: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
-  integer: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
-  object: factory.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword),
-  string: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-  boolean: factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),
-  undefined: factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
-  null: factory.createLiteralTypeNode(factory.createToken(ts.SyntaxKind.NullKeyword))
-};
-var createTypeLiteralNode = factory.createTypeLiteralNode;
-var createTypeReferenceNode = factory.createTypeReferenceNode;
-var createNumericLiteral = factory.createNumericLiteral;
-var createStringLiteral = factory.createStringLiteral;
-var createArrayTypeNode = factory.createArrayTypeNode;
-var createLiteralTypeNode = factory.createLiteralTypeNode;
-var createNull = factory.createNull;
-var createIdentifier = factory.createIdentifier;
-var createOptionalTypeNode = factory.createOptionalTypeNode;
-var createTupleTypeNode = factory.createTupleTypeNode;
-var createRestTypeNode = factory.createRestTypeNode;
-var createTrue = factory.createTrue;
-var createFalse = factory.createFalse;
-
-export { appendJSDocToNode, createArrayDeclaration, createArrayTypeNode, createEnumDeclaration, createExportDeclaration, createFalse, createIdentifier, createImportDeclaration, createIndexSignature, createInterfaceDeclaration, createIntersectionDeclaration, createJSDoc, createLiteralTypeNode, createNamespaceDeclaration, createNull, createNumericLiteral, createOmitDeclaration, createOptionalTypeNode, createParameterSignature, createPropertySignature, createQuestionToken, createRestTypeNode, createStringLiteral, createTrue, createTupleDeclaration, createTupleTypeNode, createTypeAliasDeclaration, createTypeDeclaration, createTypeLiteralNode, createTypeReferenceNode, createUnionDeclaration, factory_exports, keywordTypeNodes, modifiers, syntaxKind };
-//# sourceMappingURL=chunk-BEHWCDCH.js.map
-//# sourceMappingURL=chunk-BEHWCDCH.js.map