@kubb/parser-ts 4.1.3 → 5.0.0-alpha.31

package/package.json

@@ -1,20 +1,18 @@
 {
   "name": "@kubb/parser-ts",
-  "version": "4.1.3",
-  "description": "TypeScript parsing and manipulation utilities for Kubb, enabling code generation with proper TypeScript syntax and formatting.",
+  "version": "5.0.0-alpha.31",
+  "description": "TypeScript and TSX file parser for Kubb, converting generated files to strings using the TypeScript compiler.",
   "keywords": [
     "typescript",
+    "tsx",
     "parser",
-    "ast",
-    "code-generation",
-    "syntax",
-    "formatting",
+    "code-generator",
     "codegen",
     "kubb"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/kubb-labs/kubb.git",
+    "url": "git+https://github.com/kubb-labs/kubb.git",
     "directory": "packages/parser-ts"
   },
   "license": "MIT",
@@ -26,43 +24,32 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
-    "./factory": {
-      "import": "./dist/factory.js",
-      "require": "./dist/factory.cjs"
-    },
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.cts",
-  "typesVersions": {
-    "*": {
-      "factory": [
-        "./dist/factory.d.ts"
-      ]
-    }
-  },
+  "types": "./dist/index.d.ts",
   "files": [
     "src",
     "dist",
     "!/**/**.test.**",
-    "!/**/__tests__/**"
+    "!/**/__tests__/**",
+    "!/**/__snapshots__/**"
   ],
   "dependencies": {
-    "prettier": "^3.6.2",
-    "remeda": "^2.32.0",
-    "typescript": "5.9.3"
+    "typescript": "^6.0.2",
+    "@kubb/core": "5.0.0-alpha.31"
   },
   "devDependencies": {
-    "tsdown": "^0.15.7"
+    "@internals/utils": "0.0.0"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "scripts": {
     "build": "tsdown",
     "clean": "npx rimraf ./dist",

package/src/index.ts

@@ -1,3 +1,2 @@
-export * as factory from './factory.ts'
-export { format } from './format.ts'
-export { print } from './print.ts'
+export { createExport, createImport, parserTs, print, safePrint, validateNodes } from './parserTs.ts'
+export { parserTsx } from './parserTsx.ts'

package/src/parserTs.ts

@@ -0,0 +1,212 @@
+import { normalize, relative } from 'node:path'
+import type { KubbFile, Parser } from '@kubb/core'
+import { defineParser } from '@kubb/core'
+import ts from 'typescript'
+
+const { factory } = ts
+
+function slash(path: string): string {
+  return normalize(path).replaceAll(/\\/g, '/').replace('../', '')
+}
+
+function getRelativePath(rootDir: string, filePath: string): string {
+  const rel = relative(rootDir, filePath)
+  const slashed = slash(rel)
+  return slashed.startsWith('../') ? slashed : `./${slashed}`
+}
+
+function trimExtName(text: string): string {
+  return text.replace(/\.[^/.]+$/, '')
+}
+
+/**
+ * Validates TypeScript AST nodes before printing.
+ * Throws an error if any node has SyntaxKind.Unknown which would cause the
+ * TypeScript printer to crash.
+ */
+export function validateNodes(...nodes: ts.Node[]): void {
+  for (const node of nodes) {
+    if (!node) {
+      throw new Error('Attempted to print undefined or null TypeScript node')
+    }
+    if (node.kind === ts.SyntaxKind.Unknown) {
+      throw new Error(
+        'Invalid TypeScript AST node detected with SyntaxKind.Unknown. ' +
+          'This typically indicates a schema pattern that could not be properly converted to TypeScript. ' +
+          `Node: ${JSON.stringify(node, null, 2)}`,
+      )
+    }
+  }
+}
+
+/**
+ * Converts TypeScript/TSX AST nodes to a string using the TypeScript printer.
+ */
+export function print(...elements: Array<ts.Node>): string {
+  const sourceFile = ts.createSourceFile('print.tsx', '', ts.ScriptTarget.ES2022, true, ts.ScriptKind.TSX)
+
+  const printer = ts.createPrinter({
+    omitTrailingSemicolon: true,
+    newLine: ts.NewLineKind.LineFeed,
+    removeComments: false,
+    noEmitHelpers: true,
+  })
+
+  const output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(elements.filter(Boolean)), sourceFile)
+
+  return output.replace(/\r\n/g, '\n')
+}
+
+/**
+ * Like `print` but validates nodes first to surface issues early.
+ */
+export function safePrint(...elements: Array<ts.Node>): string {
+  validateNodes(...elements)
+  return print(...elements)
+}
+
+export function createImport({
+  name,
+  path,
+  root,
+  isTypeOnly = false,
+  isNameSpace = false,
+}: {
+  name: string | Array<string | { propertyName: string; name?: string }>
+  path: string
+  root?: string
+  /** @default false */
+  isTypeOnly?: boolean
+  /** @default false */
+  isNameSpace?: boolean
+}): ts.ImportDeclaration {
+  const resolvePath = root ? getRelativePath(root, path) : path
+
+  if (!Array.isArray(name)) {
+    if (isNameSpace) {
+      return factory.createImportDeclaration(
+        undefined,
+        factory.createImportClause(isTypeOnly, undefined, factory.createNamespaceImport(factory.createIdentifier(name))),
+        factory.createStringLiteral(resolvePath),
+        undefined,
+      )
+    }
+
+    return factory.createImportDeclaration(
+      undefined,
+      factory.createImportClause(isTypeOnly, factory.createIdentifier(name), undefined),
+      factory.createStringLiteral(resolvePath),
+      undefined,
+    )
+  }
+
+  const specifiers = name.map((item) => {
+    if (typeof item === 'object') {
+      const { propertyName, name: alias } = item
+      return factory.createImportSpecifier(false, alias ? factory.createIdentifier(propertyName) : undefined, factory.createIdentifier(alias ?? propertyName))
+    }
+    return factory.createImportSpecifier(false, undefined, factory.createIdentifier(item))
+  })
+
+  return factory.createImportDeclaration(
+    undefined,
+    factory.createImportClause(isTypeOnly, undefined, factory.createNamedImports(specifiers)),
+    factory.createStringLiteral(resolvePath),
+    undefined,
+  )
+}
+
+export function createExport({
+  path,
+  asAlias,
+  isTypeOnly = false,
+  name,
+}: {
+  path: string
+  /** @default false */
+  asAlias?: boolean
+  /** @default false */
+  isTypeOnly?: boolean
+  name?: string | Array<ts.Identifier | string>
+}): ts.ExportDeclaration {
+  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(
+      undefined,
+      isTypeOnly,
+      asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : undefined,
+      factory.createStringLiteral(path),
+      undefined,
+    )
+  }
+
+  return factory.createExportDeclaration(
+    undefined,
+    isTypeOnly,
+    factory.createNamedExports(
+      name.map((propertyName) =>
+        factory.createExportSpecifier(false, undefined, typeof propertyName === 'string' ? factory.createIdentifier(propertyName) : propertyName),
+      ),
+    ),
+    factory.createStringLiteral(path),
+    undefined,
+  )
+}
+
+/**
+ * Parser that converts `.ts` and `.js` files to strings using the TypeScript
+ * compiler. Handles import/export statement generation from file metadata.
+ *
+ * @default Used automatically when no `parsers` option is set in `defineConfig`.
+ */
+export const parserTs: Parser = defineParser({
+  name: 'typescript',
+  extNames: ['.ts', '.js'],
+  async parse(file, options = { extname: '.ts' }) {
+    const sourceParts: Array<string> = []
+    for (const item of file.sources) {
+      if (item.value) {
+        sourceParts.push(item.value)
+      }
+    }
+    const source = sourceParts.join('\n\n')
+
+    const importNodes: Array<ts.ImportDeclaration> = []
+    for (const item of (file as KubbFile.ResolvedFile).imports) {
+      const importPath = item.root ? getRelativePath(item.root, item.path) : item.path
+      const hasExtname = !!/\.[^/.]+$/.exec(importPath)
+
+      importNodes.push(
+        createImport({
+          name: item.name as string | Array<string | { propertyName: string; name?: string }>,
+          path: options?.extname && hasExtname ? `${trimExtName(importPath)}${options.extname}` : item.root ? trimExtName(importPath) : importPath,
+          isTypeOnly: item.isTypeOnly,
+          isNameSpace: item.isNameSpace,
+        }),
+      )
+    }
+
+    const exportNodes: Array<ts.ExportDeclaration> = []
+    for (const item of (file as KubbFile.ResolvedFile).exports) {
+      const exportPath = item.path
+      const hasExtname = !!/\.[^/.]+$/.exec(exportPath)
+
+      exportNodes.push(
+        createExport({
+          name: item.name as string | Array<ts.Identifier | string> | undefined,
+          path: options?.extname && hasExtname ? `${trimExtName(item.path)}${options.extname}` : trimExtName(item.path),
+          isTypeOnly: item.isTypeOnly,
+          asAlias: item.asAlias,
+        }),
+      )
+    }
+
+    const parts = [file.banner, print(...importNodes, ...exportNodes), source, file.footer].filter((segment): segment is string => segment != null)
+    return parts.join('\n')
+  },
+})

package/src/parserTsx.ts

@@ -0,0 +1,20 @@
+import type { Parser } from '@kubb/core'
+import { defineParser } from '@kubb/core'
+import { parserTs } from './parserTs.ts'
+
+/**
+ * Parser that converts `.tsx` and `.jsx` files to strings.
+ * Delegates to `typescriptParser` since the TypeScript compiler natively
+ * supports JSX/TSX syntax via `ScriptKind.TSX`.
+ *
+ * Add this parser to the `parsers` option in `defineConfig` when generating `.tsx`/`.jsx` files.
+ *
+ * @default extname '.tsx'
+ */
+export const parserTsx: Parser = defineParser({
+  name: 'tsx',
+  extNames: ['.tsx', '.jsx'],
+  async parse(file, options = { extname: '.tsx' }) {
+    return parserTs.parse(file, options)
+  },
+})

package/README.md

@@ -1,52 +0,0 @@
-<div align="center">
-
-<!-- <img src="assets/logo.png" alt="logo" width="200" height="auto" /> -->
-<h1>@kubb/parser-ts</h1>
-
-<p>
-   TypeScript parser
-  </p>
-  <img src="https://raw.githubusercontent.com/kubb-labs/kubb/main/assets/banner.png" alt="logo"  height="auto" />
-
-[![npm version][npm-version-src]][npm-version-href]
-[![npm downloads][npm-downloads-src]][npm-downloads-href]
-[![Coverage][coverage-src]][coverage-href]
-[![License][license-src]][license-href]
-
-<h4>
-    <a href="https://codesandbox.io/s/github/kubb-labs/kubb/tree/main//examples/typescript" target="_blank">View Demo</a>
-    <span> · </span>
-      <a href="https://kubb.dev/" target="_blank">Documentation</a>
-    <span> · </span>
-      <a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Report Bug</a>
-    <span> · </span>
-      <a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Request Feature</a>
-  </h4>
-</div>
-## Supporting Kubb
-
-Kubb uses an MIT-licensed open source project with its ongoing development made possible entirely by the support of Sponsors. If you would like to become a sponsor, please consider:
-
-- [Become a Sponsor on GitHub](https://github.com/sponsors/stijnvanhulle)
-
-<p align="center">
-  <a href="https://github.com/sponsors/stijnvanhulle">
-    <img src="https://raw.githubusercontent.com/stijnvanhulle/sponsors/main/sponsors.svg" alt="My sponsors" />
-  </a>
-</p>
-
-
-<!-- Badges -->
-
-[npm-version-src]: https://img.shields.io/npm/v/@kubb/parser-ts?flat&colorA=18181B&colorB=f58517
-[npm-version-href]: https://npmjs.com/package/@kubb/parser-ts
-[npm-downloads-src]: https://img.shields.io/npm/dm/@kubb/parser-ts?flat&colorA=18181B&colorB=f58517
-[npm-downloads-href]: https://npmjs.com/package/@kubb/parser-ts
-[license-src]: https://img.shields.io/github/license/kubb-labs/kubb.svg?flat&colorA=18181B&colorB=f58517
-[license-href]: https://github.com/kubb-labs/kubb/blob/main/LICENSE
-[build-src]: https://img.shields.io/github/actions/workflow/status/kubb-labs/kubb/ci.yaml?style=flat&colorA=18181B&colorB=f58517
-[build-href]: https://www.npmjs.com/package/@kubb/parser-ts
-[minified-src]: https://img.shields.io/bundlephobia/min/@kubb/parser-ts?style=flat&colorA=18181B&colorB=f58517
-[minified-href]: https://www.npmjs.com/package/@kubb/parser-ts
-[coverage-src]: https://img.shields.io/codecov/c/github/kubb-labs/kubb?style=flat&colorA=18181B&colorB=f58517
-[coverage-href]: https://www.npmjs.com/package/@kubb/parser-ts

package/dist/chunk-CTAAG5j7.js

@@ -1,13 +0,0 @@
-//#region rolldown:runtime
-var __defProp = Object.defineProperty;
-var __export = (all) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	return target;
-};
-
-//#endregion
-export { __export };

package/dist/factory-BB7TA5iA.js

@@ -1,245 +0,0 @@
-import { __export } from "./chunk-CTAAG5j7.js";
-import { isNumber } from "remeda";
-import ts from "typescript";
-
-//#region src/factory.ts
-var factory_exports = /* @__PURE__ */ __export({
-	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
-});
-const { SyntaxKind, factory } = ts;
-const 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)
-};
-const 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;
-}
-const questionToken = factory.createToken(ts.SyntaxKind.QuestionToken);
-function createQuestionToken(token) {
-	if (!token) return;
-	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;
-}
-/**
-* Minimum nodes length of 2
-* @example `string & number`
-*/
-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)]);
-}
-/**
-* Minimum nodes length of 2
-* @example `string | number`
-*/
-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: modifiers$1 = [], name, questionToken: questionToken$1, type }) {
-	return factory.createPropertySignature([...modifiers$1, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : void 0].filter(Boolean), propertyName(name), createQuestionToken(questionToken$1), type);
-}
-function createParameterSignature(name, { modifiers: modifiers$1, dotDotDotToken, questionToken: questionToken$1, type, initializer }) {
-	return factory.createParameterDeclaration(modifiers$1, dotDotDotToken, name, createQuestionToken(questionToken$1), 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}\n`);
-	})));
-}
-/**
-* @link https://github.com/microsoft/TypeScript/issues/44151
-*/
-function appendJSDocToNode({ node, comments }) {
-	const filteredComments = comments.filter(Boolean);
-	if (!filteredComments.length) return node;
-	const text = filteredComments.reduce((acc = "", comment = "") => {
-		return `${acc}\n * ${comment.replaceAll("*/", "*\\/")}`;
-	}, "*");
-	return ts.addSyntheticLeadingComment({ ...node }, ts.SyntaxKind.MultiLineCommentTrivia, `${text || "*"}\n`, true);
-}
-function createIndexSignature(type, { modifiers: modifiers$1, indexName = "key", indexType = factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword) } = {}) {
-	return factory.createIndexSignature(modifiers$1, [createParameterSignature(indexName, { type: indexType })], type);
-}
-function createTypeAliasDeclaration({ modifiers: modifiers$1, name, typeParameters, type }) {
-	return factory.createTypeAliasDeclaration(modifiers$1, name, typeParameters, type);
-}
-function createInterfaceDeclaration({ modifiers: modifiers$1, name, typeParameters, members }) {
-	return factory.createInterfaceDeclaration(modifiers$1, name, typeParameters, void 0, members);
-}
-function createTypeDeclaration({ syntax, isExportable, comments, name, type }) {
-	if (syntax === "interface" && "members" in type) return appendJSDocToNode({
-		node: createInterfaceDeclaration({
-			members: type.members,
-			modifiers: isExportable ? [modifiers.export] : [],
-			name,
-			typeParameters: void 0
-		}),
-		comments
-	});
-	return appendJSDocToNode({
-		node: createTypeAliasDeclaration({
-			type,
-			modifiers: isExportable ? [modifiers.export] : [],
-			name,
-			typeParameters: void 0
-		}),
-		comments
-	});
-}
-function createNamespaceDeclaration({ statements, name }) {
-	return factory.createModuleDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(name), factory.createModuleBlock(statements), ts.NodeFlags.Namespace);
-}
-/**
-* In { propertyName: string; name?: string } is `name` being used to make the type more unique when multiple same names are used.
-* @example `import { Pet as Cat } from './Pet'`
-*/
-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((propertyName$1) => {
-		return factory.createExportSpecifier(false, void 0, typeof propertyName$1 === "string" ? factory.createIdentifier(propertyName$1) : propertyName$1);
-	})), 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()));
-	}).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());
-		if (Number.parseInt(value.toString(), 10) === value && isNumber(Number.parseInt(value.toString(), 10))) initializer = factory.createNumericLiteral(value);
-		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
-		if (isNumber(Number.parseInt(key.toString(), 10))) return factory.createEnumMember(factory.createStringLiteral(`${typeName}_${key}`), initializer);
-		if (key) return factory.createEnumMember(factory.createStringLiteral(`${key}`), initializer);
-	}).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);
-	}).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))]);
-}
-const 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))
-};
-const createTypeLiteralNode = factory.createTypeLiteralNode;
-const createTypeReferenceNode = factory.createTypeReferenceNode;
-const createNumericLiteral = factory.createNumericLiteral;
-const createStringLiteral = factory.createStringLiteral;
-const createArrayTypeNode = factory.createArrayTypeNode;
-const createLiteralTypeNode = factory.createLiteralTypeNode;
-const createNull = factory.createNull;
-const createIdentifier = factory.createIdentifier;
-const createOptionalTypeNode = factory.createOptionalTypeNode;
-const createTupleTypeNode = factory.createTupleTypeNode;
-const createRestTypeNode = factory.createRestTypeNode;
-const createTrue = factory.createTrue;
-const createFalse = factory.createFalse;
-
-//#endregion
-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=factory-BB7TA5iA.js.map