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

package/dist/factory-CroRqsMR.js

@@ -1,249 +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) {
-		const node$1 = createInterfaceDeclaration({
-			members: type.members,
-			modifiers: isExportable ? [modifiers.export] : [],
-			name,
-			typeParameters: void 0
-		});
-		return appendJSDocToNode({
-			node: node$1,
-			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);
-}
-/**
-* 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-CroRqsMR.js.map

package/dist/factory-CroRqsMR.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory-CroRqsMR.js","names":["modifiers","questionToken","node","importPropertyName: ts.Identifier | undefined","importName: ts.NamedImportBindings | undefined","propertyName","initializer: ts.Expression"],"sources":["../src/factory.ts"],"sourcesContent":["import { isNumber } from 'remeda'\nimport ts from 'typescript'\n\nconst { SyntaxKind, factory } = ts\n\n// https://ts-ast-viewer.com/\n\nexport const modifiers = {\n  async: factory.createModifier(ts.SyntaxKind.AsyncKeyword),\n  export: factory.createModifier(ts.SyntaxKind.ExportKeyword),\n  const: factory.createModifier(ts.SyntaxKind.ConstKeyword),\n  static: factory.createModifier(ts.SyntaxKind.StaticKeyword),\n} as const\n\nexport const syntaxKind = {\n  union: SyntaxKind.UnionType as 192,\n} as const\n\nfunction isValidIdentifier(str: string): boolean {\n  if (!str.length || str.trim() !== str) {\n    return false\n  }\n  const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest)\n\n  return !!node && node.kind === ts.SyntaxKind.Identifier && ts.identifierToKeywordKind(node.kind as unknown as ts.Identifier) === undefined\n}\n\nfunction propertyName(name: string | ts.PropertyName): ts.PropertyName {\n  if (typeof name === 'string') {\n    return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name)\n  }\n  return name\n}\n\nconst questionToken = factory.createToken(ts.SyntaxKind.QuestionToken)\n\nexport function createQuestionToken(token?: boolean | ts.QuestionToken) {\n  if (!token) {\n    return undefined\n  }\n  if (token === true) {\n    return questionToken\n  }\n  return token\n}\n\nexport function createIntersectionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode | null {\n  if (!nodes.length) {\n    return null\n  }\n\n  if (nodes.length === 1) {\n    return nodes[0] || null\n  }\n\n  const node = factory.createIntersectionTypeNode(nodes)\n\n  if (withParentheses) {\n    return factory.createParenthesizedType(node)\n  }\n\n  return node\n}\n\n/**\n * Minimum nodes length of 2\n * @example `string & number`\n */\nexport function createTupleDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode | null {\n  if (!nodes.length) {\n    return null\n  }\n\n  if (nodes.length === 1) {\n    return nodes[0] || null\n  }\n\n  const node = factory.createTupleTypeNode(nodes)\n\n  if (withParentheses) {\n    return factory.createParenthesizedType(node)\n  }\n\n  return node\n}\n\nexport function createArrayDeclaration({ nodes }: { nodes: Array<ts.TypeNode> }): ts.TypeNode | null {\n  if (!nodes.length) {\n    return factory.createTupleTypeNode([])\n  }\n\n  if (nodes.length === 1) {\n    return factory.createArrayTypeNode(nodes.at(0)!)\n  }\n\n  return factory.createExpressionWithTypeArguments(factory.createIdentifier('Array'), [factory.createUnionTypeNode(nodes)])\n}\n\n/**\n * Minimum nodes length of 2\n * @example `string | number`\n */\nexport function createUnionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode {\n  if (!nodes.length) {\n    return keywordTypeNodes.any\n  }\n\n  if (nodes.length === 1) {\n    return nodes[0] as ts.TypeNode\n  }\n\n  const node = factory.createUnionTypeNode(nodes)\n\n  if (withParentheses) {\n    return factory.createParenthesizedType(node)\n  }\n\n  return node\n}\n\nexport function createPropertySignature({\n  readOnly,\n  modifiers = [],\n  name,\n  questionToken,\n  type,\n}: {\n  readOnly?: boolean\n  modifiers?: Array<ts.Modifier>\n  name: ts.PropertyName | string\n  questionToken?: ts.QuestionToken | boolean\n  type?: ts.TypeNode\n}) {\n  return factory.createPropertySignature(\n    [...modifiers, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : undefined].filter(Boolean),\n    propertyName(name),\n    createQuestionToken(questionToken),\n    type,\n  )\n}\n\nexport function createParameterSignature(\n  name: string | ts.BindingName,\n  {\n    modifiers,\n    dotDotDotToken,\n    questionToken,\n    type,\n    initializer,\n  }: {\n    decorators?: Array<ts.Decorator>\n    modifiers?: Array<ts.Modifier>\n    dotDotDotToken?: ts.DotDotDotToken\n    questionToken?: ts.QuestionToken | boolean\n    type?: ts.TypeNode\n    initializer?: ts.Expression\n  },\n): ts.ParameterDeclaration {\n  return factory.createParameterDeclaration(modifiers, dotDotDotToken, name, createQuestionToken(questionToken), type, initializer)\n}\n\nexport function createJSDoc({ comments }: { comments: string[] }) {\n  if (!comments.length) {\n    return null\n  }\n  return factory.createJSDocComment(\n    factory.createNodeArray(\n      comments.map((comment, i) => {\n        if (i === comments.length - 1) {\n          return factory.createJSDocText(comment)\n        }\n\n        return factory.createJSDocText(`${comment}\\n`)\n      }),\n    ),\n  )\n}\n\n/**\n * @link https://github.com/microsoft/TypeScript/issues/44151\n */\nexport function appendJSDocToNode<TNode extends ts.Node>({ node, comments }: { node: TNode; comments: Array<string | undefined> }) {\n  const filteredComments = comments.filter(Boolean)\n\n  if (!filteredComments.length) {\n    return node\n  }\n\n  const text = filteredComments.reduce((acc = '', comment = '') => {\n    return `${acc}\\n * ${comment.replaceAll('*/', '*\\\\/')}`\n  }, '*')\n\n  // node: {...node}, with that ts.addSyntheticLeadingComment is appending\n  return ts.addSyntheticLeadingComment({ ...node }, ts.SyntaxKind.MultiLineCommentTrivia, `${text || '*'}\\n`, true)\n}\n\nexport function createIndexSignature(\n  type: ts.TypeNode,\n  {\n    modifiers,\n    indexName = 'key',\n    indexType = factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n  }: {\n    indexName?: string\n    indexType?: ts.TypeNode\n    decorators?: Array<ts.Decorator>\n    modifiers?: Array<ts.Modifier>\n  } = {},\n) {\n  return factory.createIndexSignature(modifiers, [createParameterSignature(indexName, { type: indexType })], type)\n}\n\nexport function createTypeAliasDeclaration({\n  modifiers,\n  name,\n  typeParameters,\n  type,\n}: {\n  modifiers?: Array<ts.Modifier>\n  name: string | ts.Identifier\n  typeParameters?: Array<ts.TypeParameterDeclaration>\n  type: ts.TypeNode\n}) {\n  return factory.createTypeAliasDeclaration(modifiers, name, typeParameters, type)\n}\n\nexport function createInterfaceDeclaration({\n  modifiers,\n  name,\n  typeParameters,\n  members,\n}: {\n  modifiers?: Array<ts.Modifier>\n  name: string | ts.Identifier\n  typeParameters?: Array<ts.TypeParameterDeclaration>\n  members: Array<ts.TypeElement>\n}) {\n  return factory.createInterfaceDeclaration(modifiers, name, typeParameters, undefined, members)\n}\n\nexport function createTypeDeclaration({\n  syntax,\n  isExportable,\n  comments,\n  name,\n  type,\n}: {\n  syntax: 'type' | 'interface'\n  comments: Array<string | undefined>\n  isExportable?: boolean\n  name: string | ts.Identifier\n  type: ts.TypeNode\n}) {\n  if (syntax === 'interface' && 'members' in type) {\n    const node = createInterfaceDeclaration({\n      members: type.members as Array<ts.TypeElement>,\n      modifiers: isExportable ? [modifiers.export] : [],\n      name,\n      typeParameters: undefined,\n    })\n\n    return appendJSDocToNode({\n      node,\n      comments,\n    })\n  }\n\n  const node = createTypeAliasDeclaration({\n    type,\n    modifiers: isExportable ? [modifiers.export] : [],\n    name,\n    typeParameters: undefined,\n  })\n\n  return appendJSDocToNode({\n    node,\n    comments,\n  })\n}\n\nexport function createNamespaceDeclaration({ statements, name }: { name: string; statements: ts.Statement[] }) {\n  return factory.createModuleDeclaration(\n    [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n    factory.createIdentifier(name),\n    factory.createModuleBlock(statements),\n    ts.NodeFlags.Namespace,\n  )\n}\n\n/**\n * In { propertyName: string; name?: string } is `name` being used to make the type more unique when multiple same names are used.\n * @example `import { Pet as Cat } from './Pet'`\n */\nexport function createImportDeclaration({\n  name,\n  path,\n  isTypeOnly = false,\n  isNameSpace = false,\n}: {\n  name: string | Array<string | { propertyName: string; name?: string }>\n  path: string\n  isTypeOnly?: boolean\n  isNameSpace?: boolean\n}) {\n  if (!Array.isArray(name)) {\n    let importPropertyName: ts.Identifier | undefined = factory.createIdentifier(name)\n    let importName: ts.NamedImportBindings | undefined\n\n    if (isNameSpace) {\n      importPropertyName = undefined\n      importName = factory.createNamespaceImport(factory.createIdentifier(name))\n    }\n\n    return factory.createImportDeclaration(\n      undefined,\n      factory.createImportClause(isTypeOnly, importPropertyName, importName),\n      factory.createStringLiteral(path),\n      undefined,\n    )\n  }\n\n  return factory.createImportDeclaration(\n    undefined,\n    factory.createImportClause(\n      isTypeOnly,\n      undefined,\n      factory.createNamedImports(\n        name.map((item) => {\n          if (typeof item === 'object') {\n            const obj = item as { propertyName: string; name?: string }\n            if (obj.name) {\n              return factory.createImportSpecifier(false, factory.createIdentifier(obj.propertyName), factory.createIdentifier(obj.name))\n            }\n\n            return factory.createImportSpecifier(false, undefined, factory.createIdentifier(obj.propertyName))\n          }\n\n          return factory.createImportSpecifier(false, undefined, factory.createIdentifier(item))\n        }),\n      ),\n    ),\n    factory.createStringLiteral(path),\n    undefined,\n  )\n}\n\nexport function createExportDeclaration({\n  path,\n  asAlias,\n  isTypeOnly = false,\n  name,\n}: {\n  path: string\n  asAlias?: boolean\n  isTypeOnly?: boolean\n  name?: string | Array<ts.Identifier | string>\n}) {\n  if (name && !Array.isArray(name) && !asAlias) {\n    console.warn(`When using name as string, asAlias should be true ${name}`)\n  }\n\n  if (!Array.isArray(name)) {\n    const parsedName = name?.match(/^\\d/) ? `_${name?.slice(1)}` : name\n\n    return factory.createExportDeclaration(\n      undefined,\n      isTypeOnly,\n      asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : undefined,\n      factory.createStringLiteral(path),\n      undefined,\n    )\n  }\n\n  return factory.createExportDeclaration(\n    undefined,\n    isTypeOnly,\n    factory.createNamedExports(\n      name.map((propertyName) => {\n        return factory.createExportSpecifier(false, undefined, typeof propertyName === 'string' ? factory.createIdentifier(propertyName) : propertyName)\n      }),\n    ),\n    factory.createStringLiteral(path),\n    undefined,\n  )\n}\n\nexport function createEnumDeclaration({\n  type = 'enum',\n  name,\n  typeName,\n  enums,\n}: {\n  /**\n   * @default `'enum'`\n   */\n  type?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal'\n  /**\n   * Enum name in camelCase.\n   */\n  name: string\n  /**\n   * Enum name in PascalCase.\n   */\n  typeName: string\n  enums: [key: string | number, value: string | number | boolean][]\n}): [name: ts.Node | undefined, type: ts.Node] {\n  if (type === 'literal') {\n    return [\n      undefined,\n      factory.createTypeAliasDeclaration(\n        [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n        factory.createIdentifier(typeName),\n        undefined,\n        factory.createUnionTypeNode(\n          enums\n            .map(([_key, value]) => {\n              if (isNumber(value)) {\n                return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()))\n              }\n\n              if (typeof value === 'boolean') {\n                return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse())\n              }\n              if (value) {\n                return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()))\n              }\n\n              return undefined\n            })\n            .filter(Boolean),\n        ),\n      ),\n    ]\n  }\n\n  if (type === 'enum' || type === 'constEnum') {\n    return [\n      undefined,\n      factory.createEnumDeclaration(\n        [factory.createToken(ts.SyntaxKind.ExportKeyword), type === 'constEnum' ? factory.createToken(ts.SyntaxKind.ConstKeyword) : undefined].filter(Boolean),\n        factory.createIdentifier(typeName),\n        enums\n          .map(([key, value]) => {\n            let initializer: ts.Expression = factory.createStringLiteral(value?.toString())\n            const isExactNumber = Number.parseInt(value.toString(), 10) === value\n\n            if (isExactNumber && isNumber(Number.parseInt(value.toString(), 10))) {\n              initializer = factory.createNumericLiteral(value as number)\n            }\n\n            if (typeof value === 'boolean') {\n              initializer = value ? factory.createTrue() : factory.createFalse()\n            }\n\n            if (isNumber(Number.parseInt(key.toString(), 10))) {\n              return factory.createEnumMember(factory.createStringLiteral(`${typeName}_${key}`), initializer)\n            }\n\n            if (key) {\n              return factory.createEnumMember(factory.createStringLiteral(`${key}`), initializer)\n            }\n\n            return undefined\n          })\n          .filter(Boolean),\n      ),\n    ]\n  }\n\n  // used when using `as const` instead of an TypeScript enum.\n  const identifierName = type === 'asPascalConst' ? typeName : name\n\n  return [\n    factory.createVariableStatement(\n      [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n      factory.createVariableDeclarationList(\n        [\n          factory.createVariableDeclaration(\n            factory.createIdentifier(identifierName),\n            undefined,\n            undefined,\n            factory.createAsExpression(\n              factory.createObjectLiteralExpression(\n                enums\n                  .map(([key, value]) => {\n                    let initializer: ts.Expression = factory.createStringLiteral(value?.toString())\n\n                    if (isNumber(value)) {\n                      // Error: Negative numbers should be created in combination with createPrefixUnaryExpression factory.\n                      // The method createNumericLiteral only accepts positive numbers\n                      // or those combined with createPrefixUnaryExpression.\n                      // Therefore, we need to ensure that the number is not negative.\n                      if (value < 0) {\n                        initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)))\n                      } else {\n                        initializer = factory.createNumericLiteral(value)\n                      }\n                    }\n\n                    if (typeof value === 'boolean') {\n                      initializer = value ? factory.createTrue() : factory.createFalse()\n                    }\n\n                    if (key) {\n                      return factory.createPropertyAssignment(factory.createStringLiteral(`${key}`), initializer)\n                    }\n\n                    return undefined\n                  })\n                  .filter(Boolean),\n                true,\n              ),\n              factory.createTypeReferenceNode(factory.createIdentifier('const'), undefined),\n            ),\n          ),\n        ],\n        ts.NodeFlags.Const,\n      ),\n    ),\n    factory.createTypeAliasDeclaration(\n      type === 'asPascalConst' ? [] : [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n      factory.createIdentifier(typeName),\n      undefined,\n      factory.createIndexedAccessTypeNode(\n        factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n        factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n      ),\n    ),\n  ]\n}\n\nexport function createOmitDeclaration({ keys, type, nonNullable }: { keys: Array<string> | string; type: ts.TypeNode; nonNullable?: boolean }) {\n  const node = nonNullable ? factory.createTypeReferenceNode(factory.createIdentifier('NonNullable'), [type]) : type\n\n  if (Array.isArray(keys)) {\n    return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [\n      node,\n      factory.createUnionTypeNode(\n        keys.map((key) => {\n          return factory.createLiteralTypeNode(factory.createStringLiteral(key))\n        }),\n      ),\n    ])\n  }\n\n  return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [node, factory.createLiteralTypeNode(factory.createStringLiteral(keys))])\n}\n\nexport const keywordTypeNodes = {\n  any: factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),\n  unknown: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),\n  void: factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),\n  number: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n  integer: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n  object: factory.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword),\n  string: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n  boolean: factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),\n  undefined: factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),\n  null: factory.createLiteralTypeNode(factory.createToken(ts.SyntaxKind.NullKeyword)),\n} as const\n\nexport const createTypeLiteralNode = factory.createTypeLiteralNode\n\nexport const createTypeReferenceNode = factory.createTypeReferenceNode\nexport const createNumericLiteral = factory.createNumericLiteral\nexport const createStringLiteral = factory.createStringLiteral\n\nexport const createArrayTypeNode = factory.createArrayTypeNode\n\nexport const createLiteralTypeNode = factory.createLiteralTypeNode\nexport const createNull = factory.createNull\nexport const createIdentifier = factory.createIdentifier\n\nexport const createOptionalTypeNode = factory.createOptionalTypeNode\nexport const createTupleTypeNode = factory.createTupleTypeNode\nexport const createRestTypeNode = factory.createRestTypeNode\nexport const createTrue = factory.createTrue\nexport const createFalse = factory.createFalse\n"],"mappings":"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"}

package/dist/factory-DqBZ_C7_.d.cts

@@ -1,227 +0,0 @@
-import ts from "typescript";
-
-//#region rolldown:runtime
-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-DqBZ_C7_.d.cts.map

package/dist/factory.cjs

@@ -1,36 +0,0 @@
-const require_factory = require('./factory-BNDICAoK.cjs');
-
-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 +0,0 @@
-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-DqBZ_C7_.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 +0,0 @@
-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-BJCGLhSr.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 +0,0 @@
-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-CroRqsMR.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.d.cts

@@ -1,25 +0,0 @@
-import { factory_d_exports } from "./factory-DqBZ_C7_.cjs";
-import ts from "typescript";
-
-//#region src/format.d.ts
-declare function format(source?: string): Promise<string>;
-//#endregion
-//#region src/print.d.ts
-type PrintOptions = {
-  source?: string;
-  baseName?: string;
-  scriptKind?: ts.ScriptKind;
-};
-/**
- * Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.
- * Ensures consistent output across environments.
- * Also works as a formatter when `source` is provided without `elements`.
- */
-declare function print(elements?: Array<ts.Node>, {
-  source,
-  baseName,
-  scriptKind
-}?: PrintOptions): string;
-//#endregion
-export { factory_d_exports as factory, format, print };
-//# sourceMappingURL=index.d.cts.map