@kubb/parser-ts 5.5.6 → 5.6.1

package/dist/index.js

@@ -1,9 +1,26 @@
 import "./rolldown-runtime-CRm0XQPb.js";
 import { createRequire } from "node:module";
 import { ast, defineParser } from "@kubb/kit";
-import { dirname, normalize, relative, resolve } from "node:path";
+import { dirname, relative, resolve } from "node:path";
 //#region ../../internals/utils/src/fs.ts
 /**
+* Converts a filesystem path to use POSIX (`/`) separators.
+*
+* Most of the codebase compares and composes paths as strings (prefix matching, joining for
+* import specifiers, splitting on `/`). On POSIX `path.resolve` already returns `/`-separated
+* paths, but on Windows it returns `\`-separated paths, which breaks every such comparison.
+*
+* Routing every path that crosses a module boundary through `toPosixPath` keeps the rest of the
+* code platform-agnostic. The conversion runs unconditionally so Windows-specific behavior is
+* exercisable from POSIX CI.
+*
+* @example
+* toPosixPath('C:\\repo\\src\\pet.ts') // 'C:/repo/src/pet.ts'
+*/
+function toPosixPath(filePath) {
+	return filePath.replaceAll("\\", "/");
+}
+/**
 * Strips the file extension from a path or file name.
 * Only removes the last `.ext` segment when the dot is not part of a directory name.
 *
@@ -18,61 +35,42 @@ function trimExtName(text) {
 	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
 	return text;
 }
-/**
-* Indentation unit prepended once per nesting level when pretty-printing.
-*/
-const INDENT = " ".repeat(2);
-/**
-* Matches only the final `.<ext>` of a path, so a name like `foo.bar.ts` keeps
-* `foo.bar` and loses just `.ts`.
-*/
-const FILE_EXTENSION_PATTERN = /\.[^/.]+$/;
-/**
-* Matches Windows-style backslash path separators.
-*/
-const WINDOWS_PATH_SEPARATOR = /\\/g;
-/**
-* Matches `*\/` in free-form text so JSDoc bodies can neutralize premature
-* comment terminators (`*\/` → `* /`).
-*/
-const JSDOC_TERMINATOR_PATTERN = /\*\//g;
-/**
-* Matches carriage returns for normalizing CRLF/CR line endings to LF.
-*/
-const CARRIAGE_RETURN_PATTERN = /\r/g;
-/**
-* Matches CRLF sequences used when normalizing TypeScript printer output.
-*/
-const CRLF_PATTERN = /\r\n/g;
-/**
-* Matches an identifier that starts with a digit. JavaScript disallows this,
-* so the printer replaces the leading digit with `_`.
-*/
-const LEADING_DIGIT_PATTERN = /^\d/;
 //#endregion
 //#region src/utils.ts
+let compiler;
 /**
-* Loaded with `require`, not `import`. When ESM imports a CommonJS package, Node keeps a second
-* copy of its source to detect named exports, and for TypeScript that copy is about 9 MB.
-*/
-const typescript = createRequire(import.meta.url)("typescript");
-const { factory } = typescript;
+* Loads TypeScript on the first `print` or `copy`; `parse` is string templating and never needs it.
+*
+* Loaded with `require`, not `import`: when ESM imports a CommonJS package, Node keeps a second copy of its source
+* to detect named exports, and for TypeScript that copy is about 9 MB.
+*/
+function loadCompiler() {
+	if (compiler) return compiler;
+	const typescript = createRequire(import.meta.url)("typescript");
+	compiler = {
+		typescript,
+		printer: typescript.createPrinter({
+			omitTrailingSemicolon: true,
+			newLine: typescript.NewLineKind.LineFeed,
+			removeComments: false,
+			noEmitHelpers: true
+		}),
+		sourceFile: typescript.createSourceFile("print.tsx", "", typescript.ScriptTarget.ES2022, true, typescript.ScriptKind.TSX)
+	};
+	return compiler;
+}
 /**
-* Resolves `filePath` relative to `rootDir` and returns a POSIX-style path
-* prefixed with `./` when the target sits inside the root, or `../` when it escapes it.
+* Module specifier that imports `filePath` from the file at `root`: POSIX, relative to that file's directory, `./`-prefixed unless it climbs with `../`.
 */
-function getRelativePath(rootDir, filePath) {
-	const rel = relative(rootDir, filePath);
-	const slashed = normalize(rel).replaceAll(WINDOWS_PATH_SEPARATOR, "/").replace("../", "");
+function getRelativePath(root, filePath) {
+	const slashed = toPosixPath(relative(dirname(root), filePath));
 	return slashed.startsWith("../") ? slashed : `./${slashed}`;
 }
 /**
-* Rewrites an import/export path so its extension matches the caller-supplied
-* `options.extname`. When the source path has no extension the original is kept,
-* so virtual/module-only paths flow through unchanged.
+* Swaps the extension of a relative import/export path for `options.extname`; package specifiers and extension-less paths stay as-is.
 */
 function resolveOutputPath(path, options, rootAware) {
-	const hasExtname = FILE_EXTENSION_PATTERN.test(path);
+	const hasExtname = /\.[^/.]+$/.test(path);
 	if (rootAware && options?.extname && hasExtname) return `${trimExtName(path)}${options.extname}`;
 	return rootAware ? trimExtName(path) : path;
 }
@@ -81,6 +79,7 @@ function resolveOutputPath(path, options, rootAware) {
 */
 function toImportName(element) {
 	if (!element.propertyName) return element.name.text;
+	const { typescript } = loadCompiler();
 	const { propertyName } = element;
 	return {
 		propertyName: typescript.isStringLiteral(propertyName) ? quoteModulePath(propertyName.text) : propertyName.text,
@@ -91,6 +90,7 @@ function toImportName(element) {
 * Converts an `import` declaration into `ImportNode`s. Side-effect imports and imports with attributes stay as written.
 */
 function toImportNodes(statement, filePath) {
+	const { typescript } = loadCompiler();
 	if (!typescript.isImportDeclaration(statement) || !statement.importClause || !typescript.isStringLiteral(statement.moduleSpecifier) || statement.attributes) return [];
 	const { name, namedBindings, phaseModifier } = statement.importClause;
 	const specifier = statement.moduleSpecifier.text;
@@ -131,6 +131,7 @@ function toImportNodes(statement, filePath) {
 * Converts an `export … from` declaration into `ExportNode`s. Forms `printExport` cannot print stay as written.
 */
 function toExportNodes(statement) {
+	const { typescript } = loadCompiler();
 	if (!typescript.isExportDeclaration(statement) || !statement.moduleSpecifier || !typescript.isStringLiteral(statement.moduleSpecifier) || statement.attributes) return [];
 	const { exportClause, isTypeOnly } = statement;
 	const path = statement.moduleSpecifier.text;
@@ -151,14 +152,11 @@ function toExportNodes(statement) {
 		isTypeOnly
 	})];
 }
-function isModuleDeclaration(statement) {
-	return typescript.isImportDeclaration(statement) || typescript.isExportDeclaration(statement) && Boolean(statement.moduleSpecifier);
-}
 /**
-* Splits `source` into its top-level `import`/`export … from` declarations, as nodes, the `header` above the first of them
-* (shebang, directives, comments) and the remaining `body`.
+* Splits `source` into its lifted `import`/`export … from` nodes, the `header` above the first one (shebang, directives, comments) and the rest as `body`.
 */
 function splitModuleDeclarations(source, filePath) {
+	const { typescript } = loadCompiler();
 	const sourceFile = typescript.createSourceFile(filePath, source, typescript.ScriptTarget.Latest);
 	const imports = [];
 	const exports = [];
@@ -169,7 +167,7 @@ function splitModuleDeclarations(source, filePath) {
 		const importNodes = toImportNodes(statement, filePath);
 		const exportNodes = toExportNodes(statement);
 		if (!importNodes.length && !exportNodes.length) {
-			if (isModuleDeclaration(statement)) break;
+			if (typescript.isImportDeclaration(statement) || typescript.isExportDeclaration(statement) && statement.moduleSpecifier) break;
 			continue;
 		}
 		const text = source.slice(cursor, statement.getStart(sourceFile));
@@ -187,50 +185,35 @@ function splitModuleDeclarations(source, filePath) {
 	};
 }
 /**
-* Serializes a `nodes` array into source text. Each entry is rendered via {@link printCodeNode}
-* and joined with a single newline. A `Break` node (`<br/>`) inserts one blank line between
-* statements. Consecutive breaks, and breaks at the very start or end, are folded into the
-* separator, so a double `<br/>` never emits more than one blank line.
+* Joins the printed `nodes` with `separator`; a `Break` widens the next separator to a blank line, and leading, trailing and repeated breaks fold into one.
+*
+* Imperative on purpose: this runs once per source fragment and `map().filter().join()` showed up in deopt traces.
 */
-function printNodes(nodes) {
-	if (!nodes || nodes.length === 0) return "";
+function printNodes({ nodes, separator }) {
 	let result = "";
-	let hasContent = false;
 	let pendingBreak = false;
-	for (const node of nodes) {
+	for (const node of nodes ?? []) {
 		if (node.kind === "Break") {
-			if (hasContent) pendingBreak = true;
+			pendingBreak = result !== "";
 			continue;
 		}
 		const text = printCodeNode(node);
 		if (!text) continue;
-		if (hasContent) result += pendingBreak ? "\n\n" : "\n";
+		if (result) result += pendingBreak ? "\n\n" : separator;
 		result += text;
-		hasContent = true;
 		pendingBreak = false;
 	}
 	return result;
 }
 /**
-* Indents every non-empty line of `text` by one indent unit. Pass a number to repeat
-* {@link INDENT_CHAR} that many times, or a string to use as the indent verbatim.
+* Indents every non-empty line of `text` by two spaces.
 */
-function indentLines(text, indent = INDENT) {
+function indentLines(text) {
 	if (!text) return "";
-	const pad = typeof indent === "string" ? indent : " ".repeat(indent);
-	return text.split("\n").map((line) => line.trim() ? `${pad}${line}` : "").join("\n");
+	return text.split("\n").map((line) => line.trim() ? `  ${line}` : "").join("\n");
 }
 /**
-* Removes the common leading whitespace shared by every non-blank line and trims
-* surrounding blank lines, so multi-line content authored inside an indented template
-* literal lines up at a column-zero baseline. Leading whitespace is counted by
-* character, so N tabs and N spaces are treated as the same depth.
-*
-* @example
-* ```ts
-* dedent('\n    foo\n      bar\n    ')
-* // 'foo\n  bar'
-* ```
+* Strips the common leading whitespace and the surrounding blank lines, counting tabs and spaces alike, so indented template literals start at column zero.
 */
 function dedent(text) {
 	if (!text) return "";
@@ -245,61 +228,37 @@ function dedent(text) {
 	return trimmed.map((line) => isBlank(line) ? "" : line.slice(min)).join("\n");
 }
 /**
-* Renders the generic clause (`<T, U>`) shared by function and arrow-function nodes.
-* Accepts either a raw string (rendered verbatim) or an array of type-parameter names.
+* Renders `<T>(params): ReturnType`; an async function wraps its return type in `Promise<>`.
 */
-function formatGenerics(generics) {
-	if (!generics) return "";
-	return `<${Array.isArray(generics) ? generics.join(", ") : generics}>`;
+function signature({ async: isAsync, generics, params, returnType }) {
+	const genericsStr = generics ? `<${Array.isArray(generics) ? generics.join(", ") : generics}>` : "";
+	const wrapped = isAsync ? `Promise<${returnType}>` : returnType;
+	const returnTypeStr = returnType ? `: ${wrapped}` : "";
+	return `${genericsStr}(${params ?? ""})${returnTypeStr}`;
 }
 /**
-* Renders the return-type suffix (`: T` or `: Promise<T>` when `isAsync` is true).
-* Returns an empty string when no return type is provided.
+* Puts the JSDoc block, when it renders to something, above `declaration`.
 */
-function formatReturnType(returnType, isAsync) {
-	if (!returnType) return "";
-	return isAsync ? `: Promise<${returnType}>` : `: ${returnType}`;
+function withJSDoc({ jsDoc, declaration }) {
+	const jsDocStr = jsDoc ? printJSDoc(jsDoc) : "";
+	return jsDocStr ? `${jsDocStr}\n${declaration}` : declaration;
 }
 /**
-* Module-scoped TypeScript printer instance. A printer does not mutate the source file, so one
-* instance is reused across every `print()` call instead of constructing a new printer each time.
-*/
-const TS_PRINTER = typescript.createPrinter({
-	omitTrailingSemicolon: true,
-	newLine: typescript.NewLineKind.LineFeed,
-	removeComments: false,
-	noEmitHelpers: true
-});
-/**
-* Module-scoped source file used as the print target. `printList` only reads the source
-* file's compiler options / language version. It never mutates it.
-*/
-const PRINT_SOURCE_FILE = typescript.createSourceFile("print.tsx", "", typescript.ScriptTarget.ES2022, true, typescript.ScriptKind.TSX);
-TS_PRINTER.printList(typescript.ListFormat.MultiLine, factory.createNodeArray([]), PRINT_SOURCE_FILE);
-/**
 * Converts TypeScript/TSX AST nodes to a string using the TypeScript printer.
 */
 function print(...elements) {
 	const filtered = elements.filter(Boolean);
 	if (filtered.length === 0) return "";
-	return TS_PRINTER.printList(typescript.ListFormat.MultiLine, factory.createNodeArray(filtered), PRINT_SOURCE_FILE).replace(CRLF_PATTERN, "\n");
+	const { typescript, printer, sourceFile } = loadCompiler();
+	return printer.printList(typescript.ListFormat.MultiLine, typescript.factory.createNodeArray(filtered), sourceFile).replace(/\r\n/g, "\n");
 }
 /**
-* Converts a {@link ast.JSDocNode} to a JSDoc comment block string.
-*
-* @example
-* ```ts
-* printJSDoc({ comments: ['@description A pet', '@deprecated'] })
-* // /**
-* //  * @description A pet
-* //  * @deprecated
-* //  *\/
-* ```
+* Converts a {@link ast.JSDocNode} to a `/** … *\/` block, dropping blank comments.
 */
 function printJSDoc(jsDoc) {
 	const comments = (jsDoc.comments ?? []).filter((c) => c != null);
 	if (comments.length === 0) return "";
-	const lines = comments.flatMap((c) => c.split(/\r?\n/)).map((l) => l.replace(JSDOC_TERMINATOR_PATTERN, "* /").replace(CARRIAGE_RETURN_PATTERN, "")).filter((l) => l.trim().length > 0);
+	const lines = comments.flatMap((c) => c.split(/\r?\n/)).map((l) => l.replace(/\*\//g, "* /").replace(/\r/g, "")).filter((l) => l.trim().length > 0);
 	if (lines.length === 0) return "";
 	return [
 		"/**",
@@ -308,194 +267,101 @@ function printJSDoc(jsDoc) {
 	].join("\n");
 }
 /**
-* Converts a {@link ast.ConstNode} to a TypeScript `const` declaration string.
-*
-* Mirrors the `Const` component from `@kubb/renderer-jsx`.
-*
-* @example
-* ```ts
-* printConst(factory.createConst({ name: 'pet', export: true, nodes: ['{}'] }))
-* // 'export const pet = {}'
-* ```
-*
-* @example With type and `as const`
-* ```ts
-* printConst(factory.createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true, nodes: ['[]'] }))
-* // 'export const pets: Pet[] = [] as const'
-* ```
+* Converts a {@link ast.ConstNode} to a `const` declaration, mirroring the `Const` component from `@kubb/renderer-jsx`.
 */
 function printConst(node) {
 	const { name, export: canExport, type, JSDoc, asConst, nodes } = node;
-	const jsDocStr = JSDoc ? printJSDoc(JSDoc) : "";
-	const body = printNodes(nodes);
-	const parts = [];
-	if (canExport) parts.push("export ");
-	parts.push("const ");
-	parts.push(name);
-	if (type) parts.push(`: ${type}`);
-	parts.push(" = ");
-	parts.push(body);
-	if (asConst) parts.push(" as const");
-	return [jsDocStr, parts.join("")].filter(Boolean).join("\n");
+	return withJSDoc({
+		jsDoc: JSDoc,
+		declaration: `${canExport ? "export " : ""}const ${name}${type ? `: ${type}` : ""} = ${printNodes({
+			nodes,
+			separator: "\n"
+		})}${asConst ? " as const" : ""}`
+	});
 }
 /**
-* Converts a {@link ast.TypeNode} to a TypeScript `type` alias declaration string.
-*
-* Mirrors the `Type` component from `@kubb/renderer-jsx`.
-*
-* @example
-* ```ts
-* printType(factory.createType({ name: 'Pet', export: true, nodes: ['{ id: number }'] }))
-* // 'export type Pet = { id: number }'
-* ```
+* Converts a {@link ast.TypeNode} to a `type` alias, mirroring the `Type` component from `@kubb/renderer-jsx`.
 */
 function printType(node) {
 	const { name, export: canExport, JSDoc, nodes } = node;
-	const jsDocStr = JSDoc ? printJSDoc(JSDoc) : "";
-	const body = printNodes(nodes);
-	const parts = [];
-	if (canExport) parts.push("export ");
-	parts.push("type ");
-	parts.push(name);
-	parts.push(" = ");
-	parts.push(body);
-	return [jsDocStr, parts.join("")].filter(Boolean).join("\n");
+	return withJSDoc({
+		jsDoc: JSDoc,
+		declaration: `${canExport ? "export " : ""}type ${name} = ${printNodes({
+			nodes,
+			separator: "\n"
+		})}`
+	});
 }
 /**
-* Converts a {@link ast.FunctionNode} to a TypeScript `function` declaration string.
-*
-* Mirrors the `Function` component from `@kubb/renderer-jsx`.
-*
-* @example
-* ```ts
-* printFunction(factory.createFunction({ name: 'getPet', export: true, params: 'id: string', returnType: 'Pet', nodes: ['return fetch(id)'] }))
-* // 'export function getPet(id: string): Pet {\n  return fetch(id)\n}'
-* ```
-*
-* @example Async with generics
-* ```ts
-* printFunction(factory.createFunction({ name: 'fetchPet', export: true, async: true, generics: ['T'], params: 'id: string', returnType: 'T' }))
-* // 'export async function fetchPet<T>(id: string): Promise<T> {\n}'
-* ```
+* Converts a {@link ast.FunctionNode} to a `function` declaration, mirroring the `Function` component from `@kubb/renderer-jsx`.
 */
 function printFunction(node) {
 	const { name, default: isDefault, export: canExport, async: isAsync, generics, params, returnType, JSDoc, nodes } = node;
-	const jsDocStr = JSDoc ? printJSDoc(JSDoc) : "";
-	const body = printNodes(nodes);
-	const indented = body ? indentLines(body) : "";
-	const parts = [];
-	if (canExport) parts.push("export ");
-	if (isDefault) parts.push("default ");
-	if (isAsync) parts.push("async ");
-	parts.push("function ");
-	parts.push(name);
-	parts.push(formatGenerics(generics));
-	parts.push(`(${params ?? ""})`);
-	parts.push(formatReturnType(returnType, isAsync));
-	parts.push(" {");
-	if (indented) parts.push(`\n${indented}\n`);
-	parts.push("}");
-	return [jsDocStr, parts.join("")].filter(Boolean).join("\n");
+	const body = indentLines(printNodes({
+		nodes,
+		separator: "\n"
+	}));
+	return withJSDoc({
+		jsDoc: JSDoc,
+		declaration: `${`${canExport ? "export " : ""}${isDefault ? "default " : ""}${isAsync ? "async " : ""}`}function ${name}${signature({
+			async: isAsync,
+			generics,
+			params,
+			returnType
+		})} {${body ? `\n${body}\n` : ""}}`
+	});
 }
 /**
-* Converts an {@link ast.ArrowFunctionNode} to a TypeScript arrow function declaration string.
-*
-* Mirrors the `Function.Arrow` component from `@kubb/renderer-jsx`.
-*
-* @example Multi-line arrow function
-* ```ts
-* printArrowFunction(factory.createArrowFunction({ name: 'getPet', export: true, params: 'id: string', nodes: ['return fetch(id)'] }))
-* // 'export const getPet = (id: string) => {\n  return fetch(id)\n}'
-* ```
-*
-* @example Single-line arrow function
-* ```ts
-* printArrowFunction(factory.createArrowFunction({ name: 'double', params: 'n: number', singleLine: true, nodes: ['n * 2'] }))
-* // 'const double = (n: number) => n * 2'
-* ```
+* Converts an {@link ast.ArrowFunctionNode} to a `const` arrow function, mirroring the `Function.Arrow` component from `@kubb/renderer-jsx`.
 */
 function printArrowFunction(node) {
 	const { name, default: isDefault, export: canExport, async: isAsync, generics, params, returnType, JSDoc, nodes, singleLine } = node;
-	const jsDocStr = JSDoc ? printJSDoc(JSDoc) : "";
-	const body = printNodes(nodes);
+	const body = printNodes({
+		nodes,
+		separator: "\n"
+	});
 	const arrowBody = singleLine ? ` => ${body}` : body ? ` => {\n${indentLines(body)}\n}` : " => {}";
-	const parts = [];
-	if (canExport) parts.push("export ");
-	if (isDefault) parts.push("default ");
-	parts.push("const ");
-	parts.push(name);
-	parts.push(" = ");
-	if (isAsync) parts.push("async ");
-	parts.push(formatGenerics(generics));
-	parts.push(`(${params ?? ""})`);
-	parts.push(formatReturnType(returnType, isAsync));
-	parts.push(arrowBody);
-	return [jsDocStr, parts.join("")].filter(Boolean).join("\n");
+	return withJSDoc({
+		jsDoc: JSDoc,
+		declaration: `${`${canExport ? "export " : ""}${isDefault ? "default " : ""}`}const ${name} = ${isAsync ? "async " : ""}${signature({
+			async: isAsync,
+			generics,
+			params,
+			returnType
+		})}${arrowBody}`
+	});
 }
 /**
-* Converts a {@link ast.CodeNode} to its TypeScript string representation.
-*
-* Dispatches to the appropriate printer based on the node's `kind`.
-*
-* @example
-* ```ts
-* printCodeNode(factory.createConst({ name: 'x', nodes: ['1'] }))
-* // 'const x = 1'
-* ```
+* Dispatches a {@link ast.CodeNode} to the printer for its `kind`.
 */
 function printCodeNode(node) {
-	if (node.kind === "Break") return "";
-	if (node.kind === "Text") return dedent(node.value);
-	if (node.kind === "Jsx") return dedent(node.value);
-	if (node.kind === "Const") return printConst(node);
-	if (node.kind === "Type") return printType(node);
-	if (node.kind === "Function") return printFunction(node);
-	if (node.kind === "ArrowFunction") return printArrowFunction(node);
-	return "";
+	switch (node.kind) {
+		case "Break": return "";
+		case "Text":
+		case "Jsx": return dedent(node.value);
+		case "Const": return printConst(node);
+		case "Type": return printType(node);
+		case "Function": return printFunction(node);
+		case "ArrowFunction": return printArrowFunction(node);
+	}
 }
 /**
-* Converts a {@link ast.SourceNode} to its TypeScript string representation.
-*
-* Iterates `nodes` in DOM order, rendering each {@link ast.CodeNode} via
-* {@link printCodeNode}.
-*
-* Top-level declarations are separated by a blank line so the source reads
-* cleanly without an external formatter.
-*
-* @example From nodes
-* ```ts
-* printSource({ kind: 'Source', nodes: [factory.createConst({ name: 'x', nodes: [factory.createText('1')] }), factory.createText('x.toString()')] })
-* // 'const x = 1\n\nx.toString()'
-* ```
+* Prints a {@link ast.SourceNode} with a blank line between its top-level nodes.
 */
 function printSource(node) {
-	const nodes = node.nodes;
-	if (!nodes || nodes.length === 0) return "";
-	let result = "";
-	for (const child of nodes) {
-		const text = printCodeNode(child);
-		if (!text) continue;
-		result = result ? `${result}\n\n${text}` : text;
-	}
-	return result;
+	return printNodes({
+		nodes: node.nodes,
+		separator: "\n\n"
+	});
 }
 /**
-* Wraps a module specifier in single quotes, escaping any embedded backslash or quote so the emitted
-* statement stays valid even for unusual paths.
+* Wraps a module specifier in single quotes, escaping embedded backslashes and quotes.
 */
 function quoteModulePath(path) {
 	return `'${path.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
 }
 /**
-* Renders an import declaration string in the repo style (single quotes, no semicolons), covering
-* default, namespace (`* as`), and named imports with `{ a as b }` aliases, each optionally
-* `type`-only. `path` is used verbatim, so resolve it first.
-*
-* @example
-* ```ts
-* printImport({ name: ['z'], path: './zod.ts' })
-* // "import { z } from './zod.ts'"
-* ```
+* Renders an `import` declaration (default, `* as`, or named with `{ a as b }`, each optionally `type`-only). `path` is used verbatim, so resolve it first.
 */
 function printImport({ name, path, isTypeOnly = false, isNameSpace = false }) {
 	const typePrefix = isTypeOnly ? "type " : "";
@@ -510,21 +376,13 @@ function printImport({ name, path, isTypeOnly = false, isNameSpace = false }) {
 	}).join(", ")} } from ${from}`;
 }
 /**
-* Renders an export declaration string in the repo style (single quotes, no semicolons), covering
-* named re-exports, namespace alias (`* as name`), and wildcard, each optionally `type`-only.
-* `path` is used verbatim, so resolve it first.
-*
-* @example
-* ```ts
-* printExport({ name: ['Pet', 'Order'], path: './models.ts' })
-* // "export { Pet, Order } from './models.ts'"
-* ```
+* Renders an `export … from` declaration (named, `* as name`, or wildcard, each optionally `type`-only). `path` is used verbatim, so resolve it first.
 */
 function printExport({ path, name, isTypeOnly = false, asAlias = false }) {
 	const typePrefix = isTypeOnly ? "type " : "";
 	const from = quoteModulePath(path);
-	if (Array.isArray(name)) return `export ${typePrefix}{ ${name.map((item) => typeof item === "string" ? item : item.text).join(", ")} } from ${from}`;
-	if (asAlias && name) return `export ${typePrefix}* as ${LEADING_DIGIT_PATTERN.test(name) ? `_${name.slice(1)}` : name} from ${from}`;
+	if (Array.isArray(name)) return `export ${typePrefix}{ ${name.join(", ")} } from ${from}`;
+	if (asAlias && name) return `export ${typePrefix}* as ${/^\d/.test(name) ? `_${name.slice(1)}` : name} from ${from}`;
 	if (name) return `export ${typePrefix}{ ${name} } from ${from}`;
 	return `export ${typePrefix}* from ${from}`;
 }
@@ -559,33 +417,17 @@ const parserTs = defineParser(({ extension = DEFAULT_EXTENSION } = {}) => {
 	return {
 		name: "typescript",
 		extNames: [".ts", ".js"],
-		print(...nodes) {
-			return print(...nodes);
-		},
+		print,
 		parse(file) {
 			const extname = extension[file.extname] || void 0;
-			const sourceParts = [];
-			for (const item of file.sources) {
-				const sourceStr = printSource(item);
-				if (sourceStr) sourceParts.push(sourceStr.trimEnd());
-			}
-			const source = sourceParts.join("\n\n");
-			const importLines = [];
-			for (const item of file.imports) {
-				const importPath = item.root ? getRelativePath(item.root, item.path) : item.path;
-				importLines.push(printImport({
-					name: item.name,
-					path: resolveOutputPath(importPath, { extname }, Boolean(item.root)),
-					isTypeOnly: item.isTypeOnly,
-					isNameSpace: item.isNameSpace
-				}));
-			}
-			const exportLines = [];
-			for (const item of file.exports) exportLines.push(printExport({
-				name: item.name,
-				path: resolveOutputPath(item.path, { extname }, item.path.startsWith(".")),
-				isTypeOnly: item.isTypeOnly,
-				asAlias: item.asAlias
+			const source = file.sources.map((item) => printSource(item)).filter(Boolean).map((text) => text.trimEnd()).join("\n\n");
+			const importLines = file.imports.map((item) => printImport({
+				...item,
+				path: resolveOutputPath(item.root ? getRelativePath(item.root, item.path) : item.path, { extname }, Boolean(item.root))
+			}));
+			const exportLines = file.exports.map((item) => printExport({
+				...item,
+				path: resolveOutputPath(item.path, { extname }, item.path.startsWith("."))
 			}));
 			const importExportBlock = [...importLines, ...exportLines].join("\n");
 			return [
@@ -632,20 +474,11 @@ const parserTs = defineParser(({ extension = DEFAULT_EXTENSION } = {}) => {
 * })
 * ```
 */
-const parserTsx = defineParser((options = {}) => {
-	const parser = parserTs(options);
-	return {
-		name: "tsx",
-		extNames: [".tsx", ".jsx"],
-		print(...nodes) {
-			return print(...nodes);
-		},
-		parse(file) {
-			return parser.parse(file);
-		},
-		copy: parser.copy
-	};
-});
+const parserTsx = defineParser((options) => ({
+	...parserTs(options),
+	name: "tsx",
+	extNames: [".tsx", ".jsx"]
+}));
 //#endregion
 export { parserTs, parserTsx };