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

package/dist/{utils-D83JA6Xx.cjs → utils-BLJwyza-.cjs}

@@ -1,156 +1,5 @@
-const require_response = require("./response-DS5S3IG4.cjs");
-//#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
+const require_response = require("./response-hnSw2NKE.cjs");
+const require_visitor = require("./visitor-DpKZ9Tk0.cjs");
 //#region ../../internals/utils/src/promise.ts
 /**
 * Wraps `factory` with a keyed cache backed by the provided store.
@@ -347,7 +196,7 @@ function buildJSDoc(comments, options = {}) {
 */
 function indentLines(text) {
 	if (!text) return "";
-	return text.split("\n").map((line) => line.trim() ? `${INDENT}${line}` : "").join("\n");
+	return text.split("\n").map((line) => line.trim() ? `${require_visitor.INDENT}${line}` : "").join("\n");
 }
 /**
 * Renders an object key, quoting it with single quotes only when it is not a valid identifier.
@@ -397,181 +246,23 @@ function buildList(items, brackets = ["[", "]"]) {
 	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"
-]);
+//#region src/utils/schemaMerge.ts
 /**
-* Returns the last path segment of a reference string.
+* Merges a run of adjacent anonymous object members into one. Named or non-object members break the
+* run and pass through. Stays a construction-time helper, not a macro, so callers keep control of the
+* member boundaries (such as keeping synthetic discriminant objects out of a run).
 *
 * @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 ? require_response.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 require_response.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 require_response.createSchema({
-		...objectNode,
-		properties: objectNode.properties.map((prop) => {
-			if (prop.name !== propertyName) return prop;
-			return require_response.createProperty({
-				...prop,
-				schema: require_response.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' }) })] }),
-* ])
+* const merged = [...mergeAdjacentObjectsLazy([objectA, objectB])]
 * ```
 */
 function* mergeAdjacentObjectsLazy(members) {
 	let acc;
 	for (const member of members) {
-		const objectMember = narrowSchema(member, "object");
+		const objectMember = require_visitor.narrowSchema(member, "object");
 		if (objectMember && !objectMember.name && acc !== void 0) {
-			const accObject = narrowSchema(acc, "object");
+			const accObject = require_visitor.narrowSchema(acc, "object");
 			if (accObject && !accObject.name) {
 				acc = require_response.createSchema({
 					...accObject,
@@ -585,68 +276,6 @@ function* mergeAdjacentObjectsLazy(members) {
 	}
 	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 require_response.createSchema({
-		...ref.schema,
-		...definedOverrides
-	});
-}
 //#endregion
 //#region src/utils/strings.ts
 /**
@@ -762,254 +391,6 @@ function getNestedAccessor(param, accessor) {
 	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 = [
-	require_response.inputDef,
-	require_response.outputDef,
-	require_response.operationDef,
-	require_response.requestBodyDef,
-	require_response.contentDef,
-	require_response.responseDef,
-	require_response.schemaDef,
-	require_response.propertyDef,
-	require_response.parameterDef,
-	require_response.functionParameterDef,
-	require_response.functionParametersDef,
-	require_response.typeLiteralDef,
-	require_response.indexedAccessTypeDef,
-	require_response.objectBindingPatternDef,
-	require_response.constDef,
-	require_response.typeDef,
-	require_response.functionDef,
-	require_response.arrowFunctionDef,
-	require_response.textDef,
-	require_response.breakDef,
-	require_response.jsxDef,
-	require_response.importDef,
-	require_response.exportDef,
-	require_response.sourceDef,
-	require_response.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.
@@ -1032,9 +413,9 @@ function collect(node, options) {
 */
 const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
 	const refs = /* @__PURE__ */ new Set();
-	collect(node, { schema(child) {
+	require_visitor.collect(node, { schema(child) {
 		if (child.type === "ref") {
-			const name = resolveRefName(child);
+			const name = require_visitor.resolveRefName(child);
 			if (name) refs.add(name);
 		}
 	} });
@@ -1077,7 +458,7 @@ function computeUsedSchemaNames(operations, schemas) {
 			if (namedSchema) visitSchema(namedSchema);
 		}
 	}
-	for (const op of operations) for (const schema of collectLazy(op, {
+	for (const op of operations) for (const schema of require_visitor.collectLazy(op, {
 		depth: "shallow",
 		schema: (node) => node
 	})) visitSchema(schema);
@@ -1134,9 +515,9 @@ function findCircularSchemas(schemas) {
 */
 function containsCircularRef(node, { circularSchemas, excludeName }) {
 	if (!node || circularSchemas.size === 0) return false;
-	for (const _ of collectLazy(node, { schema(child) {
+	for (const _ of require_visitor.collectLazy(node, { schema(child) {
 		if (child.type !== "ref") return null;
-		const name = resolveRefName(child);
+		const name = require_visitor.resolveRefName(child);
 		return name && name !== excludeName && circularSchemas.has(name) ? true : null;
 	} })) return true;
 	return false;
@@ -1277,7 +658,7 @@ function createOperationParams(node, options) {
 		name: paramsName,
 		node,
 		params: queryParams,
-		groupType: resolveGroupType({
+		groupType: require_visitor.resolveGroupType({
 			node,
 			params: queryParams,
 			group: "query",
@@ -1289,7 +670,7 @@ function createOperationParams(node, options) {
 		name: headersName,
 		node,
 		params: headerParams,
-		groupType: resolveGroupType({
+		groupType: require_visitor.resolveGroupType({
 			node,
 			params: headerParams,
 			group: "header",
@@ -1419,24 +800,6 @@ Object.defineProperty(exports, "caseParams", {
 		return caseParams;
 	}
 });
-Object.defineProperty(exports, "childName", {
-	enumerable: true,
-	get: function() {
-		return childName;
-	}
-});
-Object.defineProperty(exports, "collect", {
-	enumerable: true,
-	get: function() {
-		return collect;
-	}
-});
-Object.defineProperty(exports, "collectLazy", {
-	enumerable: true,
-	get: function() {
-		return collectLazy;
-	}
-});
 Object.defineProperty(exports, "collectUsedSchemaNames", {
 	enumerable: true,
 	get: function() {
@@ -1455,18 +818,6 @@ Object.defineProperty(exports, "createOperationParams", {
 		return createOperationParams;
 	}
 });
-Object.defineProperty(exports, "enumPropName", {
-	enumerable: true,
-	get: function() {
-		return enumPropName;
-	}
-});
-Object.defineProperty(exports, "extractRefName", {
-	enumerable: true,
-	get: function() {
-		return extractRefName;
-	}
-});
 Object.defineProperty(exports, "findCircularSchemas", {
 	enumerable: true,
 	get: function() {
@@ -1479,24 +830,6 @@ Object.defineProperty(exports, "getNestedAccessor", {
 		return getNestedAccessor;
 	}
 });
-Object.defineProperty(exports, "httpMethods", {
-	enumerable: true,
-	get: function() {
-		return httpMethods;
-	}
-});
-Object.defineProperty(exports, "isHttpOperationNode", {
-	enumerable: true,
-	get: function() {
-		return isHttpOperationNode;
-	}
-});
-Object.defineProperty(exports, "isStringType", {
-	enumerable: true,
-	get: function() {
-		return isStringType;
-	}
-});
 Object.defineProperty(exports, "isValidVarName", {
 	enumerable: true,
 	get: function() {
@@ -1539,66 +872,18 @@ Object.defineProperty(exports, "mergeAdjacentObjectsLazy", {
 		return mergeAdjacentObjectsLazy;
 	}
 });
-Object.defineProperty(exports, "narrowSchema", {
-	enumerable: true,
-	get: function() {
-		return narrowSchema;
-	}
-});
-Object.defineProperty(exports, "nodeDefs", {
-	enumerable: true,
-	get: function() {
-		return nodeDefs;
-	}
-});
 Object.defineProperty(exports, "objectKey", {
 	enumerable: true,
 	get: function() {
 		return objectKey;
 	}
 });
-Object.defineProperty(exports, "resolveGroupType", {
-	enumerable: true,
-	get: function() {
-		return resolveGroupType;
-	}
-});
 Object.defineProperty(exports, "resolveParamType", {
 	enumerable: true,
 	get: function() {
 		return resolveParamType;
 	}
 });
-Object.defineProperty(exports, "resolveRefName", {
-	enumerable: true,
-	get: function() {
-		return resolveRefName;
-	}
-});
-Object.defineProperty(exports, "schemaTypes", {
-	enumerable: true,
-	get: function() {
-		return schemaTypes;
-	}
-});
-Object.defineProperty(exports, "setDiscriminatorEnum", {
-	enumerable: true,
-	get: function() {
-		return setDiscriminatorEnum;
-	}
-});
-Object.defineProperty(exports, "setEnumName", {
-	enumerable: true,
-	get: function() {
-		return setEnumName;
-	}
-});
-Object.defineProperty(exports, "simplifyUnion", {
-	enumerable: true,
-	get: function() {
-		return simplifyUnion;
-	}
-});
 Object.defineProperty(exports, "stringify", {
 	enumerable: true,
 	get: function() {
@@ -1611,35 +896,17 @@ Object.defineProperty(exports, "stringifyObject", {
 		return stringifyObject;
 	}
 });
-Object.defineProperty(exports, "syncSchemaRef", {
-	enumerable: true,
-	get: function() {
-		return syncSchemaRef;
-	}
-});
 Object.defineProperty(exports, "toRegExpString", {
 	enumerable: true,
 	get: function() {
 		return toRegExpString;
 	}
 });
-Object.defineProperty(exports, "transform", {
-	enumerable: true,
-	get: function() {
-		return transform;
-	}
-});
 Object.defineProperty(exports, "trimQuotes", {
 	enumerable: true,
 	get: function() {
 		return trimQuotes;
 	}
 });
-Object.defineProperty(exports, "walk", {
-	enumerable: true,
-	get: function() {
-		return walk;
-	}
-});
 
-//# sourceMappingURL=utils-D83JA6Xx.cjs.map
+//# sourceMappingURL=utils-BLJwyza-.cjs.map