@kubb/parser-ts 3.16.2 → 3.16.4

package/dist/factory-_F-JTqnG.d.cts

@@ -0,0 +1,230 @@
+import ts from "typescript";
+
+//#region rolldown:runtime
+declare namespace factory_d_exports {
+  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, keywordTypeNodes, modifiers, syntaxKind };
+}
+declare const modifiers: {
+  readonly async: ts.ModifierToken<ts.SyntaxKind.AsyncKeyword>;
+  readonly export: ts.ModifierToken<ts.SyntaxKind.ExportKeyword>;
+  readonly const: ts.ModifierToken<ts.SyntaxKind.ConstKeyword>;
+  readonly static: ts.ModifierToken<ts.SyntaxKind.StaticKeyword>;
+};
+declare const syntaxKind: {
+  readonly union: 192;
+};
+declare function createQuestionToken(token?: boolean | ts.QuestionToken): ts.PunctuationToken<ts.SyntaxKind.QuestionToken> | undefined;
+declare function createIntersectionDeclaration({
+  nodes,
+  withParentheses
+}: {
+  nodes: Array<ts.TypeNode>;
+  withParentheses?: boolean;
+}): ts.TypeNode | null;
+/**
+ * Minimum nodes length of 2
+ * @example `string & number`
+ */
+declare function createTupleDeclaration({
+  nodes,
+  withParentheses
+}: {
+  nodes: Array<ts.TypeNode>;
+  withParentheses?: boolean;
+}): ts.TypeNode | null;
+declare function createArrayDeclaration({
+  nodes
+}: {
+  nodes: Array<ts.TypeNode>;
+}): ts.TypeNode | null;
+/**
+ * Minimum nodes length of 2
+ * @example `string | number`
+ */
+declare function createUnionDeclaration({
+  nodes,
+  withParentheses
+}: {
+  nodes: Array<ts.TypeNode>;
+  withParentheses?: boolean;
+}): ts.TypeNode;
+declare function createPropertySignature({
+  readOnly,
+  modifiers,
+  name,
+  questionToken,
+  type
+}: {
+  readOnly?: boolean;
+  modifiers?: Array<ts.Modifier>;
+  name: ts.PropertyName | string;
+  questionToken?: ts.QuestionToken | boolean;
+  type?: ts.TypeNode;
+}): ts.PropertySignature;
+declare function createParameterSignature(name: string | ts.BindingName, {
+  modifiers,
+  dotDotDotToken,
+  questionToken,
+  type,
+  initializer
+}: {
+  decorators?: Array<ts.Decorator>;
+  modifiers?: Array<ts.Modifier>;
+  dotDotDotToken?: ts.DotDotDotToken;
+  questionToken?: ts.QuestionToken | boolean;
+  type?: ts.TypeNode;
+  initializer?: ts.Expression;
+}): ts.ParameterDeclaration;
+declare function createJSDoc({
+  comments
+}: {
+  comments: string[];
+}): ts.JSDoc | null;
+/**
+ * @link https://github.com/microsoft/TypeScript/issues/44151
+ */
+declare function appendJSDocToNode<TNode extends ts.Node>({
+  node,
+  comments
+}: {
+  node: TNode;
+  comments: Array<string | undefined>;
+}): TNode;
+declare function createIndexSignature(type: ts.TypeNode, {
+  modifiers,
+  indexName,
+  indexType
+}?: {
+  indexName?: string;
+  indexType?: ts.TypeNode;
+  decorators?: Array<ts.Decorator>;
+  modifiers?: Array<ts.Modifier>;
+}): ts.IndexSignatureDeclaration;
+declare function createTypeAliasDeclaration({
+  modifiers,
+  name,
+  typeParameters,
+  type
+}: {
+  modifiers?: Array<ts.Modifier>;
+  name: string | ts.Identifier;
+  typeParameters?: Array<ts.TypeParameterDeclaration>;
+  type: ts.TypeNode;
+}): ts.TypeAliasDeclaration;
+declare function createInterfaceDeclaration({
+  modifiers,
+  name,
+  typeParameters,
+  members
+}: {
+  modifiers?: Array<ts.Modifier>;
+  name: string | ts.Identifier;
+  typeParameters?: Array<ts.TypeParameterDeclaration>;
+  members: Array<ts.TypeElement>;
+}): ts.InterfaceDeclaration;
+declare function createTypeDeclaration({
+  syntax,
+  isExportable,
+  comments,
+  name,
+  type
+}: {
+  syntax: 'type' | 'interface';
+  comments: Array<string | undefined>;
+  isExportable?: boolean;
+  name: string | ts.Identifier;
+  type: ts.TypeNode;
+}): ts.TypeAliasDeclaration | ts.InterfaceDeclaration;
+declare function createNamespaceDeclaration({
+  statements,
+  name
+}: {
+  name: string;
+  statements: ts.Statement[];
+}): ts.ModuleDeclaration;
+/**
+ * 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'`
+ */
+declare function createImportDeclaration({
+  name,
+  path,
+  isTypeOnly,
+  isNameSpace
+}: {
+  name: string | Array<string | {
+    propertyName: string;
+    name?: string;
+  }>;
+  path: string;
+  isTypeOnly?: boolean;
+  isNameSpace?: boolean;
+}): ts.ImportDeclaration;
+declare function createExportDeclaration({
+  path,
+  asAlias,
+  isTypeOnly,
+  name
+}: {
+  path: string;
+  asAlias?: boolean;
+  isTypeOnly?: boolean;
+  name?: string | Array<ts.Identifier | string>;
+}): ts.ExportDeclaration;
+declare function createEnumDeclaration({
+  type,
+  name,
+  typeName,
+  enums
+}: {
+  /**
+   * @default `'enum'`
+   */
+  type?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal';
+  /**
+   * Enum name in camelCase.
+   */
+  name: string;
+  /**
+   * Enum name in PascalCase.
+   */
+  typeName: string;
+  enums: [key: string | number, value: string | number | boolean][];
+}): [name: ts.Node | undefined, type: ts.Node];
+declare function createOmitDeclaration({
+  keys,
+  type,
+  nonNullable
+}: {
+  keys: Array<string> | string;
+  type: ts.TypeNode;
+  nonNullable?: boolean;
+}): ts.TypeReferenceNode;
+declare const keywordTypeNodes: {
+  readonly any: ts.KeywordTypeNode<ts.SyntaxKind.AnyKeyword>;
+  readonly unknown: ts.KeywordTypeNode<ts.SyntaxKind.UnknownKeyword>;
+  readonly void: ts.KeywordTypeNode<ts.SyntaxKind.VoidKeyword>;
+  readonly number: ts.KeywordTypeNode<ts.SyntaxKind.NumberKeyword>;
+  readonly integer: ts.KeywordTypeNode<ts.SyntaxKind.NumberKeyword>;
+  readonly object: ts.KeywordTypeNode<ts.SyntaxKind.ObjectKeyword>;
+  readonly string: ts.KeywordTypeNode<ts.SyntaxKind.StringKeyword>;
+  readonly boolean: ts.KeywordTypeNode<ts.SyntaxKind.BooleanKeyword>;
+  readonly undefined: ts.KeywordTypeNode<ts.SyntaxKind.UndefinedKeyword>;
+  readonly null: ts.LiteralTypeNode;
+};
+declare const createTypeLiteralNode: (members: readonly ts.TypeElement[] | undefined) => ts.TypeLiteralNode;
+declare const createTypeReferenceNode: (typeName: string | ts.EntityName, typeArguments?: readonly ts.TypeNode[]) => ts.TypeReferenceNode;
+declare const createNumericLiteral: (value: string | number, numericLiteralFlags?: ts.TokenFlags) => ts.NumericLiteral;
+declare const createStringLiteral: (text: string, isSingleQuote?: boolean) => ts.StringLiteral;
+declare const createArrayTypeNode: (elementType: ts.TypeNode) => ts.ArrayTypeNode;
+declare const createLiteralTypeNode: (literal: ts.LiteralTypeNode["literal"]) => ts.LiteralTypeNode;
+declare const createNull: () => ts.NullLiteral;
+declare const createIdentifier: (text: string) => ts.Identifier;
+declare const createOptionalTypeNode: (type: ts.TypeNode) => ts.OptionalTypeNode;
+declare const createTupleTypeNode: (elements: readonly (ts.TypeNode | ts.NamedTupleMember)[]) => ts.TupleTypeNode;
+declare const createRestTypeNode: (type: ts.TypeNode) => ts.RestTypeNode;
+declare const createTrue: () => ts.TrueLiteral;
+declare const createFalse: () => ts.FalseLiteral;
+//#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_d_exports, keywordTypeNodes, modifiers, syntaxKind };
+//# sourceMappingURL=factory-_F-JTqnG.d.cts.map

package/dist/factory.cjs

@@ -1,144 +1,36 @@
-'use strict';
+const require_factory = require('./factory-DeJMlphM.cjs');
 
-var chunkFIHRQE7D_cjs = require('./chunk-FIHRQE7D.cjs');
-
-
-
-Object.defineProperty(exports, "appendJSDocToNode", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.appendJSDocToNode; }
-});
-Object.defineProperty(exports, "createArrayDeclaration", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createArrayDeclaration; }
-});
-Object.defineProperty(exports, "createArrayTypeNode", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createArrayTypeNode; }
-});
-Object.defineProperty(exports, "createEnumDeclaration", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createEnumDeclaration; }
-});
-Object.defineProperty(exports, "createExportDeclaration", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createExportDeclaration; }
-});
-Object.defineProperty(exports, "createFalse", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createFalse; }
-});
-Object.defineProperty(exports, "createIdentifier", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createIdentifier; }
-});
-Object.defineProperty(exports, "createImportDeclaration", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createImportDeclaration; }
-});
-Object.defineProperty(exports, "createIndexSignature", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createIndexSignature; }
-});
-Object.defineProperty(exports, "createInterfaceDeclaration", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createInterfaceDeclaration; }
-});
-Object.defineProperty(exports, "createIntersectionDeclaration", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createIntersectionDeclaration; }
-});
-Object.defineProperty(exports, "createJSDoc", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createJSDoc; }
-});
-Object.defineProperty(exports, "createLiteralTypeNode", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createLiteralTypeNode; }
-});
-Object.defineProperty(exports, "createNamespaceDeclaration", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createNamespaceDeclaration; }
-});
-Object.defineProperty(exports, "createNull", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createNull; }
-});
-Object.defineProperty(exports, "createNumericLiteral", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createNumericLiteral; }
-});
-Object.defineProperty(exports, "createOmitDeclaration", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createOmitDeclaration; }
-});
-Object.defineProperty(exports, "createOptionalTypeNode", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createOptionalTypeNode; }
-});
-Object.defineProperty(exports, "createParameterSignature", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createParameterSignature; }
-});
-Object.defineProperty(exports, "createPropertySignature", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createPropertySignature; }
-});
-Object.defineProperty(exports, "createQuestionToken", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createQuestionToken; }
-});
-Object.defineProperty(exports, "createRestTypeNode", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createRestTypeNode; }
-});
-Object.defineProperty(exports, "createStringLiteral", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createStringLiteral; }
-});
-Object.defineProperty(exports, "createTrue", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createTrue; }
-});
-Object.defineProperty(exports, "createTupleDeclaration", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createTupleDeclaration; }
-});
-Object.defineProperty(exports, "createTupleTypeNode", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createTupleTypeNode; }
-});
-Object.defineProperty(exports, "createTypeAliasDeclaration", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createTypeAliasDeclaration; }
-});
-Object.defineProperty(exports, "createTypeDeclaration", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createTypeDeclaration; }
-});
-Object.defineProperty(exports, "createTypeLiteralNode", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createTypeLiteralNode; }
-});
-Object.defineProperty(exports, "createTypeReferenceNode", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createTypeReferenceNode; }
-});
-Object.defineProperty(exports, "createUnionDeclaration", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.createUnionDeclaration; }
-});
-Object.defineProperty(exports, "keywordTypeNodes", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.keywordTypeNodes; }
-});
-Object.defineProperty(exports, "modifiers", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.modifiers; }
-});
-Object.defineProperty(exports, "syntaxKind", {
-  enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.syntaxKind; }
-});
-//# sourceMappingURL=factory.cjs.map
-//# sourceMappingURL=factory.cjs.map
+exports.appendJSDocToNode = require_factory.appendJSDocToNode;
+exports.createArrayDeclaration = require_factory.createArrayDeclaration;
+exports.createArrayTypeNode = require_factory.createArrayTypeNode;
+exports.createEnumDeclaration = require_factory.createEnumDeclaration;
+exports.createExportDeclaration = require_factory.createExportDeclaration;
+exports.createFalse = require_factory.createFalse;
+exports.createIdentifier = require_factory.createIdentifier;
+exports.createImportDeclaration = require_factory.createImportDeclaration;
+exports.createIndexSignature = require_factory.createIndexSignature;
+exports.createInterfaceDeclaration = require_factory.createInterfaceDeclaration;
+exports.createIntersectionDeclaration = require_factory.createIntersectionDeclaration;
+exports.createJSDoc = require_factory.createJSDoc;
+exports.createLiteralTypeNode = require_factory.createLiteralTypeNode;
+exports.createNamespaceDeclaration = require_factory.createNamespaceDeclaration;
+exports.createNull = require_factory.createNull;
+exports.createNumericLiteral = require_factory.createNumericLiteral;
+exports.createOmitDeclaration = require_factory.createOmitDeclaration;
+exports.createOptionalTypeNode = require_factory.createOptionalTypeNode;
+exports.createParameterSignature = require_factory.createParameterSignature;
+exports.createPropertySignature = require_factory.createPropertySignature;
+exports.createQuestionToken = require_factory.createQuestionToken;
+exports.createRestTypeNode = require_factory.createRestTypeNode;
+exports.createStringLiteral = require_factory.createStringLiteral;
+exports.createTrue = require_factory.createTrue;
+exports.createTupleDeclaration = require_factory.createTupleDeclaration;
+exports.createTupleTypeNode = require_factory.createTupleTypeNode;
+exports.createTypeAliasDeclaration = require_factory.createTypeAliasDeclaration;
+exports.createTypeDeclaration = require_factory.createTypeDeclaration;
+exports.createTypeLiteralNode = require_factory.createTypeLiteralNode;
+exports.createTypeReferenceNode = require_factory.createTypeReferenceNode;
+exports.createUnionDeclaration = require_factory.createUnionDeclaration;
+exports.keywordTypeNodes = require_factory.keywordTypeNodes;
+exports.modifiers = require_factory.modifiers;
+exports.syntaxKind = require_factory.syntaxKind;

package/dist/factory.d.cts

@@ -1,2 +1,2 @@
-import 'typescript';
-export { j as appendJSDocToNode, d as createArrayDeclaration, A as createArrayTypeNode, t as createEnumDeclaration, r as createExportDeclaration, I as createFalse, D as createIdentifier, q as createImportDeclaration, k as createIndexSignature, n as createInterfaceDeclaration, a as createIntersectionDeclaration, i as createJSDoc, B as createLiteralTypeNode, p as createNamespaceDeclaration, C as createNull, y as createNumericLiteral, u as createOmitDeclaration, E as createOptionalTypeNode, h as createParameterSignature, g as createPropertySignature, c as createQuestionToken, G as createRestTypeNode, z as createStringLiteral, H as createTrue, b as createTupleDeclaration, F as createTupleTypeNode, l as createTypeAliasDeclaration, o as createTypeDeclaration, w as createTypeLiteralNode, x as createTypeReferenceNode, e as createUnionDeclaration, v as keywordTypeNodes, m as modifiers, s as syntaxKind } from './factory-Cn6Avpxk.cjs';
+import { 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, keywordTypeNodes, modifiers, syntaxKind } from "./factory-_F-JTqnG.cjs";
+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, keywordTypeNodes, modifiers, syntaxKind };

package/dist/factory.d.ts

@@ -1,2 +1,2 @@
-import 'typescript';
-export { j as appendJSDocToNode, d as createArrayDeclaration, A as createArrayTypeNode, t as createEnumDeclaration, r as createExportDeclaration, I as createFalse, D as createIdentifier, q as createImportDeclaration, k as createIndexSignature, n as createInterfaceDeclaration, a as createIntersectionDeclaration, i as createJSDoc, B as createLiteralTypeNode, p as createNamespaceDeclaration, C as createNull, y as createNumericLiteral, u as createOmitDeclaration, E as createOptionalTypeNode, h as createParameterSignature, g as createPropertySignature, c as createQuestionToken, G as createRestTypeNode, z as createStringLiteral, H as createTrue, b as createTupleDeclaration, F as createTupleTypeNode, l as createTypeAliasDeclaration, o as createTypeDeclaration, w as createTypeLiteralNode, x as createTypeReferenceNode, e as createUnionDeclaration, v as keywordTypeNodes, m as modifiers, s as syntaxKind } from './factory-Cn6Avpxk.js';
+import { 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, keywordTypeNodes, modifiers, syntaxKind } from "./factory-CUjjpSgy.js";
+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, keywordTypeNodes, modifiers, syntaxKind };

package/dist/factory.js

@@ -1,3 +1,3 @@
-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, keywordTypeNodes, modifiers, syntaxKind } from './chunk-BEHWCDCH.js';
-//# sourceMappingURL=factory.js.map
-//# sourceMappingURL=factory.js.map
+import { 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, keywordTypeNodes, modifiers, syntaxKind } from "./factory-CTKjALU5.js";
+
+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, keywordTypeNodes, modifiers, syntaxKind };

package/dist/index.cjs

@@ -1,52 +1,66 @@
-'use strict';
+const require_factory = require('./factory-DeJMlphM.cjs');
+const typescript = require_factory.__toESM(require("typescript"));
+const prettier = require_factory.__toESM(require("prettier"));
+const prettier_plugins_typescript = require_factory.__toESM(require("prettier/plugins/typescript"));
 
-var chunkFIHRQE7D_cjs = require('./chunk-FIHRQE7D.cjs');
-var ts = require('typescript');
-var prettier = require('prettier');
-var pluginTypescript = require('prettier/plugins/typescript');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var ts__default = /*#__PURE__*/_interopDefault(ts);
-var pluginTypescript__default = /*#__PURE__*/_interopDefault(pluginTypescript);
-
-var { factory } = ts__default.default;
-var escapeNewLines = (code) => code.replace(/\n\n/g, "\n/* :newline: */");
-var restoreNewLines = (code) => code.replace(/\/\* :newline: \*\//g, "\n");
-function print(elements, { source = "", baseName = "print.ts", removeComments, noEmitHelpers, newLine = ts__default.default.NewLineKind.LineFeed, scriptKind = ts__default.default.ScriptKind.TS } = {}) {
-  const sourceFile = ts__default.default.createSourceFile(baseName, escapeNewLines(source), ts__default.default.ScriptTarget.ES2022, false, scriptKind);
-  const printer = ts__default.default.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__default.default.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile);
-  return restoreNewLines(output).replace(/\r\n/g, "\n");
+//#region src/print.ts
+const { factory } = typescript.default;
+/**
+* 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 = typescript.default.NewLineKind.LineFeed, scriptKind = typescript.default.ScriptKind.TS } = {}) {
+	const sourceFile = typescript.default.createSourceFile(baseName, escapeNewLines(source), typescript.default.ScriptTarget.ES2022, false, scriptKind);
+	const printer = typescript.default.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(typescript.default.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__default.default]
+
+//#endregion
+//#region src/format.ts
+const formatOptions = {
+	tabWidth: 2,
+	printWidth: 160,
+	parser: "typescript",
+	singleQuote: true,
+	semi: false,
+	bracketSameLine: false,
+	endOfLine: "auto",
+	plugins: [prettier_plugins_typescript.default]
 };
+/**
+* Format the generated code based on Prettier
+*/
 async function format(source) {
-  if (!source) {
-    return "";
-  }
-  return prettier.format(source, formatOptions);
+	if (!source) return "";
+	return (0, prettier.format)(source, formatOptions);
 }
 
-Object.defineProperty(exports, "factory", {
+//#endregion
+Object.defineProperty(exports, 'factory', {
   enumerable: true,
-  get: function () { return chunkFIHRQE7D_cjs.factory_exports; }
+  get: function () {
+    return require_factory.factory_exports;
+  }
 });
 exports.format = format;
 exports.print = print;
-//# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/print.ts","../src/format.ts"],"names":["ts","pluginTypescript","prettierFormat"],"mappings":";;;;;;;;;;;;AAIA,IAAM,EAAE,SAAY,GAAAA,mBAAA;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,UAAUA,mBAAG,CAAA,WAAA,CAAY,UAAU,UAAa,GAAAA,mBAAA,CAAG,WAAW,EAAG,EAAA,GAAkB,EAChJ,EAAA;AACR,EAAM,MAAA,UAAA,GAAaA,mBAAG,CAAA,gBAAA,CAAiB,QAAU,EAAA,cAAA,CAAe,MAAM,CAAA,EAAGA,mBAAG,CAAA,YAAA,CAAa,MAAQ,EAAA,KAAA,EAAO,UAAU,CAAA;AAElH,EAAM,MAAA,OAAA,GAAUA,oBAAG,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,CAAUA,mBAAG,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,CAACC,iCAAgB;AAC5B,CAAA;AAKA,eAAsB,OAAO,MAAgB,EAAA;AAE3C,EAAA,IAAI,CAAC,MAAQ,EAAA;AACX,IAAO,OAAA,EAAA;AAAA;AAGT,EAAO,OAAAC,eAAA,CAAe,QAAQ,aAAa,CAAA;AAC7C","file":"index.cjs","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.cjs","names":["ts","code: string","elements: Array<ts.Node>","formatOptions: Options","pluginTypescript","source: string"],"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,GAAGA;;;;;;AAapB,MAAM,iBAAiB,CAACC,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,UAAUF,mBAAG,YAAY,UAAU,aAAaA,mBAAG,WAAW,IAAkB,GAAG,CAAE,GAClJ;CACR,MAAM,aAAaA,mBAAG,iBAAiB,UAAU,eAAe,OAAO,EAAEA,mBAAG,aAAa,QAAQ,OAAO,WAAW;CAEnH,MAAM,UAAUA,mBAAG,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,UAAUA,mBAAG,WAAW,WAAW,QAAQ,gBAAgB,MAAM,EAAE,WAAW;AAErG,QAAO,gBAAgB,OAAO,CAAC,QAAQ,SAAS,KAAK;AACtD;;;;AC3CD,MAAMG,gBAAyB;CAC7B,UAAU;CACV,YAAY;CACZ,QAAQ;CACR,aAAa;CACb,MAAM;CACN,iBAAiB;CACjB,WAAW;CACX,SAAS,CAACC,mCAAiB;AAC5B;;;;AAKD,eAAsB,OAAOC,QAAgB;AAE3C,KAAI,CAAC,OACH,QAAO;AAGT,6BAAsB,QAAQ,cAAc;AAC7C"}

package/dist/index.d.cts

@@ -1,20 +1,30 @@
-import ts, { PrinterOptions } from 'typescript';
-export { f as factory } from './factory-Cn6Avpxk.cjs';
+import { factory_d_exports } from "./factory-_F-JTqnG.cjs";
+import ts, { PrinterOptions } from "typescript";
 
+//#region src/print.d.ts
 type PrintOptions = {
-    source?: string;
-    baseName?: string;
-    scriptKind?: ts.ScriptKind;
+  source?: string;
+  baseName?: string;
+  scriptKind?: ts.ScriptKind;
 } & PrinterOptions;
 /**
  * Convert AST TypeScript nodes to a string based on the TypeScript printer.
  * Ensures consistent output across environments.
  */
-declare function print(elements: Array<ts.Node>, { source, baseName, removeComments, noEmitHelpers, newLine, scriptKind }?: PrintOptions): string;
-
+declare function print(elements: Array<ts.Node>, {
+  source,
+  baseName,
+  removeComments,
+  noEmitHelpers,
+  newLine,
+  scriptKind
+}?: PrintOptions): string;
+//#endregion
+//#region src/format.d.ts
 /**
  * Format the generated code based on Prettier
  */
 declare function format(source: string): Promise<string>;
-
-export { format, print };
+//#endregion
+export { factory_d_exports as factory, format, print };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,20 +1,30 @@
-import ts, { PrinterOptions } from 'typescript';
-export { f as factory } from './factory-Cn6Avpxk.js';
+import { factory_d_exports } from "./factory-CUjjpSgy.js";
+import ts, { PrinterOptions } from "typescript";
 
+//#region src/print.d.ts
 type PrintOptions = {
-    source?: string;
-    baseName?: string;
-    scriptKind?: ts.ScriptKind;
+  source?: string;
+  baseName?: string;
+  scriptKind?: ts.ScriptKind;
 } & PrinterOptions;
 /**
  * Convert AST TypeScript nodes to a string based on the TypeScript printer.
  * Ensures consistent output across environments.
  */
-declare function print(elements: Array<ts.Node>, { source, baseName, removeComments, noEmitHelpers, newLine, scriptKind }?: PrintOptions): string;
-
+declare function print(elements: Array<ts.Node>, {
+  source,
+  baseName,
+  removeComments,
+  noEmitHelpers,
+  newLine,
+  scriptKind
+}?: PrintOptions): string;
+//#endregion
+//#region src/format.d.ts
 /**
  * Format the generated code based on Prettier
  */
 declare function format(source: string): Promise<string>;
-
-export { format, print };
+//#endregion
+export { factory_d_exports as factory, format, print };
+//# sourceMappingURL=index.d.ts.map