@kubb/ast 5.0.0-beta.6 → 5.0.0-beta.60

package/dist/utils-Dj_KoXMv.js

@@ -0,0 +1,1389 @@
+import "./chunk-CNktS9qV.js";
+import { A as contentDef, D as fileDef, E as exportDef, G as typeDef, H as functionDef, K as createProperty, M as arrowFunctionDef, N as breakDef, O as importDef, P as constDef, Q as schemaDef, S as typeLiteralDef, U as jsxDef, W as textDef, X as pascalCase, Y as camelCase, Z as createSchema, _ as createTypeLiteral, b as indexedAccessTypeDef, c as operationDef, f as inputDef, h as createIndexedAccessType, i as parameterDef, k as sourceDef, m as createFunctionParameters, n as responseDef, o as outputDef, p as createFunctionParameter, q as propertyDef, u as requestBodyDef, v as functionParameterDef, x as objectBindingPatternDef, y as functionParametersDef } from "./response-DKxTr522.js";
+//#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`).
+* Call `isScalarPrimitive()` to check for the scalar types.
+*/
+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"
+};
+/**
+* Scalar primitive schema types used for union simplification and type narrowing.
+*/
+const SCALAR_PRIMITIVE_TYPES = new Set([
+	"string",
+	"number",
+	"integer",
+	"bigint",
+	"boolean"
+]);
+/**
+* Returns `true` when `type` is a scalar primitive that can be assigned without wrapping
+* (for example `string | number | boolean`).
+*/
+function isScalarPrimitive(type) {
+	return SCALAR_PRIMITIVE_TYPES.has(type);
+}
+/**
+* HTTP method identifiers used by operation nodes.
+*/
+const httpMethods = {
+	get: "GET",
+	post: "POST",
+	put: "PUT",
+	patch: "PATCH",
+	delete: "DELETE",
+	head: "HEAD",
+	options: "OPTIONS",
+	trace: "TRACE"
+};
+/**
+* One indentation level, derived from {@link INDENT_SIZE}.
+*/
+const INDENT = Array.from({ length: 2 }, () => " ").join("");
+//#endregion
+//#region ../../internals/utils/src/promise.ts
+/**
+* Wraps `factory` with a keyed cache backed by the provided store.
+*
+* Pass a `WeakMap` for object keys (results are GC-eligible when the key is
+* collected) or a `Map` for primitive keys. For multi-argument functions,
+* nest two `memoize` calls — the outer keyed by the first argument, the
+* inner (created once per outer miss) keyed by the second.
+*
+* Because the cache is owned by the caller, it can be shared, inspected, or
+* cleared independently of the memoized function.
+*
+* @example Single WeakMap key
+* ```ts
+* const cache = new WeakMap<SchemaNode, Set<string>>()
+* const getRefs = memoize(cache, (node) => collectRefs(node))
+* ```
+*
+* @example Single Map key (primitive)
+* ```ts
+* const cache = new Map<string, Resolver>()
+* const getResolver = memoize(cache, (name) => buildResolver(name))
+* ```
+*
+* @example Two-level (object + primitive)
+* ```ts
+* const outer = new WeakMap<Params[], Map<string, Params[]>>()
+* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
+* fn(params)('camelcase')
+* ```
+*/
+function memoize(store, factory) {
+	return (key) => {
+		if (store.has(key)) return store.get(key);
+		const value = factory(key);
+		store.set(key, value);
+		return value;
+	};
+}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = new Set([
+	"abstract",
+	"arguments",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"function",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"int",
+	"interface",
+	"let",
+	"long",
+	"native",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"short",
+	"static",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"volatile",
+	"while",
+	"with",
+	"yield",
+	"Array",
+	"Date",
+	"hasOwnProperty",
+	"Infinity",
+	"isFinite",
+	"isNaN",
+	"isPrototypeOf",
+	"length",
+	"Math",
+	"name",
+	"NaN",
+	"Number",
+	"Object",
+	"prototype",
+	"String",
+	"toString",
+	"undefined",
+	"valueOf"
+]);
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*
+* @example
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
+*/
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return isIdentifier(name);
+}
+/**
+* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
+*
+* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
+* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
+* deciding whether an object key needs quoting.
+*
+* @example
+* ```ts
+* isIdentifier('name')   // true
+* isIdentifier('x-total')// false
+* ```
+*/
+function isIdentifier(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+//#endregion
+//#region ../../internals/utils/src/string.ts
+/**
+* Wraps a value in single quotes for emitting a single-quoted JavaScript string literal, escaping
+* any backslash or single quote in the content.
+*
+* @example
+* ```ts
+* singleQuote('foo')      // "'foo'"
+* singleQuote("o'clock")  // "'o\\'clock'"
+* ```
+*/
+function singleQuote(value) {
+	if (value === void 0 || value === null) return "''";
+	return `'${String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+//#endregion
+//#region src/utils/codegen.ts
+/**
+* Builds a JSDoc comment block from an array of lines, returning `fallback` when there are no
+* comments so callers always get a usable string.
+*
+* @example
+* ```ts
+* buildJSDoc(['@type string', '@example hello'])
+* // '/**\n   * @type string\n   * @example hello\n   *\/\n  '
+* ```
+*/
+function buildJSDoc(comments, options = {}) {
+	const { indent = "   * ", suffix = "\n  ", fallback = "  " } = options;
+	if (comments.length === 0) return fallback;
+	return `/**\n${comments.map((c) => `${indent}${c}`).join("\n")}\n   */${suffix}`;
+}
+/**
+* Indents every non-empty line of `text` by one indent level, leaving blank lines empty.
+*/
+function indentLines(text) {
+	if (!text) return "";
+	return text.split("\n").map((line) => line.trim() ? `${INDENT}${line}` : "").join("\n");
+}
+/**
+* Renders an object key, quoting it with single quotes only when it is not a valid identifier.
+* Reserved words and globals (`name`, `class`, …) are valid bare keys and stay unquoted.
+*
+* @example
+* ```ts
+* objectKey('name')    // 'name'
+* objectKey('x-total') // "'x-total'"
+* ```
+*/
+function objectKey(name) {
+	return isIdentifier(name) ? name : singleQuote(name);
+}
+/**
+* Assembles a multi-line object literal from already-rendered `entries`, indenting each entry one
+* level and closing the brace at column zero. Nested objects built the same way indent cumulatively,
+* so callers never re-parse the generated code. A trailing comma is added per entry to match the
+* formatter's multi-line style.
+*
+* @example
+* ```ts
+* buildObject(['id: z.number()', 'name: z.string()'])
+* // '{\n  id: z.number(),\n  name: z.string(),\n}'
+* ```
+*/
+function buildObject(entries) {
+	if (entries.length === 0) return "{}";
+	return `{\n${entries.map((entry) => `${indentLines(entry)},`).join("\n")}\n}`;
+}
+/**
+* Assembles a bracketed list (array by default) from already-rendered `items`. Keeps everything on
+* one line when no item spans multiple lines, and otherwise puts each item on its own line, indented
+* one level with a trailing comma and the closing bracket at column zero. Use it for `z.union([…])`,
+* `z.array([…])`, and similar member lists so objects inside them nest correctly.
+*
+* @example
+* ```ts
+* buildList(['z.string()', 'z.number()'])
+* // '[z.string(), z.number()]'
+* ```
+*/
+function buildList(items, brackets = ["[", "]"]) {
+	const [open, close] = brackets;
+	if (items.length === 0) return `${open}${close}`;
+	if (!items.some((item) => item.includes("\n"))) return `${open}${items.join(", ")}${close}`;
+	return `${open}\n${items.map((item) => `${indentLines(item)},`).join("\n")}\n${close}`;
+}
+//#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/utils/refs.ts
+const plainStringTypes = new Set([
+	"string",
+	"uuid",
+	"email",
+	"url",
+	"datetime"
+]);
+/**
+* Returns the last path segment of a reference string.
+*
+* @example
+* ```ts
+* extractRefName('#/components/schemas/Pet') // 'Pet'
+* ```
+*/
+function extractRefName(ref) {
+	return ref.split("/").at(-1) ?? ref;
+}
+/**
+* Resolves the schema name of a ref node, falling back through `ref` → `name` → nested `schema.name`.
+*
+* Returns `null` for non-ref nodes or when no name resolves.
+*
+* @example
+* ```ts
+* resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' })
+* // => 'Pet'
+* ```
+*/
+function resolveRefName(node) {
+	if (!node || node.type !== "ref") return null;
+	if (node.ref) return extractRefName(node.ref) ?? node.name ?? node.schema?.name ?? null;
+	return node.name ?? node.schema?.name ?? null;
+}
+/**
+* Builds a PascalCase child schema name by joining a parent name and property name.
+* Returns `null` when there is no parent to nest under.
+*
+* @example
+* ```ts
+* childName('Order', 'shipping_address') // 'OrderShippingAddress'
+* childName(undefined, 'params')         // null
+* ```
+*/
+function childName(parentName, propName) {
+	return parentName ? pascalCase([parentName, propName].join(" ")) : null;
+}
+/**
+* Builds a PascalCase enum name from the parent name, property name, and a suffix, skipping any
+* empty parts.
+*
+* @example
+* ```ts
+* enumPropName('Order', 'status', 'enum') // 'OrderStatusEnum'
+* ```
+*/
+function enumPropName(parentName, propName, enumSuffix) {
+	return pascalCase([
+		parentName,
+		propName,
+		enumSuffix
+	].filter(Boolean).join(" "));
+}
+/**
+* Type guard that returns `true` when a schema emits as a plain `string` type.
+*
+* Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`
+* types, returns `true` only when `representation` is `'string'` rather than `'date'`.
+*/
+function isStringType(node) {
+	if (plainStringTypes.has(node.type)) return true;
+	const temporal = narrowSchema(node, "date") ?? narrowSchema(node, "time");
+	if (temporal) return temporal.representation !== "date";
+	return false;
+}
+/**
+* Derives a {@link ParamGroupType} for a query or header group from the resolver.
+*
+* Returns `null` when there is no resolver, no params, or the group name equals the
+* individual param name (so there is no real group to emit).
+*/
+function resolveGroupType({ node, params, group, resolver }) {
+	if (!resolver || !params.length) return null;
+	const firstParam = params[0];
+	const groupName = (group === "query" ? resolver.resolveQueryParamsName : resolver.resolveHeaderParamsName).call(resolver, node, firstParam);
+	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
+	return {
+		type: groupName,
+		optional: params.every((p) => !p.required)
+	};
+}
+//#endregion
+//#region src/transformers.ts
+/**
+* Replaces a discriminator property's schema with a string enum of allowed values.
+*
+* If `node` is not an object schema, or if the property does not exist, the input
+* node is returned as-is.
+*
+* @example
+* ```ts
+* const schema = createSchema({
+*   type: 'object',
+*   properties: [createProperty({ name: 'type', required: true, schema: createSchema({ type: 'string' }) })],
+* })
+* const result = setDiscriminatorEnum({ node: schema, propertyName: 'type', values: ['dog', 'cat'] })
+* ```
+*/
+function setDiscriminatorEnum({ node, propertyName, values, enumName }) {
+	const objectNode = narrowSchema(node, "object");
+	if (!objectNode?.properties?.length) return node;
+	if (!objectNode.properties.some((prop) => prop.name === propertyName)) return node;
+	return createSchema({
+		...objectNode,
+		properties: objectNode.properties.map((prop) => {
+			if (prop.name !== propertyName) return prop;
+			return createProperty({
+				...prop,
+				schema: createSchema({
+					type: "enum",
+					primitive: "string",
+					enumValues: values,
+					name: enumName,
+					readOnly: prop.schema.readOnly,
+					writeOnly: prop.schema.writeOnly
+				})
+			});
+		})
+	});
+}
+/**
+* Merges adjacent anonymous object members into a single anonymous object member.
+*
+* @example
+* ```ts
+* const merged = mergeAdjacentObjects([
+*   createSchema({ type: 'object', properties: [createProperty({ name: 'a', schema: createSchema({ type: 'string' }) })] }),
+*   createSchema({ type: 'object', properties: [createProperty({ name: 'b', schema: createSchema({ type: 'number' }) })] }),
+* ])
+* ```
+*/
+function* mergeAdjacentObjectsLazy(members) {
+	let acc;
+	for (const member of members) {
+		const objectMember = narrowSchema(member, "object");
+		if (objectMember && !objectMember.name && acc !== void 0) {
+			const accObject = narrowSchema(acc, "object");
+			if (accObject && !accObject.name) {
+				acc = createSchema({
+					...accObject,
+					properties: [...accObject.properties ?? [], ...objectMember.properties ?? []]
+				});
+				continue;
+			}
+		}
+		if (acc !== void 0) yield acc;
+		acc = member;
+	}
+	if (acc !== void 0) yield acc;
+}
+/**
+* Removes enum members that are covered by broader scalar primitives in the same union.
+*
+* @example
+* ```ts
+* const simplified = simplifyUnion([
+*   createSchema({ type: 'enum', primitive: 'string', enumValues: ['active'] }),
+*   createSchema({ type: 'string' }),
+* ])
+* // keeps only string member
+* ```
+*/
+function simplifyUnion(members) {
+	const scalarPrimitives = new Set(members.filter((member) => isScalarPrimitive(member.type)).map((m) => m.type));
+	if (!scalarPrimitives.size) return members;
+	return members.filter((member) => {
+		const enumNode = narrowSchema(member, "enum");
+		if (!enumNode) return true;
+		const primitive = enumNode.primitive;
+		if (!primitive) return true;
+		if ((enumNode.namedEnumValues?.length ?? enumNode.enumValues?.length ?? 0) <= 1) return true;
+		if (scalarPrimitives.has(primitive)) return false;
+		if ((primitive === "integer" || primitive === "number") && (scalarPrimitives.has("integer") || scalarPrimitives.has("number"))) return false;
+		return true;
+	});
+}
+function setEnumName(propNode, parentName, propName, enumSuffix) {
+	const enumNode = narrowSchema(propNode, "enum");
+	if (enumNode?.primitive === "boolean") return {
+		...propNode,
+		name: null
+	};
+	if (enumNode) return {
+		...propNode,
+		name: enumPropName(parentName, propName, enumSuffix)
+	};
+	return propNode;
+}
+/**
+* Merges a ref node with its resolved schema, giving usage-site fields precedence.
+*
+* Usage-site fields (`description`, `readOnly`, `nullable`, `deprecated`) on the ref node override
+* the same fields in the resolved `node.schema`. Non-ref nodes are returned unchanged.
+*
+* @example
+* ```ts
+* // Ref with description override
+* const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
+* const merged = syncSchemaRef(ref)  // merges with resolved Pet schema
+* ```
+*/
+function syncSchemaRef(node) {
+	const ref = narrowSchema(node, "ref");
+	if (!ref) return node;
+	if (!ref.schema) return node;
+	const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref;
+	const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== void 0));
+	return createSchema({
+		...ref.schema,
+		...definedOverrides
+	});
+}
+//#endregion
+//#region src/utils/strings.ts
+/**
+* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
+* Returns the string unchanged when no balanced quote pair is found.
+*
+* @example
+* ```ts
+* trimQuotes('"hello"') // 'hello'
+* trimQuotes('hello')   // 'hello'
+* ```
+*/
+function trimQuotes(text) {
+	if (text.length >= 2) {
+		const first = text[0];
+		const last = text[text.length - 1];
+		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`") return text.slice(1, -1);
+	}
+	return text;
+}
+/**
+* Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.
+*
+* Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated
+* code matches the repo style without a formatter.
+*
+* @example
+* ```ts
+* stringify('hello')   // "'hello'"
+* stringify('"hello"') // "'hello'"
+* ```
+*/
+function stringify(value) {
+	if (value === void 0 || value === null) return "''";
+	return `'${JSON.stringify(trimQuotes(value.toString())).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
+}
+/**
+* Escapes characters that are not allowed inside JS string literals, covering quotes, backslashes,
+* and the Unicode line terminators U+2028 and U+2029.
+*
+* @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+*
+* @example
+* ```ts
+* jsStringEscape('say "hi"\nbye') // 'say \\"hi\\"\\nbye'
+* ```
+*/
+function jsStringEscape(input) {
+	return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
+		switch (character) {
+			case "\"":
+			case "'":
+			case "\\": return `\\${character}`;
+			case "\n": return "\\n";
+			case "\r": return "\\r";
+			case "\u2028": return "\\u2028";
+			case "\u2029": return "\\u2029";
+			default: return "";
+		}
+	});
+}
+/**
+* Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
+* Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.
+* Pass `null` as the second argument to emit a `/pattern/flags` literal instead.
+*
+* @example
+* ```ts
+* toRegExpString('^(?im)foo')       // 'new RegExp("^foo", "im")'
+* toRegExpString('^(?im)foo', null) // '/^foo/im'
+* ```
+*/
+function toRegExpString(text, func = "RegExp") {
+	const raw = trimQuotes(text);
+	const match = raw.match(/^\^(\(\?([igmsuy]+)\))/i);
+	const replacementTarget = match?.[1] ?? "";
+	const matchedFlags = match?.[2];
+	const cleaned = raw.replace(/^\\?\//, "").replace(/\\?\/$/, "").replace(replacementTarget, "");
+	const { source, flags } = new RegExp(cleaned, matchedFlags);
+	if (func === null) return `/${source}/${flags}`;
+	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
+}
+/**
+* Renders a plain object as multi-line `key: value` source for embedding in generated code. Nested
+* objects recurse with fixed indentation, so the result drops straight into an object literal
+* without re-parsing.
+*
+* @example
+* ```ts
+* stringifyObject({ foo: 'bar', nested: { a: 1 } })
+* // 'foo: bar,\nnested: {\n        a: 1\n      }'
+* ```
+*/
+function stringifyObject(value) {
+	return Object.entries(value).map(([key, val]) => {
+		if (val !== null && typeof val === "object") return `${key}: {\n        ${stringifyObject(val)}\n      }`;
+		return `${key}: ${val}`;
+	}).filter(Boolean).join(",\n");
+}
+/**
+* Renders a dotted path or string array as an optional-chaining accessor expression rooted at
+* `accessor`. Returns `null` for an empty path.
+*
+* @example
+* ```ts
+* getNestedAccessor('pagination.next.id', 'lastPage')
+* // "lastPage?.['pagination']?.['next']?.['id']"
+* ```
+*/
+function getNestedAccessor(param, accessor) {
+	const parts = Array.isArray(param) ? param : param.split(".");
+	if (parts.length === 0 || parts.length === 1 && parts[0] === "") return null;
+	return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
+}
+//#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]] : []));
+/**
+* Per-kind builders rerun after children are rebuilt. Derived from each
+* definition's `rebuild` flag.
+*/
+const nodeRebuilders = Object.fromEntries(nodeDefs.flatMap((def) => def.rebuild ? [[def.kind, def.create]] : []));
+/**
+* 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;
+	const rebuilt = transformChildren(applyVisitor(node, visitor, parent) ?? node, options, recurse);
+	if (rebuilt === node) return node;
+	const rebuild = nodeRebuilders[rebuilt.kind];
+	return rebuild ? rebuild(rebuilt) : rebuilt;
+}
+/**
+* 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
+//#region src/utils/schemaGraph.ts
+/**
+* Collects every named schema referenced transitively from a node through its ref edges.
+*
+* Refs are followed by name only, so the resolved `node.schema` is never traversed inline.
+*
+* @example Collect refs from a single schema
+* ```ts
+* const names = collectReferencedSchemaNames(petSchema)
+* // → Set { 'Category', 'Tag' }
+* ```
+*
+* @example Accumulate refs from multiple schemas into one set
+* ```ts
+* const out = new Set<string>()
+* for (const schema of schemas) {
+*   collectReferencedSchemaNames(schema, out)
+* }
+* ```
+*/
+const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
+	const refs = /* @__PURE__ */ new Set();
+	collect(node, { schema(child) {
+		if (child.type === "ref") {
+			const name = resolveRefName(child);
+			if (name) refs.add(name);
+		}
+	} });
+	return refs;
+});
+function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
+	if (!node) return out;
+	for (const name of collectSchemaRefs(node)) out.add(name);
+	return out;
+}
+/**
+* Collects the names of all top-level schemas transitively used by a set of operations.
+*
+* An operation uses a schema when its parameters, request body, or responses reference it, directly
+* or through other named schemas. The walk is iterative, so reference cycles are safe.
+*
+* Pair it with `include` filters so schemas reachable only from excluded operations stay ungenerated.
+*
+* @example Only generate schemas referenced by included operations
+* ```ts
+* const includedOps = operations.filter((op) => resolver.resolveOptions(op, { options, include }) !== null)
+* const allowed = collectUsedSchemaNames(includedOps, schemas)
+*
+* for (const schema of schemas) {
+*   if (schema.name && !allowed.has(schema.name)) continue
+*   // … generate schema
+* }
+* ```
+*/
+const collectUsedSchemaNamesMemo = memoize(/* @__PURE__ */ new WeakMap(), (ops) => memoize(/* @__PURE__ */ new WeakMap(), (schemas) => computeUsedSchemaNames(ops, schemas)));
+function computeUsedSchemaNames(operations, schemas) {
+	const schemaMap = /* @__PURE__ */ new Map();
+	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
+	const result = /* @__PURE__ */ new Set();
+	function visitSchema(schema) {
+		const directRefs = collectReferencedSchemaNames(schema);
+		for (const name of directRefs) if (!result.has(name)) {
+			result.add(name);
+			const namedSchema = schemaMap.get(name);
+			if (namedSchema) visitSchema(namedSchema);
+		}
+	}
+	for (const op of operations) for (const schema of collectLazy(op, {
+		depth: "shallow",
+		schema: (node) => node
+	})) visitSchema(schema);
+	return result;
+}
+function collectUsedSchemaNames(operations, schemas) {
+	return collectUsedSchemaNamesMemo(operations)(schemas);
+}
+const EMPTY_CIRCULAR_SET = /* @__PURE__ */ new Set();
+const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (schemas) => {
+	const graph = /* @__PURE__ */ new Map();
+	for (const schema of schemas) {
+		if (!schema.name) continue;
+		graph.set(schema.name, collectReferencedSchemaNames(schema));
+	}
+	const circular = /* @__PURE__ */ new Set();
+	for (const start of graph.keys()) {
+		const visited = /* @__PURE__ */ new Set();
+		const stack = [...graph.get(start) ?? []];
+		while (stack.length > 0) {
+			const node = stack.pop();
+			if (node === start) {
+				circular.add(start);
+				break;
+			}
+			if (visited.has(node)) continue;
+			visited.add(node);
+			const next = graph.get(node);
+			if (next) for (const r of next) stack.push(r);
+		}
+	}
+	return circular;
+});
+/**
+* Finds every schema that takes part in a circular dependency chain, including direct self-loops.
+*
+* Wrap the returned schema positions in a deferred construct (a lazy getter or `z.lazy(() => …)`) so
+* the generated code does not recurse forever. Refs are followed by name only, so the walk stays
+* linear in the size of the schema graph.
+*
+* @note Call this once on the full graph, then check individual schemas with `containsCircularRef()`.
+*/
+function findCircularSchemas(schemas) {
+	if (schemas.length === 0) return EMPTY_CIRCULAR_SET;
+	return findCircularSchemasMemo(schemas);
+}
+/**
+* Returns `true` when a schema, or anything nested inside it, references a circular schema.
+*
+* Pass `excludeName` to skip refs to a specific schema, which helps when self-references are handled
+* on their own. Pair it with `findCircularSchemas()` to decide where lazy wrappers go.
+*
+* @note Stops at the first matching circular ref.
+*/
+function containsCircularRef(node, { circularSchemas, excludeName }) {
+	if (!node || circularSchemas.size === 0) return false;
+	for (const _ of collectLazy(node, { schema(child) {
+		if (child.type !== "ref") return null;
+		const name = resolveRefName(child);
+		return name && name !== excludeName && circularSchemas.has(name) ? true : null;
+	} })) return true;
+	return false;
+}
+//#endregion
+//#region src/utils/schemaTraversal.ts
+/**
+* Maps each property of an object schema to its transformed output. Pairs every result with the
+* original property so the printer keeps full control over modifiers, getters, and key syntax.
+*
+* @example
+* ```ts
+* const entries = mapSchemaProperties(node, (schema) => this.transform(schema))
+* // entries: [{ name: 'id', property, output: 'z.number()' }, ...]
+* ```
+*/
+function mapSchemaProperties(node, transform) {
+	return node.properties.map((property) => ({
+		name: property.name,
+		property,
+		output: transform(property.schema)
+	}));
+}
+/**
+* Maps each member of a union or intersection schema to its transformed output, pairing every
+* result with the original member.
+*/
+function mapSchemaMembers(node, transform) {
+	return (node.members ?? []).map((schema) => ({
+		schema,
+		output: transform(schema)
+	}));
+}
+/**
+* Maps each item of an array or tuple schema to its transformed output, pairing every result with
+* the original item.
+*/
+function mapSchemaItems(node, transform) {
+	return (node.items ?? []).map((schema) => ({
+		schema,
+		output: transform(schema)
+	}));
+}
+/**
+* Emits a lazy getter for a circular-ref property position, `get name() { return body }`. The key
+* is quoted only when it is not a valid identifier. Used by the string printers to defer evaluation
+* of a recursive schema until first access.
+*
+* @example
+* ```ts
+* lazyGetter({ name: 'parent', body: 'z.lazy(() => Pet)' })
+* // "get parent() { return z.lazy(() => Pet) }"
+* ```
+*/
+function lazyGetter({ name, body }) {
+	return `get ${objectKey(name)}() { return ${body} }`;
+}
+//#endregion
+//#region src/utils/operationParams.ts
+/**
+* Applies casing rules to parameter names and returns a new array without mutating the input.
+*
+* Run it before handing parameters to schema builders so output property keys get the right casing
+* while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, the
+* original array is returned unchanged.
+*/
+const caseParamsMemo = memoize(/* @__PURE__ */ new WeakMap(), (params) => memoize(/* @__PURE__ */ new Map(), (casing) => params.map((param) => {
+	const transformed = casing === "camelcase" || !isValidVarName(param.name) ? camelCase(param.name) : param.name;
+	return {
+		...param,
+		name: transformed
+	};
+})));
+function caseParams(params, casing) {
+	if (!casing) return params;
+	return caseParamsMemo(params)(casing);
+}
+/**
+* Resolves the {@link TypeExpression} for an individual parameter.
+*
+* Without a resolver, it falls back to the schema primitive (a plain type-name string). When the
+* parameter belongs to a named group, it emits an {@link IndexedAccessTypeNode} like
+* `GroupParams['petId']`, otherwise the resolved individual name.
+*/
+function resolveParamType({ node, param, resolver }) {
+	if (!resolver) return param.schema.primitive ?? "unknown";
+	const individualName = resolver.resolveParamName(node, param);
+	const groupLocation = param.in === "path" || param.in === "query" || param.in === "header" ? param.in : void 0;
+	const groupResolvers = {
+		path: resolver.resolvePathParamsName,
+		query: resolver.resolveQueryParamsName,
+		header: resolver.resolveHeaderParamsName
+	};
+	const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : void 0;
+	if (groupName && groupName !== individualName) return createIndexedAccessType({
+		objectType: groupName,
+		indexType: param.name
+	});
+	return individualName;
+}
+/**
+* Converts an `OperationNode` into function parameters for code generation.
+*
+* Centralizes parameter grouping logic for all plugins. `paramsType` chooses between one
+* destructured object parameter (`object`) and separate top-level parameters (`inline`), while
+* `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
+* name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
+*/
+function createOperationParams(node, options) {
+	const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
+	const dataName = paramNames?.data ?? "data";
+	const paramsName = paramNames?.params ?? "params";
+	const headersName = paramNames?.headers ?? "headers";
+	const pathName = paramNames?.path ?? "pathParams";
+	const wrapType = (type) => typeWrapper ? typeWrapper(type) : type;
+	const wrapTypeExpression = (type) => typeof type === "string" ? wrapType(type) : type;
+	const casedParams = caseParams(node.parameters, paramsCasing);
+	const pathParams = casedParams.filter((p) => p.in === "path");
+	const queryParams = casedParams.filter((p) => p.in === "query");
+	const headerParams = casedParams.filter((p) => p.in === "header");
+	const toProperty = (param) => ({
+		name: param.name,
+		type: wrapTypeExpression(resolveParamType({
+			node,
+			param,
+			resolver
+		})),
+		optional: !param.required
+	});
+	const emptyObjectDefault = (props) => props.every((p) => p.optional) ? "{}" : void 0;
+	const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.resolveDataName(node) ?? "unknown") : void 0;
+	const bodyProperty = bodyType ? [{
+		name: dataName,
+		type: bodyType,
+		optional: !(node.requestBody?.required ?? false)
+	}] : [];
+	const trailingGroups = [{
+		name: paramsName,
+		node,
+		params: queryParams,
+		groupType: resolveGroupType({
+			node,
+			params: queryParams,
+			group: "query",
+			resolver
+		}),
+		resolver,
+		wrapType
+	}, {
+		name: headersName,
+		node,
+		params: headerParams,
+		groupType: resolveGroupType({
+			node,
+			params: headerParams,
+			group: "header",
+			resolver
+		}),
+		resolver,
+		wrapType
+	}];
+	const params = [];
+	if (paramsType === "object") {
+		const children = [
+			...pathParams.map(toProperty),
+			...bodyProperty,
+			...trailingGroups.flatMap(buildGroupProperty)
+		];
+		if (children.length) params.push(createFunctionParameter({
+			properties: children,
+			default: emptyObjectDefault(children)
+		}));
+	} else {
+		if (pathParamsType === "inlineSpread" && pathParams.length) {
+			const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]);
+			params.push(createFunctionParameter({
+				name: pathName,
+				type: spreadType ? wrapType(spreadType) : void 0,
+				rest: true
+			}));
+		} else if (pathParamsType === "inline") params.push(...pathParams.map((p) => createFunctionParameter(toProperty(p))));
+		else if (pathParams.length) {
+			const pathChildren = pathParams.map(toProperty);
+			params.push(createFunctionParameter({
+				properties: pathChildren,
+				default: pathParamsDefault ?? emptyObjectDefault(pathChildren)
+			}));
+		}
+		params.push(...bodyProperty.map((p) => createFunctionParameter(p)));
+		params.push(...trailingGroups.flatMap(buildGroupParam));
+	}
+	params.push(...extraParams);
+	return createFunctionParameters({ params });
+}
+/**
+* Builds the property descriptor for a query or header group.
+* Returns an empty array when there are no params to emit.
+*
+* A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline
+* {@link TypeLiteralNode} from the individual params.
+*/
+function buildGroupProperty({ name, node, params, groupType, resolver, wrapType }) {
+	if (groupType) return [{
+		name,
+		type: typeof groupType.type === "string" ? wrapType(groupType.type) : groupType.type,
+		optional: groupType.optional
+	}];
+	if (params.length) return [{
+		name,
+		type: buildTypeLiteral({
+			node,
+			params,
+			resolver
+		}),
+		optional: params.every((p) => !p.required)
+	}];
+	return [];
+}
+/**
+* Builds a single {@link FunctionParameterNode} for a query or header group.
+* Returns an empty array when there are no params to emit.
+*
+* A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline
+* {@link TypeLiteralNode} from the individual params.
+*/
+function buildGroupParam(args) {
+	return buildGroupProperty(args).map((p) => createFunctionParameter(p));
+}
+/**
+* Builds a {@link TypeLiteralNode} for an inline anonymous type grouping named fields.
+*
+* Used when query or header parameters have no dedicated group type name.
+* Each language printer renders this appropriately (TypeScript: `{ petId: string; name?: string }`).
+*/
+function buildTypeLiteral({ node, params, resolver }) {
+	return createTypeLiteral({ members: params.map((p) => ({
+		name: p.name,
+		type: resolveParamType({
+			node,
+			param: p,
+			resolver
+		}),
+		optional: !p.required
+	})) });
+}
+//#endregion
+export { enumPropName as A, objectKey as B, trimQuotes as C, simplifyUnion as D, setEnumName as E, isHttpOperationNode as F, httpMethods as H, narrowSchema as I, buildJSDoc as L, isStringType as M, resolveGroupType as N, syncSchemaRef as O, resolveRefName as P, buildList as R, toRegExpString as S, setDiscriminatorEnum as T, schemaTypes as U, isValidVarName as V, nodeDefs as _, resolveParamType as a, stringify as b, mapSchemaMembers as c, containsCircularRef as d, findCircularSchemas as f, walk as g, transform as h, createOperationParams as i, extractRefName as j, childName as k, mapSchemaProperties as l, collectLazy as m, buildTypeLiteral as n, lazyGetter as o, collect as p, caseParams as r, mapSchemaItems as s, buildGroupParam as t, collectUsedSchemaNames as u, getNestedAccessor as v, mergeAdjacentObjectsLazy as w, stringifyObject as x, jsStringEscape as y, buildObject as z };
+
+//# sourceMappingURL=utils-Dj_KoXMv.js.map