schema-components 1.18.1 → 1.20.0

package/dist/normalise-tL9FckAk.mjs

@@ -1,748 +0,0 @@
-import { isObject } from "./core/guards.mjs";
-import { emitDiagnostic } from "./core/diagnostics.mjs";
-import { isOpenApi30, isSwagger2 } from "./core/version.mjs";
-//#region src/core/openapi30.ts
-/**
-* OpenAPI 3.0.x schema normalisation.
-*
-* Transforms `nullable`, `discriminator`, `example` keywords, and walks
-* all schema locations (components, paths, parameters, request bodies,
-* responses) to apply normalisation.
-*/
-/**
-* Normalise OpenAPI 3.0.x `nullable` keyword to `anyOf [T, null]`.
-*
-* OpenAPI 3.0 uses `nullable: true` instead of the JSON Schema standard
-* `anyOf: [T, { type: "null" }]`. The walker understands the latter form
-* natively, so this normaliser converts `nullable` to `anyOf`.
-*
-* Only applied when `nullable` is explicitly `true`. `nullable: false` or
-* absent is the default and requires no transformation.
-*/
-function normaliseOpenApi30Node(node) {
-	if ("example" in node && !("examples" in node)) {
-		node.examples = [node.example];
-		delete node.example;
-	} else if ("example" in node) delete node.example;
-	if (node.nullable !== true) {
-		if ("nullable" in node) delete node.nullable;
-		return node;
-	}
-	const nullOption = { type: "null" };
-	if (Array.isArray(node.anyOf)) {
-		node.anyOf = [...node.anyOf, nullOption];
-		delete node.nullable;
-		return node;
-	}
-	if (Array.isArray(node.oneOf)) {
-		node.anyOf = [...node.oneOf, nullOption];
-		delete node.oneOf;
-		delete node.nullable;
-		return node;
-	}
-	if (Array.isArray(node.allOf)) {
-		node.anyOf = [{ allOf: node.allOf }, nullOption];
-		delete node.allOf;
-		delete node.nullable;
-		return node;
-	}
-	const wrapper = {};
-	for (const [key, value] of Object.entries(node)) if (key !== "nullable") wrapper[key] = value;
-	return { anyOf: [wrapper, nullOption] };
-}
-/**
-* Normalise OpenAPI 3.0.x `discriminator` keyword by injecting `const`
-* values into each `oneOf`/`anyOf` option's discriminator property.
-*
-* In OpenAPI 3.0, `discriminator` is a sibling of `oneOf`/`anyOf`:
-*   discriminator: { propertyName: "type" }
-* The walker detects discriminated unions from `oneOf` + `const` on a
-* property, so this normaliser injects the `const` values from the
-* `mapping` or infers them from `$ref` fragment names.
-*/
-function normaliseOpenApi30Discriminator(node) {
-	const discriminator = node.discriminator;
-	if (!isObject(discriminator)) return node;
-	const propertyName = discriminator.propertyName;
-	if (typeof propertyName !== "string") return node;
-	const mapping = isObject(discriminator.mapping) ? discriminator.mapping : void 0;
-	const composite = node.oneOf ?? node.anyOf;
-	if (!Array.isArray(composite)) return node;
-	const refToValue = /* @__PURE__ */ new Map();
-	if (mapping !== void 0) {
-		for (const [value, ref] of Object.entries(mapping)) if (typeof ref === "string") refToValue.set(ref, value);
-	}
-	const normalisedComposite = [];
-	for (const option of composite) {
-		if (!isObject(option)) {
-			normalisedComposite.push(option);
-			continue;
-		}
-		const props = isObject(option.properties) ? { ...option.properties } : void 0;
-		const discProp = props?.[propertyName];
-		if (isObject(discProp) && "const" in discProp) {
-			normalisedComposite.push(option);
-			continue;
-		}
-		let constValue;
-		if (isObject(discProp) && typeof discProp.$ref === "string") constValue = refToValue.get(discProp.$ref);
-		if (constValue === void 0 && typeof option.$ref === "string") {
-			constValue = refToValue.get(option.$ref);
-			if (constValue === void 0) {
-				const fragment = option.$ref.split("/").pop();
-				if (fragment !== void 0) constValue = fragment;
-			}
-		}
-		if (constValue === void 0 && mapping !== void 0) {
-			const optionIndex = composite.indexOf(option);
-			const mappingEntries = Object.entries(mapping);
-			const entry = optionIndex >= 0 && optionIndex < mappingEntries.length ? mappingEntries[optionIndex] : void 0;
-			if (entry !== void 0) constValue = entry[0];
-		}
-		if (constValue !== void 0) {
-			const normalisedProps = props ?? {};
-			normalisedProps[propertyName] = {
-				...isObject(discProp) ? discProp : {},
-				const: constValue
-			};
-			normalisedComposite.push({
-				...option,
-				properties: normalisedProps
-			});
-		} else normalisedComposite.push(option);
-	}
-	if ("oneOf" in node) node.oneOf = normalisedComposite;
-	else if ("anyOf" in node) node.anyOf = normalisedComposite;
-	delete node.discriminator;
-	return node;
-}
-/**
-* Combined OpenAPI 3.0.x node transform: Draft 04 + nullable + discriminator.
-* Applied to every schema node in an OpenAPI 3.0 document.
-*
-* Draft 04 normalisation is included because OpenAPI 3.0 inherits
-* Draft 04/05 schema semantics including `exclusiveMinimum: boolean`.
-*/
-function normaliseOpenApi30Combined(node) {
-	return normaliseOpenApi30Discriminator(normaliseOpenApi30Node(normaliseDraft04Node(node)));
-}
-/**
-* Deep-normalise all schemas in an OpenAPI 3.0.x document.
-* Walks components/schemas, path operations, parameters, request bodies,
-* and responses — applying `nullable` normalisation to each schema.
-*/
-function deepNormaliseOpenApi30Doc(doc, deepNormalise) {
-	const result = { ...doc };
-	const components = doc.components;
-	if (isObject(components)) {
-		const schemas = components.schemas;
-		if (isObject(schemas)) {
-			const normalisedSchemas = {};
-			for (const [name, schema] of Object.entries(schemas)) normalisedSchemas[name] = isObject(schema) ? deepNormalise(schema, normaliseOpenApi30Combined) : schema;
-			result.components = {
-				...components,
-				schemas: normalisedSchemas
-			};
-		}
-	}
-	const paths = doc.paths;
-	if (isObject(paths)) {
-		const normalisedPaths = {};
-		for (const [path, pathItem] of Object.entries(paths)) normalisedPaths[path] = isObject(pathItem) ? normalisePathItem(pathItem, deepNormalise) : pathItem;
-		result.paths = normalisedPaths;
-	}
-	return result;
-}
-function normalisePathItem(pathItem, deepNormalise) {
-	const result = { ...pathItem };
-	for (const method of [
-		"get",
-		"post",
-		"put",
-		"patch",
-		"delete"
-	]) {
-		const operation = pathItem[method];
-		if (!isObject(operation)) continue;
-		result[method] = normaliseOperation(operation, deepNormalise);
-	}
-	const parameters = pathItem.parameters;
-	if (Array.isArray(parameters)) result.parameters = parameters.map((param) => isObject(param) ? normaliseParameter(param, deepNormalise) : param);
-	return result;
-}
-function normaliseOperation(operation, deepNormalise) {
-	const result = { ...operation };
-	const parameters = operation.parameters;
-	if (Array.isArray(parameters)) result.parameters = parameters.map((param) => isObject(param) ? normaliseParameter(param, deepNormalise) : param);
-	const requestBody = operation.requestBody;
-	if (isObject(requestBody)) result.requestBody = normaliseRequestBody(requestBody, deepNormalise);
-	const responses = operation.responses;
-	if (isObject(responses)) {
-		const normalisedResponses = {};
-		for (const [code, response] of Object.entries(responses)) normalisedResponses[code] = isObject(response) ? normaliseResponse(response, deepNormalise) : response;
-		result.responses = normalisedResponses;
-	}
-	return result;
-}
-function normaliseParameter(param, deepNormalise) {
-	const result = { ...param };
-	const schema = param.schema;
-	if (isObject(schema)) result.schema = deepNormalise(schema, normaliseOpenApi30Combined);
-	if ("example" in result && !("examples" in result)) {
-		result.examples = [result.example];
-		delete result.example;
-	} else if ("example" in result) delete result.example;
-	return result;
-}
-function normaliseRequestBody(requestBody, deepNormalise) {
-	const result = { ...requestBody };
-	const content = requestBody.content;
-	if (isObject(content)) result.content = normaliseContentMap(content, deepNormalise);
-	return result;
-}
-function normaliseResponse(response, deepNormalise) {
-	const result = { ...response };
-	const content = response.content;
-	if (isObject(content)) result.content = normaliseContentMap(content, deepNormalise);
-	return result;
-}
-function normaliseContentMap(content, deepNormalise) {
-	const result = {};
-	for (const [mediaType, mediaObj] of Object.entries(content)) {
-		if (!isObject(mediaObj)) {
-			result[mediaType] = mediaObj;
-			continue;
-		}
-		const normalised = { ...mediaObj };
-		const schema = mediaObj.schema;
-		if (isObject(schema)) normalised.schema = deepNormalise(schema, normaliseOpenApi30Combined);
-		if ("example" in normalised && !("examples" in normalised)) {
-			normalised.examples = { value: normalised.example };
-			delete normalised.example;
-		} else if ("example" in normalised) delete normalised.example;
-		result[mediaType] = normalised;
-	}
-	return result;
-}
-//#endregion
-//#region src/core/swagger2.ts
-/**
-* Swagger 2.0 → OpenAPI 3.1 document normalisation.
-*
-* Transforms a Swagger 2.0 document into an OpenAPI 3.1-compatible
-* structure: host/basePath/schemes → servers, definitions → components,
-* body/formData params → requestBody, response schemas → content.
-*
-* Individual schemas within the document are also normalised for
-* Draft 04 semantics (exclusiveMinimum/exclusiveMaximum booleans).
-*/
-/**
-* Transform a Swagger 2.0 document into an OpenAPI 3.1-compatible
-* structure.
-*/
-function normaliseSwagger2Document(doc, deepNormalise, normaliseDraft04Node, diagnostics) {
-	const result = {
-		openapi: "3.1.0",
-		info: isObject(doc.info) ? { ...doc.info } : {
-			title: "API",
-			version: "0.0.0"
-		}
-	};
-	if (typeof doc.host === "string" || typeof doc.basePath === "string" || Array.isArray(doc.schemes)) {
-		const host = typeof doc.host === "string" ? doc.host : "localhost";
-		const basePath = typeof doc.basePath === "string" ? doc.basePath : "/";
-		const schemes = Array.isArray(doc.schemes) ? doc.schemes : ["https"];
-		result.servers = [{ url: `${typeof schemes[0] === "string" ? schemes[0] : "https"}://${host}${basePath}` }];
-	}
-	const paths = doc.paths;
-	if (isObject(paths)) result.paths = normaliseSwaggerPaths(paths, doc);
-	const components = {};
-	const definitions = doc.definitions;
-	if (isObject(definitions)) {
-		const schemas = {};
-		for (const [name, schema] of Object.entries(definitions)) schemas[name] = isObject(schema) ? deepNormalise(schema, (node) => normaliseOpenApi30Combined(normaliseDraft04Node(node))) : schema;
-		components.schemas = schemas;
-	}
-	const parameters = doc.parameters;
-	if (isObject(parameters)) components.parameters = { ...parameters };
-	const responses = doc.responses;
-	if (isObject(responses)) components.responses = { ...responses };
-	const securityDefinitions = doc.securityDefinitions;
-	if (isObject(securityDefinitions)) components.securitySchemes = { ...securityDefinitions };
-	if (Object.keys(components).length > 0) result.components = components;
-	if (Array.isArray(doc.tags)) result.tags = doc.tags;
-	if (isObject(doc.externalDocs)) result.externalDocs = doc.externalDocs;
-	rewriteSwaggerRefs(result);
-	if (isObject(doc.xml) || isObject(doc.definitions) && hasXmlInSchemas(doc.definitions)) emitDiagnostic(diagnostics, {
-		code: "dropped-swagger-feature",
-		message: "Swagger 2.0 xml markup is not supported and will be dropped",
-		pointer: "",
-		detail: { feature: "xml" }
-	});
-	return result;
-}
-function normaliseSwaggerPaths(paths, doc) {
-	const result = {};
-	const METHODS = [
-		"get",
-		"post",
-		"put",
-		"patch",
-		"delete",
-		"head",
-		"options"
-	];
-	for (const [path, pathItem] of Object.entries(paths)) {
-		if (!isObject(pathItem)) {
-			result[path] = pathItem;
-			continue;
-		}
-		const normalisedPath = {};
-		for (const method of METHODS) {
-			const operation = pathItem[method];
-			if (!isObject(operation)) continue;
-			normalisedPath[method] = normaliseSwaggerOperation(operation, doc);
-		}
-		const pathParams = pathItem.parameters;
-		if (Array.isArray(pathParams)) normalisedPath.parameters = pathParams.map((p) => isObject(p) ? normaliseSwaggerParameter(p, doc) : p);
-		result[path] = normalisedPath;
-	}
-	return result;
-}
-function normaliseSwaggerOperation(operation, doc) {
-	const result = {};
-	const globalProduces = Array.isArray(doc.produces) ? doc.produces : ["application/json"];
-	const globalConsumes = Array.isArray(doc.consumes) ? doc.consumes : ["application/json"];
-	const produces = Array.isArray(operation.produces) ? operation.produces : globalProduces;
-	const consumes = Array.isArray(operation.consumes) ? operation.consumes : globalConsumes;
-	for (const [key, value] of Object.entries(operation)) if (key !== "parameters" && key !== "responses" && key !== "produces" && key !== "consumes") result[key] = value;
-	const params = operation.parameters;
-	if (Array.isArray(params)) {
-		const nonBodyParams = [];
-		let bodyParam;
-		let usesFormData = false;
-		for (const param of params) {
-			if (!isObject(param)) {
-				nonBodyParams.push(param);
-				continue;
-			}
-			const resolvedParam = resolveSwaggerParameter(param, doc);
-			const location = resolvedParam.in;
-			if (location === "body") bodyParam = resolvedParam;
-			else if (location === "formData") {
-				bodyParam = buildFormDataBody(resolvedParam, params);
-				usesFormData = true;
-			} else nonBodyParams.push(normaliseSwaggerParameter(resolvedParam, doc));
-		}
-		if (nonBodyParams.length > 0) result.parameters = nonBodyParams;
-		if (bodyParam !== void 0) result.requestBody = buildRequestBody(bodyParam, usesFormData ? ["multipart/form-data"] : consumes);
-	}
-	const responses = operation.responses;
-	if (isObject(responses)) result.responses = normaliseSwaggerResponses(responses, doc, produces);
-	return result;
-}
-/**
-* Resolve a Swagger parameter that may be a `$ref`.
-*/
-function resolveSwaggerParameter(param, doc, visited = /* @__PURE__ */ new Set()) {
-	const ref = param.$ref;
-	if (typeof ref !== "string" || !ref.startsWith("#/parameters/")) return param;
-	if (visited.has(ref)) return param;
-	const nextVisited = new Set(visited);
-	nextVisited.add(ref);
-	const name = ref.slice(13);
-	const globalParams = doc.parameters;
-	if (isObject(globalParams)) {
-		const resolved = globalParams[name];
-		if (isObject(resolved)) {
-			if (typeof resolved.$ref === "string") return resolveSwaggerParameter(resolved, doc, nextVisited);
-			return resolved;
-		}
-	}
-	return param;
-}
-/**
-* Normalise a single Swagger parameter to OpenAPI 3.x form.
-*/
-function normaliseSwaggerParameter(param, doc) {
-	if (typeof param.$ref === "string") {
-		const resolved = resolveSwaggerParameter(param, doc);
-		if (resolved !== param) return normaliseSwaggerParameter(resolved, doc);
-	}
-	const result = {};
-	for (const [key, value] of Object.entries(param)) {
-		if (key === "type" || key === "format" || key === "collectionFormat") continue;
-		result[key] = value;
-	}
-	if (typeof param.type === "string") {
-		const schema = { type: param.type };
-		if (typeof param.format === "string") schema.format = param.format;
-		if (param.enum !== void 0) schema.enum = param.enum;
-		if (param.default !== void 0) schema.default = param.default;
-		if (param.minimum !== void 0) schema.minimum = param.minimum;
-		if (param.maximum !== void 0) schema.maximum = param.maximum;
-		result.schema = schema;
-	}
-	const cf = param.collectionFormat;
-	if (typeof cf === "string") switch (cf) {
-		case "csv":
-			result.style = "form";
-			result.explode = false;
-			break;
-		case "ssv":
-			result.style = "spaceDelimited";
-			result.explode = false;
-			break;
-		case "tsv":
-			result.style = "tabDelimited";
-			result.explode = false;
-			break;
-		case "pipes":
-			result.style = "pipeDelimited";
-			result.explode = false;
-			break;
-		case "multi":
-			result.style = "form";
-			result.explode = true;
-			break;
-	}
-	return result;
-}
-/**
-* Build a request body from a `formData` parameter.
-*/
-function buildFormDataBody(param, allParams) {
-	const properties = {};
-	const required = [];
-	for (const p of allParams) {
-		if (!isObject(p) || p.in !== "formData") continue;
-		const name = p.name;
-		if (typeof name !== "string") continue;
-		const schema = {};
-		if (p.type === "file") {
-			schema.type = "string";
-			schema.format = "binary";
-		} else {
-			if (typeof p.type === "string") schema.type = p.type;
-			if (typeof p.format === "string") schema.format = p.format;
-			if (p.enum !== void 0) schema.enum = p.enum;
-		}
-		properties[name] = schema;
-		if (p.required === true) required.push(name);
-	}
-	return {
-		name: param.name,
-		in: "body",
-		schema: {
-			type: "object",
-			properties,
-			...required.length > 0 ? { required } : {}
-		}
-	};
-}
-/**
-* Build an OpenAPI 3.x request body from a Swagger 2.0 body parameter.
-*/
-function buildRequestBody(bodyParam, consumes) {
-	const schema = bodyParam.schema;
-	const content = {};
-	const contentTypes = consumes.length > 0 ? consumes : ["application/json"];
-	for (const ct of contentTypes) if (typeof ct === "string") content[ct] = isObject(schema) ? { schema } : {};
-	const result = { content };
-	if (bodyParam.required === true) result.required = true;
-	if (typeof bodyParam.description === "string") result.description = bodyParam.description;
-	return result;
-}
-/**
-* Resolve a Swagger 2.0 response `$ref` (e.g. `#/responses/NotFound`).
-*/
-function resolveSwaggerResponse(response, doc, visited = /* @__PURE__ */ new Set()) {
-	const ref = response.$ref;
-	if (typeof ref !== "string" || !ref.startsWith("#/responses/")) return response;
-	if (visited.has(ref)) return response;
-	const nextVisited = new Set(visited);
-	nextVisited.add(ref);
-	const name = ref.slice(12);
-	const globalResponses = doc.responses;
-	if (isObject(globalResponses)) {
-		const resolved = globalResponses[name];
-		if (isObject(resolved)) {
-			if (typeof resolved.$ref === "string") return resolveSwaggerResponse(resolved, doc, nextVisited);
-			return resolved;
-		}
-	}
-	return response;
-}
-function normaliseSwaggerResponses(responses, doc, produces) {
-	const result = {};
-	for (const [code, response] of Object.entries(responses)) {
-		if (!isObject(response)) {
-			result[code] = response;
-			continue;
-		}
-		const resolved = resolveSwaggerResponse(response, doc);
-		const normalised = {};
-		for (const [key, value] of Object.entries(resolved)) if (key !== "schema") normalised[key] = value;
-		const schema = resolved.schema;
-		if (isObject(schema)) {
-			const content = {};
-			const contentTypes = produces.length > 0 ? produces : ["application/json"];
-			for (const ct of contentTypes) if (typeof ct === "string") content[ct] = { schema };
-			normalised.content = content;
-		}
-		result[code] = normalised;
-	}
-	return result;
-}
-/**
-* Mapping of Swagger 2.0 $ref prefixes to OpenAPI 3.x equivalents.
-* Applied after document restructuring so all $ref strings point
-* to the correct locations in the normalised document.
-*/
-const REF_REWRITES = [
-	["#/definitions/", "#/components/schemas/"],
-	["#/parameters/", "#/components/parameters/"],
-	["#/responses/", "#/components/responses/"]
-];
-/**
-* Deep-rewrite $ref strings in a normalised Swagger 2.0 document
-* from Swagger 2.0 locations to OpenAPI 3.x locations.
-* Mutates the object in place \u2014 called only on the fresh clone
-* produced by normaliseSwagger2Document.
-*/
-function rewriteSwaggerRefs(node) {
-	if (!isObject(node)) return;
-	if (typeof node.$ref === "string") {
-		for (const [from, to] of REF_REWRITES) if (node.$ref.startsWith(from)) {
-			node.$ref = to + node.$ref.slice(from.length);
-			break;
-		}
-	}
-	for (const value of Object.values(node)) if (isObject(value)) rewriteSwaggerRefs(value);
-	else if (Array.isArray(value)) for (const item of value) rewriteSwaggerRefs(item);
-}
-/**
-* Check if any schema in a definitions block contains an `xml` property.
-*/
-function hasXmlInSchemas(definitions) {
-	for (const schema of Object.values(definitions)) if (isObject(schema) && "xml" in schema) return true;
-	return false;
-}
-//#endregion
-//#region src/core/normalise.ts
-/**
-* Keys whose values are `Record<string, SubSchema>` — objects where each
-* property is a sub-schema.
-*/
-const OBJECT_SUBSCHEMA_KEYS = new Set([
-	"properties",
-	"patternProperties",
-	"$defs",
-	"definitions",
-	"dependentSchemas"
-]);
-/**
-* Keys whose values are `SubSchema[]` — arrays of sub-schemas.
-*/
-const ARRAY_SUBSCHEMA_KEYS = new Set([
-	"allOf",
-	"anyOf",
-	"oneOf",
-	"prefixItems"
-]);
-/**
-* Keys whose values are a single sub-schema object.
-*/
-const SINGLE_SUBSCHEMA_KEYS = new Set([
-	"additionalProperties",
-	"not",
-	"contains",
-	"propertyNames",
-	"if",
-	"then",
-	"else",
-	"unevaluatedProperties",
-	"unevaluatedItems"
-]);
-/**
-* Normalise each element of an unknown array by applying deepNormalise
-* to object elements and passing others through unchanged.
-*/
-function normaliseArray(items, transform) {
-	const result = [];
-	for (const item of items) result.push(isObject(item) ? deepNormalise(item, transform) : item);
-	return result;
-}
-/**
-* Normalise each value of a sub-schema map (e.g. properties, $defs).
-*/
-function normaliseSubSchemaMap(map, transform) {
-	const result = {};
-	for (const [k, v] of Object.entries(map)) result[k] = isObject(v) ? deepNormalise(v, transform) : v;
-	return result;
-}
-/**
-* Deep-normalise a JSON Schema object by applying a per-node transform
-* and recursing into every sub-schema location.
-*/
-function deepNormalise(schema, transform) {
-	const node = transform({ ...schema });
-	const result = {};
-	for (const [key, value] of Object.entries(node)) if (isObject(value) && OBJECT_SUBSCHEMA_KEYS.has(key)) result[key] = normaliseSubSchemaMap(value, transform);
-	else if (Array.isArray(value) && ARRAY_SUBSCHEMA_KEYS.has(key)) result[key] = normaliseArray(value, transform);
-	else if (isObject(value) && SINGLE_SUBSCHEMA_KEYS.has(key)) result[key] = deepNormalise(value, transform);
-	else if (key === "items") if (Array.isArray(value)) result[key] = normaliseArray(value, transform);
-	else if (isObject(value)) result[key] = deepNormalise(value, transform);
-	else result[key] = value;
-	else if (key === "dependencies" && isObject(value)) {
-		const normalised = {};
-		for (const [dk, dv] of Object.entries(value)) if (isObject(dv)) normalised[dk] = deepNormalise(dv, transform);
-		else normalised[dk] = dv;
-		result[key] = normalised;
-	} else result[key] = value;
-	return result;
-}
-/**
-* Split the legacy `dependencies` keyword into `dependentRequired` and
-* `dependentSchemas` per the Draft 2019-09+ replacement.
-*
-* Each key in `dependencies` maps to either:
-* - `string[]` → `dependentRequired`
-* - A schema object → `dependentSchemas`
-*
-* Both forms can coexist within the same `dependencies` object.
-* After splitting, `dependencies` is removed from the node.
-*/
-function splitDependencies(node) {
-	const deps = node.dependencies;
-	if (!isObject(deps)) return;
-	const requiredEntries = {};
-	const schemaEntries = {};
-	for (const [key, value] of Object.entries(deps)) if (Array.isArray(value)) {
-		const strings = value.filter((v) => typeof v === "string");
-		if (strings.length === value.length) requiredEntries[key] = strings;
-	} else if (isObject(value)) schemaEntries[key] = value;
-	if (Object.keys(requiredEntries).length > 0) {
-		const existing = node.dependentRequired;
-		if (isObject(existing)) for (const [k, v] of Object.entries(requiredEntries)) existing[k] = v;
-		else node.dependentRequired = requiredEntries;
-	}
-	if (Object.keys(schemaEntries).length > 0) {
-		const existing = node.dependentSchemas;
-		if (isObject(existing)) for (const [k, v] of Object.entries(schemaEntries)) existing[k] = v;
-		else node.dependentSchemas = schemaEntries;
-	}
-	delete node.dependencies;
-}
-/**
-* Normalise Draft 04 `exclusiveMinimum`/`exclusiveMaximum` from boolean
-* to number form.
-*
-* In Draft 04:
-* - `exclusiveMinimum: true` + `minimum: 5` → value must be > 5
-* - `exclusiveMinimum: false` (or absent) + `minimum: 5` → value must be >= 5
-*
-* In Draft 06+:
-* - `exclusiveMinimum: 5` → value must be > 5 (no separate `minimum`)
-* - `minimum: 5` → value must be >= 5
-*
-* The transform converts boolean form to number form so the walker can
-* treat `exclusiveMinimum`/`exclusiveMaximum` uniformly as numbers.
-*/
-function normaliseDraft04Node(node) {
-	if (node.exclusiveMinimum === true && typeof node.minimum === "number") {
-		node.exclusiveMinimum = node.minimum;
-		delete node.minimum;
-	} else if (node.exclusiveMinimum === false) delete node.exclusiveMinimum;
-	if (node.exclusiveMaximum === true && typeof node.maximum === "number") {
-		node.exclusiveMaximum = node.maximum;
-		delete node.maximum;
-	} else if (node.exclusiveMaximum === false) delete node.exclusiveMaximum;
-	if (typeof node.id === "string" && !("$id" in node)) {
-		node.$id = node.id;
-		delete node.id;
-	}
-	if (Array.isArray(node.items) && !("prefixItems" in node)) {
-		node.prefixItems = node.items;
-		delete node.items;
-		if ("additionalItems" in node) {
-			node.items = node.additionalItems;
-			delete node.additionalItems;
-		}
-	}
-	splitDependencies(node);
-	return node;
-}
-/**
-* Normalise Draft 06/07 nodes.
-*
-* These drafts introduced `exclusiveMinimum`/`exclusiveMaximum` as numbers
-* (already in final form) and `const`/`examples`, but still use the
-* legacy `dependencies` keyword. Split it into `dependentRequired` /
-* `dependentSchemas` so the walker can process them uniformly.
-*/
-function normaliseDraft06Or07Node(node) {
-	splitDependencies(node);
-	return node;
-}
-/**
-* Normalise Draft 2019-09 `$recursiveRef` to `$ref`.
-*
-* `$recursiveRef` resolves to the nearest `$recursiveAnchor` in the
-* dynamic scope. For rendering, the common pattern is a root
-* `$recursiveAnchor: true` — the normaliser converts
-* `$recursiveRef: "#"` to `$ref: "#"` pointing to the root.
-*
-* If a `$recursiveAnchor` name is given (non-empty string), the ref
-* is converted to `$ref: "#<anchor>"` so the existing $anchor
-* resolution in ref.ts can find it.
-*/
-function normaliseDraft201909Node(node) {
-	if (typeof node.$recursiveRef === "string") {
-		node.$ref = "#";
-		delete node.$recursiveRef;
-	}
-	if (node.$recursiveAnchor === true) {
-		if (typeof node.$anchor !== "string") node.$anchor = "__recursive__";
-		delete node.$recursiveAnchor;
-	}
-	return node;
-}
-function normaliseDynamicRefNode(node) {
-	if (typeof node.$dynamicRef === "string") {
-		node.$ref = node.$dynamicRef;
-		delete node.$dynamicRef;
-	}
-	if (typeof node.$dynamicAnchor === "string") {
-		if (typeof node.$anchor !== "string") node.$anchor = node.$dynamicAnchor;
-		delete node.$dynamicAnchor;
-	}
-	return node;
-}
-/**
-* Normalise a JSON Schema to canonical Draft 2020-12 form.
-* Deep-clones the input — the original is never mutated.
-*/
-function normaliseJsonSchema(schema, draft) {
-	switch (draft) {
-		case "draft-04": return deepNormalise(schema, normaliseDraft04Node);
-		case "draft-2019-09": return deepNormalise(schema, normaliseDraft201909Node);
-		case "draft-2020-12": return deepNormalise(schema, normaliseDynamicRefNode);
-		case "draft-06":
-		case "draft-07": return deepNormalise(schema, normaliseDraft06Or07Node);
-	}
-}
-/**
-* Normalise an OpenAPI document's schemas for walker consumption.
-* Handles version-specific keyword transformations.
-*
-* Returns the same object reference if no normalisation is needed
-* (OpenAPI 3.1.x), or a deep-cloned normalised copy otherwise.
-*/
-function normaliseOpenApiSchemas(doc, version, diagnostics) {
-	if (isSwagger2(version)) return normaliseSwagger2Document(doc, deepNormalise, normaliseDraft04Node, diagnostics);
-	if (isOpenApi30(version)) return deepNormaliseOpenApi30Doc(doc, deepNormalise);
-	return doc;
-}
-//#endregion
-export { normaliseSwagger2Document as a, normaliseOpenApi30Discriminator as c, normaliseOpenApiSchemas as i, normaliseOpenApi30Node as l, normaliseDraft04Node as n, deepNormaliseOpenApi30Doc as o, normaliseJsonSchema as r, normaliseOpenApi30Combined as s, deepNormalise as t };