@kubb/ast 5.0.0-beta.7 → 5.0.0-beta.71

package/dist/visitor-dcVC5TOW.js

@@ -0,0 +1,1313 @@
+import "./rolldown-runtime-CNktS9qV.js";
+import { hash } from "node:crypto";
+import path from "node:path";
+//#region src/constants.ts
+const visitorDepths = {
+	shallow: "shallow",
+	deep: "deep"
+};
+/**
+* Schema type discriminators used by all AST schema nodes.
+*
+* Each value is a stable discriminator across the AST (for example `schema.type === schemaTypes.object`).
+*/
+const schemaTypes = {
+	/**
+	* Text value.
+	*/
+	string: "string",
+	/**
+	* Floating-point number (`float`, `double`).
+	*/
+	number: "number",
+	/**
+	* Whole number (`int32`). Use `bigint` for `int64`.
+	*/
+	integer: "integer",
+	/**
+	* 64-bit integer (`int64`). Only used when `integerType` is set to `'bigint'`.
+	*/
+	bigint: "bigint",
+	/**
+	* Boolean value.
+	*/
+	boolean: "boolean",
+	/**
+	* Explicit null value.
+	*/
+	null: "null",
+	/**
+	* Any value (no type restriction).
+	*/
+	any: "any",
+	/**
+	* Unknown value (must be narrowed before usage).
+	*/
+	unknown: "unknown",
+	/**
+	* No return value (`void`).
+	*/
+	void: "void",
+	/**
+	* Object with named properties.
+	*/
+	object: "object",
+	/**
+	* Sequential list of items.
+	*/
+	array: "array",
+	/**
+	* Fixed-length list with position-specific items.
+	*/
+	tuple: "tuple",
+	/**
+	* "One of" multiple schema members.
+	*/
+	union: "union",
+	/**
+	* "All of" multiple schema members.
+	*/
+	intersection: "intersection",
+	/**
+	* Enum schema.
+	*/
+	enum: "enum",
+	/**
+	* Reference to another schema.
+	*/
+	ref: "ref",
+	/**
+	* Calendar date (for example `2026-03-24`).
+	*/
+	date: "date",
+	/**
+	* Date-time value (for example `2026-03-24T09:00:00Z`).
+	*/
+	datetime: "datetime",
+	/**
+	* Time-only value (for example `09:00:00`).
+	*/
+	time: "time",
+	/**
+	* UUID value.
+	*/
+	uuid: "uuid",
+	/**
+	* Email address value.
+	*/
+	email: "email",
+	/**
+	* URL value.
+	*/
+	url: "url",
+	/**
+	* IPv4 address value.
+	*/
+	ipv4: "ipv4",
+	/**
+	* IPv6 address value.
+	*/
+	ipv6: "ipv6",
+	/**
+	* Binary/blob value.
+	*/
+	blob: "blob",
+	/**
+	* Impossible value (`never`).
+	*/
+	never: "never"
+};
+/**
+* One indentation level, derived from {@link INDENT_SIZE}.
+*/
+const INDENT = Array.from({ length: 2 }, () => " ").join("");
+//#endregion
+//#region src/guards.ts
+/**
+* Narrows a `SchemaNode` to the variant that matches `type`.
+*
+* @example
+* ```ts
+* const schema = createSchema({ type: 'string' })
+* const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
+* ```
+*/
+function narrowSchema(node, type) {
+	return node?.type === type ? node : null;
+}
+/**
+* Narrows an `OperationNode` to an `HttpOperationNode` so `method` and `path` are present.
+*
+* @example
+* ```ts
+* if (isHttpOperationNode(node)) {
+*   console.log(node.method, node.path)
+* }
+* ```
+*/
+function isHttpOperationNode(node) {
+	return node.protocol === "http" || node.method !== void 0 && node.path !== void 0;
+}
+//#endregion
+//#region src/defineNode.ts
+/**
+* Visitor callback names, one per traversable node kind, in traversal order.
+* Kept in sync with the keys of `Visitor` in `visitor.ts`.
+*/
+const visitorKeys = [
+	"input",
+	"output",
+	"operation",
+	"schema",
+	"property",
+	"parameter",
+	"response"
+];
+/**
+* Builds a type guard that matches nodes of the given `kind`.
+*/
+function isKind(kind) {
+	return (node) => node?.kind === kind;
+}
+/**
+* Defines a node once and derives its `create` builder, `is` guard, and traversal
+* metadata. `create` merges `defaults`, the `build` hook (or the raw input), and the
+* `kind`, so node construction lives in one place without scattered `as` casts.
+*
+* @example Simple node
+* ```ts
+* const importDef = defineNode<ImportNode>({ kind: 'Import' })
+* const createImport = importDef.create
+* ```
+*
+* @example Node with a build hook
+* ```ts
+* const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
+*   kind: 'Property',
+*   build: (props) => ({ ...props, required: props.required ?? false }),
+*   children: ['schema'],
+*   visitorKey: 'property',
+* })
+* ```
+*/
+function defineNode(config) {
+	const { kind, defaults, build, children, visitorKey } = config;
+	function create(input) {
+		const base = build ? build(input) : input;
+		return {
+			...defaults,
+			...base,
+			kind
+		};
+	}
+	return {
+		kind,
+		create,
+		is: isKind(kind),
+		children,
+		visitorKey
+	};
+}
+//#endregion
+//#region src/nodes/code.ts
+/**
+* Definition for the {@link ConstNode}.
+*/
+const constDef = defineNode({ kind: "Const" });
+/**
+* Definition for the {@link TypeNode}.
+*/
+const typeDef = defineNode({ kind: "Type" });
+/**
+* Definition for the {@link FunctionNode}.
+*/
+const functionDef = defineNode({ kind: "Function" });
+/**
+* Definition for the {@link ArrowFunctionNode}.
+*/
+const arrowFunctionDef = defineNode({ kind: "ArrowFunction" });
+/**
+* Definition for the {@link TextNode}.
+*/
+const textDef = defineNode({
+	kind: "Text",
+	build: (value) => ({ value })
+});
+/**
+* Definition for the {@link BreakNode}.
+*/
+const breakDef = defineNode({
+	kind: "Break",
+	build: () => ({})
+});
+/**
+* Definition for the {@link JsxNode}.
+*/
+const jsxDef = defineNode({
+	kind: "Jsx",
+	build: (value) => ({ value })
+});
+/**
+* Creates a `ConstNode` representing a TypeScript `const` declaration.
+*
+* @example Exported constant with type and `as const`
+* ```ts
+* createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
+* // export const pets: Pet[] = ... as const
+* ```
+*/
+const createConst = constDef.create;
+/**
+* Creates a `TypeNode` representing a TypeScript `type` alias declaration.
+*
+* @example
+* ```ts
+* createType({ name: 'Pet', export: true })
+* // export type Pet = ...
+* ```
+*/
+const createType = typeDef.create;
+/**
+* Creates a `FunctionNode` representing a TypeScript `function` declaration.
+*
+* @example
+* ```ts
+* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
+* // export async function fetchPet(): Promise<Pet> { ... }
+* ```
+*/
+const createFunction = functionDef.create;
+/**
+* Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
+*
+* @example
+* ```ts
+* createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
+* // export const double = (n: number) => ...
+* ```
+*/
+const createArrowFunction = arrowFunctionDef.create;
+/**
+* Creates a {@link TextNode} representing a raw string fragment in the source output.
+*
+* @example
+* ```ts
+* createText('return fetch(id)')
+* // { kind: 'Text', value: 'return fetch(id)' }
+* ```
+*/
+const createText = textDef.create;
+/**
+* Creates a {@link BreakNode} representing a line break in the source output.
+*
+* @example
+* ```ts
+* createBreak()
+* // { kind: 'Break' }
+* ```
+*/
+function createBreak() {
+	return breakDef.create();
+}
+/**
+* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
+*
+* @example
+* ```ts
+* createJsx('<>\n  <a href={href}>Open</a>\n</>')
+* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
+* ```
+*/
+const createJsx = jsxDef.create;
+//#endregion
+//#region src/nodes/content.ts
+/**
+* Definition for the {@link ContentNode}.
+*/
+const contentDef = defineNode({
+	kind: "Content",
+	children: ["schema"]
+});
+/**
+* Creates a `ContentNode` for a single request-body or response content type.
+*/
+const createContent = contentDef.create;
+//#endregion
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+*/
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+/**
+* Converts `text` to PascalCase.
+*
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
+*
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
+*/
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+}
+//#endregion
+//#region ../../internals/utils/src/fs.ts
+/**
+* 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.
+*
+* @example
+* trimExtName('petStore.ts')             // 'petStore'
+* trimExtName('/src/models/pet.ts')      // '/src/models/pet'
+* trimExtName('/project.v2/gen/pet.ts')  // '/project.v2/gen/pet'
+* trimExtName('noExtension')             // 'noExtension'
+*/
+function trimExtName(text) {
+	const dotIndex = text.lastIndexOf(".");
+	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
+	return text;
+}
+//#endregion
+//#region src/utils/extractStringsFromNodes.ts
+/**
+* Extracts all string content from a `CodeNode` tree recursively.
+*
+* Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
+* and nested node content. Used to build the full source string for import filtering.
+*/
+function extractStringsFromNodes(nodes) {
+	if (!nodes?.length) return "";
+	return nodes.map((node) => {
+		if (typeof node === "string") return node;
+		if (node.kind === "Text") return node.value;
+		if (node.kind === "Break") return "";
+		if (node.kind === "Jsx") return node.value;
+		const parts = [];
+		if ("params" in node && node.params) parts.push(node.params);
+		if ("generics" in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(", ") : node.generics);
+		if ("returnType" in node && node.returnType) parts.push(node.returnType);
+		if ("type" in node && typeof node.type === "string") parts.push(node.type);
+		const nested = extractStringsFromNodes(node.nodes);
+		if (nested) parts.push(nested);
+		return parts.join("\n");
+	}).filter(Boolean).join("\n");
+}
+//#endregion
+//#region src/utils/fileMerge.ts
+function sourceKey(source) {
+	return `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
+}
+function pathTypeKey(path, isTypeOnly) {
+	return `${path}:${isTypeOnly ?? false}`;
+}
+function exportKey(path, name, isTypeOnly, asAlias) {
+	return `${path}:${name ?? ""}:${isTypeOnly ?? false}:${asAlias ?? ""}`;
+}
+function importKey(path, name, isTypeOnly) {
+	return `${path}:${name ?? ""}:${isTypeOnly ?? false}`;
+}
+/**
+* Computes a multi-level sort key for exports and imports:
+* non-array names first (wildcards/namespace aliases). Type-only before value. Alphabetical path. Unnamed before named.
+*/
+function sortKey(node) {
+	const isArray = Array.isArray(node.name) ? "1" : "0";
+	const typeOnly = node.isTypeOnly ? "0" : "1";
+	const hasName = node.name != null ? "1" : "0";
+	const name = Array.isArray(node.name) ? node.name.toSorted().join("\0") : node.name ?? "";
+	return `${isArray}:${typeOnly}:${node.path}:${hasName}:${name}`;
+}
+/**
+* Deduplicates `SourceNode` objects by `name + isExportable + isTypeOnly`, keeping the first of each
+* key. Unnamed sources fall back to their extracted node strings as the name part of the key. Returns
+* the deduplicated array in original order.
+*/
+function combineSources(sources) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const key = sourceKey(source);
+		if (!seen.has(key)) seen.set(key, source);
+	}
+	return [...seen.values()];
+}
+/**
+* Merges `incoming` names into `existing`, preserving order and dropping duplicates.
+*
+* Shared by `combineExports` and `combineImports` for the same-path name-merge case.
+*/
+function mergeNameArrays(existing, incoming) {
+	const merged = new Set(existing);
+	for (const name of incoming) merged.add(name);
+	return [...merged];
+}
+/**
+* Deduplicates and merges `ExportNode` objects by path and type.
+*
+* Named exports with the same path and `isTypeOnly` flag have their names merged into a single export.
+* Non-array exports are deduplicated by exact identity. Returns a sorted, deduplicated array.
+*/
+function combineExports(exports) {
+	const result = [];
+	const namedByPath = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const keyed = exports.map((node) => ({
+		node,
+		key: sortKey(node)
+	}));
+	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	for (const { node: curr } of keyed) {
+		const { name, path, isTypeOnly, asAlias } = curr;
+		if (Array.isArray(name)) {
+			if (!name.length) continue;
+			const key = pathTypeKey(path, isTypeOnly);
+			const existing = namedByPath.get(key);
+			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+			else {
+				const newItem = {
+					...curr,
+					name: [...new Set(name)]
+				};
+				result.push(newItem);
+				namedByPath.set(key, newItem);
+			}
+		} else {
+			const key = exportKey(path, name, isTypeOnly, asAlias);
+			if (!seen.has(key)) {
+				result.push(curr);
+				seen.add(key);
+			}
+		}
+	}
+	return result;
+}
+/**
+* Deduplicates and merges `ImportNode` objects, filtering out unused imports.
+*
+* Retains imports that are referenced in `source` or re-exported. Imports with the same path and
+* `isTypeOnly` flag have their names merged. Returns a sorted, deduplicated, filtered array.
+*/
+function combineImports(imports, exports, source) {
+	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
+	const isUsed = (importName) => !source || source.includes(importName) || exportedNames.has(importName);
+	const importNameMemo = /* @__PURE__ */ new Map();
+	const canonicalizeName = (n) => {
+		if (typeof n === "string") return n;
+		const key = `${n.propertyName}:${n.name ?? ""}`;
+		if (!importNameMemo.has(key)) importNameMemo.set(key, n);
+		return importNameMemo.get(key);
+	};
+	const pathsWithUsedNamedImport = /* @__PURE__ */ new Set();
+	for (const node of imports) {
+		if (!Array.isArray(node.name)) continue;
+		if (node.name.some((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName))) pathsWithUsedNamedImport.add(node.path);
+	}
+	const result = [];
+	const namedByPath = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const keyed = imports.map((node) => ({
+		node,
+		key: sortKey(node)
+	}));
+	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	for (const { node: curr } of keyed) {
+		if (curr.path === curr.root) continue;
+		const { path, isTypeOnly } = curr;
+		let { name } = curr;
+		if (Array.isArray(name)) {
+			name = [...new Set(name.map(canonicalizeName))].filter((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName));
+			if (!name.length) continue;
+			const key = pathTypeKey(path, isTypeOnly);
+			const existing = namedByPath.get(key);
+			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+			else {
+				const newItem = {
+					...curr,
+					name
+				};
+				result.push(newItem);
+				namedByPath.set(key, newItem);
+			}
+		} else {
+			if (name && !isUsed(name) && !pathsWithUsedNamedImport.has(path)) continue;
+			const key = importKey(path, name, isTypeOnly);
+			if (!seen.has(key)) {
+				result.push(curr);
+				seen.add(key);
+			}
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/nodes/file.ts
+/**
+* Definition for the {@link ImportNode}.
+*/
+const importDef = defineNode({ kind: "Import" });
+/**
+* Definition for the {@link ExportNode}.
+*/
+const exportDef = defineNode({ kind: "Export" });
+/**
+* Definition for the {@link SourceNode}.
+*/
+const sourceDef = defineNode({ kind: "Source" });
+/**
+* Definition for the {@link FileNode}. The fully resolved builder lives in
+* `createFile`, so this definition only supplies the guard.
+*/
+const fileDef = defineNode({ kind: "File" });
+/**
+* Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
+*
+* @example Named import
+* ```ts
+* createImport({ name: ['useState'], path: 'react' })
+* // import { useState } from 'react'
+* ```
+*/
+const createImport = importDef.create;
+/**
+* Creates an `ExportNode` representing a language-agnostic export/public API declaration.
+*
+* @example Named export
+* ```ts
+* createExport({ name: ['Pet'], path: './Pet' })
+* // export { Pet } from './Pet'
+* ```
+*/
+const createExport = exportDef.create;
+/**
+* Creates a `SourceNode` representing a fragment of source code within a file.
+*
+* @example
+* ```ts
+* createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
+* ```
+*/
+const createSource = sourceDef.create;
+/**
+* Creates a fully resolved `FileNode` from a file input descriptor.
+*
+* Computes:
+* - `id` SHA256 hash of the file path
+* - `name` `baseName` without extension
+* - `extname` extension extracted from `baseName`
+*
+* Deduplicates:
+* - `sources` via `combineSources`
+* - `exports` via `combineExports`
+* - `imports` via `combineImports` (also filters unused imports)
+*
+* @throws {Error} when `baseName` has no extension.
+*
+* @example
+* ```ts
+* const file = createFile({
+*   baseName: 'petStore.ts',
+*   path: 'src/models/petStore.ts',
+*   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
+*   imports: [createImport({ name: ['z'], path: 'zod' })],
+*   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+* })
+* // file.id      = SHA256 hash of 'src/models/petStore.ts'
+* // file.name    = 'petStore'
+* // file.extname = '.ts'
+* ```
+*
+* @example Copy a real file into the output verbatim
+* ```ts
+* const file = createFile({
+*   baseName: 'client.ts',
+*   path: 'src/gen/client.ts',
+*   copy: '/abs/path/to/templates/client.ts',
+* })
+* ```
+*/
+function createFile(input) {
+	const extname = path.extname(input.baseName) || (input.baseName.startsWith(".") ? input.baseName : "");
+	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
+	const source = (input.sources ?? []).flatMap((item) => item.nodes ?? []).map((node) => extractStringsFromNodes([node])).filter(Boolean).join("\n\n");
+	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
+	const combinedImports = input.imports?.length ? combineImports(input.imports, resolvedExports, source || void 0) : [];
+	const localNames = new Set((input.sources ?? []).map((item) => item.name).filter((name) => Boolean(name)));
+	const nameOf = (item) => typeof item === "string" ? item : item.name ?? item.propertyName;
+	const resolvedImports = combinedImports.filter((imp) => imp.path !== input.path).flatMap((imp) => {
+		if (!Array.isArray(imp.name)) return typeof imp.name === "string" && localNames.has(imp.name) ? [] : [imp];
+		const kept = imp.name.filter((item) => !localNames.has(nameOf(item)));
+		if (!kept.length) return [];
+		return [kept.length === imp.name.length ? imp : {
+			...imp,
+			name: kept
+		}];
+	});
+	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
+	return {
+		kind: "File",
+		...input,
+		id: hash("sha256", input.path, "hex"),
+		name: trimExtName(input.baseName),
+		extname,
+		imports: resolvedImports,
+		exports: resolvedExports,
+		sources: resolvedSources,
+		meta: input.meta ?? {}
+	};
+}
+//#endregion
+//#region src/nodes/function.ts
+/**
+* Definition for the {@link TypeLiteralNode}.
+*/
+const typeLiteralDef = defineNode({ kind: "TypeLiteral" });
+/**
+* Definition for the {@link IndexedAccessTypeNode}.
+*/
+const indexedAccessTypeDef = defineNode({ kind: "IndexedAccessType" });
+/**
+* Definition for the {@link ObjectBindingPatternNode}.
+*/
+const objectBindingPatternDef = defineNode({ kind: "ObjectBindingPattern" });
+/**
+* Definition for the {@link FunctionParameterNode}. `optional` defaults to `false`.
+* Passing `properties` builds a destructured group: an {@link ObjectBindingPatternNode} name
+* paired with a {@link TypeLiteralNode} type.
+*/
+const functionParameterDef = defineNode({
+	kind: "FunctionParameter",
+	build: (input) => {
+		if ("properties" in input) return {
+			name: createObjectBindingPattern({ elements: input.properties.map((p) => ({ name: p.name })) }),
+			type: createTypeLiteral({ members: input.properties.map((p) => ({
+				name: p.name,
+				type: p.type,
+				optional: p.optional ?? false
+			})) }),
+			optional: input.optional ?? false,
+			...input.default !== void 0 ? { default: input.default } : {}
+		};
+		return {
+			optional: false,
+			...input
+		};
+	}
+});
+/**
+* Definition for the {@link FunctionParametersNode}.
+*/
+const functionParametersDef = defineNode({
+	kind: "FunctionParameters",
+	defaults: { params: [] }
+});
+/**
+* Creates a {@link TypeLiteralNode} representing an inline anonymous object type.
+*
+* @example
+* ```ts
+* createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
+* // { petId: string }
+* ```
+*/
+const createTypeLiteral = typeLiteralDef.create;
+/**
+* Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
+*
+* @example
+* ```ts
+* createIndexedAccessType({ target: 'DeletePetPathParams', key: 'petId' })
+* // DeletePetPathParams['petId']
+* ```
+*/
+const createIndexedAccessType = indexedAccessTypeDef.create;
+/**
+* Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
+*
+* @example
+* ```ts
+* createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+* // { id, name }
+* ```
+*/
+const createObjectBindingPattern = objectBindingPatternDef.create;
+/**
+* Creates a `FunctionParameterNode`. `optional` defaults to `false`.
+*
+* @example Optional param
+* ```ts
+* createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
+* // → params?: QueryParams
+* ```
+*
+* @example Destructured group
+* ```ts
+* createFunctionParameter({ properties: [{ name: 'id', type: 'string' }, { name: 'name', type: 'string', optional: true }], default: '{}' })
+* // → { id, name }: { id: string; name?: string } = {}
+* ```
+*
+* @example Destructured group typed from a single reference
+* ```ts
+* createFunctionParameter({ name: createObjectBindingPattern({ elements: [{ name: 'path' }] }), type: "Omit<Config, 'url'>", default: '{}' })
+* // → { path }: Omit<Config, 'url'> = {}
+* ```
+*/
+const createFunctionParameter = functionParameterDef.create;
+/**
+* Creates a `FunctionParametersNode` from an ordered list of parameters.
+*
+* @example
+* ```ts
+* const empty = createFunctionParameters()
+* // { kind: 'FunctionParameters', params: [] }
+* ```
+*/
+function createFunctionParameters(props = {}) {
+	return functionParametersDef.create(props);
+}
+//#endregion
+//#region src/nodes/input.ts
+/**
+* Definition for the {@link InputNode}.
+*/
+const inputDef = defineNode({
+	kind: "Input",
+	defaults: {
+		schemas: [],
+		operations: [],
+		meta: {
+			circularNames: [],
+			enumNames: []
+		}
+	},
+	children: ["schemas", "operations"],
+	visitorKey: "input"
+});
+/**
+* Creates an `InputNode`. Pass `stream: true` for the streaming variant whose `schemas` and
+* `operations` are `AsyncIterable` sources. Otherwise it builds the eager variant with array
+* `schemas`/`operations`. Both variants get the defaulted `meta`.
+*
+* @example Eager
+* ```ts
+* const input = createInput()
+* // { kind: 'Input', schemas: [], operations: [] }
+* ```
+*
+* @example Streaming
+* ```ts
+* const node = createInput({ stream: true, schemas: schemasIterable, operations: operationsIterable, meta: { title: 'My API' } })
+* ```
+*/
+function createInput(options = {}) {
+	const { stream, ...overrides } = options;
+	if (stream) return {
+		kind: "Input",
+		meta: {
+			circularNames: [],
+			enumNames: []
+		},
+		...overrides
+	};
+	return inputDef.create(overrides);
+}
+//#endregion
+//#region src/nodes/requestBody.ts
+/**
+* Definition for the {@link RequestBodyNode}. Content entries are built upfront with
+* {@link createContent}, mirroring how `parameters` and `responses` take prebuilt nodes.
+*/
+const requestBodyDef = defineNode({
+	kind: "RequestBody",
+	children: ["content"]
+});
+/**
+* Creates a `RequestBodyNode`.
+*/
+const createRequestBody = requestBodyDef.create;
+//#endregion
+//#region src/nodes/operation.ts
+/**
+* Definition for the {@link OperationNode}. HTTP operations (those carrying both
+* `method` and `path`) are tagged with `protocol: 'http'`, and the request body is
+* normalized into a `RequestBodyNode`.
+*/
+const operationDef = defineNode({
+	kind: "Operation",
+	build: (props) => {
+		const { requestBody, ...rest } = props;
+		const isHttp = rest.method !== void 0 && rest.path !== void 0;
+		return {
+			tags: [],
+			parameters: [],
+			responses: [],
+			...rest,
+			...isHttp ? { protocol: "http" } : {},
+			requestBody: requestBody ? createRequestBody(requestBody) : void 0
+		};
+	},
+	children: [
+		"parameters",
+		"requestBody",
+		"responses"
+	],
+	visitorKey: "operation"
+});
+function createOperation(props) {
+	return operationDef.create(props);
+}
+//#endregion
+//#region src/nodes/output.ts
+/**
+* Definition for the {@link OutputNode}.
+*/
+const outputDef = defineNode({
+	kind: "Output",
+	defaults: { files: [] },
+	visitorKey: "output"
+});
+/**
+* Creates an `OutputNode` with a stable default for `files`.
+*
+* @example
+* ```ts
+* const output = createOutput()
+* // { kind: 'Output', files: [] }
+* ```
+*/
+function createOutput(overrides = {}) {
+	return outputDef.create(overrides);
+}
+//#endregion
+//#region src/optionality.ts
+/**
+* Generic JSON Schema optionality: a non-required field is optional, and a
+* non-required nullable field is nullish.
+*/
+function optionality(schema, required) {
+	const nullable = schema.nullable ?? false;
+	return {
+		...schema,
+		optional: !required && !nullable ? true : void 0,
+		nullish: !required && nullable ? true : void 0
+	};
+}
+//#endregion
+//#region src/nodes/parameter.ts
+/**
+* Definition for the {@link ParameterNode}. `required` defaults to `false`, and the schema's
+* `optional`/`nullish` flags are derived from it through {@link optionality}.
+*/
+const parameterDef = defineNode({
+	kind: "Parameter",
+	build: (props) => {
+		const required = props.required ?? false;
+		return {
+			...props,
+			required,
+			schema: optionality(props.schema, required)
+		};
+	},
+	children: ["schema"],
+	visitorKey: "parameter"
+});
+/**
+* Creates a `ParameterNode`.
+*
+* @example
+* ```ts
+* const param = createParameter({
+*   name: 'petId',
+*   in: 'path',
+*   required: true,
+*   schema: createSchema({ type: 'string' }),
+* })
+* ```
+*/
+const createParameter = parameterDef.create;
+//#endregion
+//#region src/nodes/property.ts
+/**
+* Definition for the {@link PropertyNode}. `required` defaults to `false`, and the schema's
+* `optional`/`nullish` flags are derived from it through {@link optionality}.
+*/
+const propertyDef = defineNode({
+	kind: "Property",
+	build: (props) => {
+		const required = props.required ?? false;
+		return {
+			...props,
+			required,
+			schema: optionality(props.schema, required)
+		};
+	},
+	children: ["schema"],
+	visitorKey: "property"
+});
+/**
+* Creates a `PropertyNode`.
+*
+* @example
+* ```ts
+* const property = createProperty({
+*   name: 'status',
+*   required: true,
+*   schema: createSchema({ type: 'string', nullable: true }),
+* })
+* // required=true, no optional/nullish
+* ```
+*/
+const createProperty = propertyDef.create;
+//#endregion
+//#region src/nodes/response.ts
+/**
+* Definition for the {@link ResponseNode}. A single legacy `schema` (with optional
+* `mediaType`/`keysToOmit`) is normalized into one `content` entry.
+*/
+const responseDef = defineNode({
+	kind: "Response",
+	build: (props) => {
+		const { schema, mediaType, keysToOmit, content, ...rest } = props;
+		const entries = content ?? (schema ? [createContent({
+			contentType: mediaType ?? "application/json",
+			schema,
+			keysToOmit: keysToOmit ?? null
+		})] : void 0);
+		return {
+			...rest,
+			content: entries
+		};
+	},
+	children: ["content"],
+	visitorKey: "response"
+});
+/**
+* Creates a `ResponseNode`.
+*
+* @example
+* ```ts
+* const response = createResponse({
+*   statusCode: '200',
+*   content: [createContent({ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) })],
+* })
+* ```
+*/
+const createResponse = responseDef.create;
+//#endregion
+//#region src/nodes/schema.ts
+/**
+* Maps schema `type` to its underlying `primitive`.
+* Primitive types map to themselves and special string formats map to `'string'`.
+* Any type not listed here (such as `ref`, `enum`, `union`, `intersection`, `tuple`, `ipv4`, `ipv6`, `blob`) has no `primitive`.
+*/
+const TYPE_TO_PRIMITIVE = {
+	string: "string",
+	number: "number",
+	integer: "integer",
+	bigint: "bigint",
+	boolean: "boolean",
+	null: "null",
+	any: "any",
+	unknown: "unknown",
+	void: "void",
+	never: "never",
+	object: "object",
+	array: "array",
+	date: "date",
+	uuid: "string",
+	email: "string",
+	url: "string",
+	datetime: "string",
+	time: "string"
+};
+/**
+* Definition for the {@link SchemaNode}. Object schemas default `properties` to an
+* empty array, and `primitive` is inferred from `type` when not explicitly provided.
+*/
+const schemaDef = defineNode({
+	kind: "Schema",
+	build: (props) => {
+		if (props.type === "object") return {
+			properties: [],
+			primitive: "object",
+			...props
+		};
+		return {
+			primitive: TYPE_TO_PRIMITIVE[props.type],
+			...props
+		};
+	},
+	children: [
+		"properties",
+		"items",
+		"members",
+		"additionalProperties"
+	],
+	visitorKey: "schema"
+});
+function createSchema(props) {
+	return schemaDef.create(props);
+}
+//#endregion
+//#region src/registry.ts
+/**
+* Every node definition. Adding a node means adding its `defineNode` to one
+* `nodes/*.ts` file and listing it here. The visitor tables in `visitor.ts` derive from it.
+*/
+const nodeDefs = [
+	inputDef,
+	outputDef,
+	operationDef,
+	requestBodyDef,
+	contentDef,
+	responseDef,
+	schemaDef,
+	propertyDef,
+	parameterDef,
+	functionParameterDef,
+	functionParametersDef,
+	typeLiteralDef,
+	indexedAccessTypeDef,
+	objectBindingPatternDef,
+	constDef,
+	typeDef,
+	functionDef,
+	arrowFunctionDef,
+	textDef,
+	breakDef,
+	jsxDef,
+	importDef,
+	exportDef,
+	sourceDef,
+	fileDef
+];
+//#endregion
+//#region src/visitor.ts
+/**
+* Child node fields per node kind, in traversal order (Babel's `VISITOR_KEYS`).
+* Derived from each definition's `children`.
+*/
+const VISITOR_KEYS = Object.fromEntries(nodeDefs.flatMap((def) => def.children ? [[def.kind, def.children]] : []));
+/**
+* Maps a node kind to the matching visitor callback name. Derived from each
+* definition's `visitorKey`.
+*/
+const VISITOR_KEY_BY_KIND = Object.fromEntries(nodeDefs.flatMap((def) => def.visitorKey ? [[def.kind, def.visitorKey]] : []));
+/**
+* Creates a small async concurrency limiter.
+*
+* At most `concurrency` tasks are in flight at once. Extra tasks are queued.
+*
+* @example
+* ```ts
+* const limit = createLimit(2)
+* for (const task of [taskA, taskB, taskC]) {
+*   await limit(() => task())
+* }
+* // only 2 tasks run at the same time
+* ```
+*/
+function createLimit(concurrency) {
+	let active = 0;
+	const queue = [];
+	function next() {
+		if (active < concurrency && queue.length > 0) {
+			active++;
+			queue.shift()();
+		}
+	}
+	return function limit(fn) {
+		return new Promise((resolve, reject) => {
+			queue.push(() => {
+				Promise.resolve(fn()).then(resolve, reject).finally(() => {
+					active--;
+					next();
+				});
+			});
+			next();
+		});
+	};
+}
+const visitorKeysByKind = VISITOR_KEYS;
+/**
+* Returns `true` when `value` is an AST node (an object carrying a `kind`).
+*/
+function isNode(value) {
+	return typeof value === "object" && value !== null && "kind" in value;
+}
+/**
+* Returns the immediate traversable children of `node` based on {@link VISITOR_KEYS}.
+*
+* `Schema` children are only included when `recurse` is `true`. Shallow mode skips them.
+*
+* @example
+* ```ts
+* const children = getChildren(operationNode, true)
+* // returns parameters, the request body, and responses
+* ```
+*/
+function* getChildren(node, recurse) {
+	if (node.kind === "Schema" && !recurse) return;
+	const keys = visitorKeysByKind[node.kind];
+	if (!keys) return;
+	const record = node;
+	for (const key of keys) {
+		const value = record[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) yield item;
+		} else if (isNode(value)) yield value;
+	}
+}
+/**
+* Runs the visitor callback that matches `node.kind` with the traversal
+* context. The result is a replacement node, a collected value, or `undefined`
+* when no callback is registered for the kind.
+*
+* Shared by `walk`, `transform`, and `collectLazy` so node-kind dispatch lives
+* in one place. `TResult` is the caller's expected return: the same node type
+* for `transform`, the collected value type for `collectLazy`, ignored for `walk`.
+*/
+function applyVisitor(node, visitor, parent) {
+	const key = VISITOR_KEY_BY_KIND[node.kind];
+	if (!key) return void 0;
+	const fn = visitor[key];
+	return fn?.(node, { parent });
+}
+/**
+* Async depth-first traversal for side effects. Visitor return values are
+* ignored. Use `transform` when you want to rewrite nodes.
+*
+* Sibling nodes at each depth run concurrently up to `options.concurrency`
+* (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor
+* work. Lower values reduce memory pressure.
+*
+* @example Log every operation
+* ```ts
+* await walk(root, {
+*   operation(node) {
+*     console.log(node.operationId)
+*   },
+* })
+* ```
+*
+* @example Only visit the root node
+* ```ts
+* await walk(root, { depth: 'shallow', input: () => {} })
+* ```
+*/
+async function walk(node, options) {
+	return _walk(node, options, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30), void 0);
+}
+async function _walk(node, visitor, recurse, limit, parent) {
+	await limit(() => applyVisitor(node, visitor, parent));
+	const children = Array.from(getChildren(node, recurse));
+	if (children.length === 0) return;
+	await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit, node)));
+}
+function transform(node, options) {
+	const { depth, parent, ...visitor } = options;
+	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
+	return transformChildren(applyVisitor(node, visitor, parent) ?? node, options, recurse);
+}
+/**
+* Immutably rebuilds a node's children using {@link VISITOR_KEYS}, transforming
+* each child node and leaving non-node values (e.g. `additionalProperties: true`) intact.
+* `Schema` children are skipped in shallow mode.
+*/
+function transformChildren(node, options, recurse) {
+	if (node.kind === "Schema" && !recurse) return node;
+	const keys = visitorKeysByKind[node.kind];
+	if (!keys) return node;
+	const record = node;
+	const childOptions = {
+		...options,
+		parent: node
+	};
+	let updates;
+	for (const key of keys) {
+		if (!(key in record)) continue;
+		const value = record[key];
+		if (Array.isArray(value)) {
+			let changed = false;
+			const mapped = value.map((item) => {
+				if (!isNode(item)) return item;
+				const next = transform(item, childOptions);
+				if (next !== item) changed = true;
+				return next;
+			});
+			if (changed) (updates ??= {})[key] = mapped;
+		} else if (isNode(value)) {
+			const next = transform(value, childOptions);
+			if (next !== value) (updates ??= {})[key] = next;
+		}
+	}
+	return updates ? {
+		...node,
+		...updates
+	} : node;
+}
+/**
+* Lazy depth-first collection pass. Yields every non-null value returned by
+* the visitor callbacks. Use `collect` for the eager array form.
+*
+* @example Collect every operationId
+* ```ts
+* const ids: string[] = []
+* for (const id of collectLazy<string>(root, {
+*   operation(node) {
+*     return node.operationId
+*   },
+* })) {
+*   ids.push(id)
+* }
+* ```
+*/
+function* collectLazy(node, options) {
+	const { depth, parent, ...visitor } = options;
+	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
+	const v = applyVisitor(node, visitor, parent);
+	if (v != null) yield v;
+	for (const child of getChildren(node, recurse)) yield* collectLazy(child, {
+		...options,
+		parent: node
+	});
+}
+/**
+* Eager depth-first collection pass. Gathers every non-null value the visitor
+* callbacks return into an array.
+*
+* @example Collect every operationId
+* ```ts
+* const ids = collect<string>(root, {
+*   operation(node) {
+*     return node.operationId
+*   },
+* })
+* ```
+*/
+function collect(node, options) {
+	return Array.from(collectLazy(node, options));
+}
+//#endregion
+export { createJsx as $, indexedAccessTypeDef as A, sourceDef as B, createFunctionParameter as C, createTypeLiteral as D, createObjectBindingPattern as E, createImport as F, createContent as G, camelCase as H, createSource as I, constDef as J, arrowFunctionDef as K, exportDef as L, typeLiteralDef as M, createExport as N, functionParameterDef as O, createFile as P, createFunction as Q, fileDef as R, inputDef as S, createIndexedAccessType as T, pascalCase as U, extractStringsFromNodes as V, contentDef as W, createBreak as X, createArrowFunction as Y, createConst as Z, createOperation as _, nodeDefs as a, typeDef as at, requestBodyDef as b, createResponse as c, isHttpOperationNode as ct, propertyDef as d, schemaTypes as dt, createText as et, createParameter as f, outputDef as g, createOutput as h, walk as i, textDef as it, objectBindingPatternDef as j, functionParametersDef as k, responseDef as l, narrowSchema as lt, optionality as m, collectLazy as n, functionDef as nt, createSchema as o, defineNode as ot, parameterDef as p, breakDef as q, transform as r, jsxDef as rt, schemaDef as s, visitorKeys as st, collect as t, createType as tt, createProperty as u, INDENT as ut, operationDef as v, createFunctionParameters as w, createInput as x, createRequestBody as y, importDef as z };
+
+//# sourceMappingURL=visitor-dcVC5TOW.js.map