schema-components 1.13.0 → 1.15.0

package/dist/normalise-tL9FckAk.mjs

@@ -0,0 +1,748 @@
+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 };