fumadocs-openapi 10.6.8 → 10.7.0

package/dist/node_modules/.pnpm/@scalar_openapi-upgrader@0.2.4/node_modules/@scalar/openapi-upgrader/dist/2.0-to-3.0/upgrade-from-two-to-three.js

@@ -0,0 +1,487 @@
+import { traverse } from "../helpers/traverse.js";
+//#region ../../node_modules/.pnpm/@scalar+openapi-upgrader@0.2.4/node_modules/@scalar/openapi-upgrader/dist/2.0-to-3.0/upgrade-from-two-to-three.js
+const DEFAULT_MEDIA_TYPE = "application/json";
+/** Extracts and removes x-example and x-examples extensions from an object */
+function extractXExampleExtensions(obj) {
+	const xExample = obj["x-example"];
+	const xExamples = obj["x-examples"];
+	delete obj["x-example"];
+	delete obj["x-examples"];
+	return {
+		xExample,
+		xExamples
+	};
+}
+/** Checks if a value is a non-null, non-array object with at least one entry */
+function isNonEmptyObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+/**
+* Checks if a value looks like a collection of named examples (all values are objects).
+* This helps distinguish between:
+* - A single example: { message: 'OK', type: 'success' } - values are primitives
+* - Named examples: { 'my-example': { message: 'OK' } } - values are objects
+*/
+function isNamedExamplesCollection(value) {
+	return isNonEmptyObject(value) && Object.values(value).every((v) => typeof v === "object" && v !== null && !Array.isArray(v));
+}
+/** Checks if a schema is empty (no meaningful properties defined) */
+function isEmptySchema(schema) {
+	if (typeof schema !== "object" || schema === null) return true;
+	const s = schema;
+	if (s.allOf || s.oneOf || s.anyOf || s.items || s.$ref || "additionalProperties" in s || [
+		"enum",
+		"const",
+		"not",
+		"format",
+		"multipleOf",
+		"maximum",
+		"exclusiveMaximum",
+		"minimum",
+		"exclusiveMinimum",
+		"maxLength",
+		"minLength",
+		"pattern",
+		"maxItems",
+		"minItems",
+		"uniqueItems",
+		"maxProperties",
+		"minProperties",
+		"required"
+	].some((key) => key in s)) return false;
+	if (typeof s.properties === "object" && s.properties !== null && Object.keys(s.properties).length > 0) return false;
+	return true;
+}
+/**
+* Removes content entries that only have an empty schema (no example/examples)
+* when other entries with actual examples exist. This prevents the UI from
+* selecting a meaningless produces-based entry over one with a real example.
+*/
+function removeEmptySchemaOnlyContentEntries(content) {
+	const keys = Object.keys(content);
+	if (!keys.some((key) => {
+		const entry = content[key];
+		return entry?.example !== void 0 || entry?.examples !== void 0;
+	})) return;
+	for (const key of keys) {
+		const entry = content[key];
+		if (!entry) continue;
+		const hasExample = entry.example !== void 0 || entry.examples !== void 0;
+		if (entry.schema !== void 0 && !hasExample && Object.keys(entry).length === 1 && isEmptySchema(entry.schema)) delete content[key];
+	}
+}
+/** The allowed properties for an OpenAPI 3.x ExampleObject */
+const EXAMPLE_OBJECT_PROPERTIES = new Set([
+	"summary",
+	"description",
+	"value",
+	"externalValue"
+]);
+/**
+* Checks if a value is a valid OpenAPI 3.x ExampleObject.
+*
+* An ExampleObject must have a `value` (or `externalValue`) property and can only contain
+* properties from the allowed set: `summary`, `description`, `value`, `externalValue`.
+*
+* This prevents false positives when user's example data happens to have a `value` property
+* (e.g., `{ value: "some data", count: 5 }` should NOT be treated as an ExampleObject).
+*/
+function isExampleObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const obj = value;
+	const hasValueOrExternalValue = "value" in obj || "externalValue" in obj;
+	const onlyHasAllowedProperties = Object.keys(obj).every((key) => EXAMPLE_OBJECT_PROPERTIES.has(key));
+	return hasValueOrExternalValue && onlyHasAllowedProperties;
+}
+/** Wraps a value as an ExampleObject, preserving existing structure if valid */
+function wrapAsExampleObject(value) {
+	if (isExampleObject(value)) return value;
+	return { value };
+}
+/**
+* True if the key looks like a MIME media type (e.g. application/json, text/plain).
+* Used to distinguish media-type example keys from named example keys when migrating
+* Swagger 2.0 examples to OpenAPI 3.0 content. Requires exactly one slash and
+* token-style type/subtype (no spaces or semicolons) to avoid false positives
+* for named keys that contain a slash (e.g. "Error 404/Not Found").
+*/
+const MEDIA_TYPE_KEY_PATTERN = /^[a-zA-Z0-9*+.-]+\/[a-zA-Z0-9*+.+-]+$/;
+function isMediaTypeKey(key) {
+	return MEDIA_TYPE_KEY_PATTERN.test(key);
+}
+/** Transforms x-example entries to OpenAPI 3.x examples format */
+function transformXExampleToExamples(xExample) {
+	return Object.entries(xExample).reduce((acc, [key, value]) => {
+		acc[key] = { value };
+		return acc;
+	}, {});
+}
+/** Update the flow names to OpenAPI 3.1.0 format */
+const upgradeFlow = (flow) => {
+	switch (flow) {
+		case "application": return "clientCredentials";
+		case "accessCode": return "authorizationCode";
+		case "implicit": return "implicit";
+		case "password": return "password";
+		default: return flow;
+	}
+};
+/**
+* Upgrade Swagger 2.0 to OpenAPI 3.0
+*
+* https://swagger.io/blog/news/whats-new-in-openapi-3-0/
+*/
+function upgradeFromTwoToThree(originalSpecification) {
+	let document = originalSpecification;
+	if (document !== null && typeof document === "object" && typeof document.swagger === "string" && document.swagger?.startsWith("2.0")) {
+		document.openapi = "3.0.4";
+		delete document.swagger;
+	} else return document;
+	if (document.host) {
+		const schemes = Array.isArray(document.schemes) && document.schemes?.length ? document.schemes : ["http"];
+		document.servers = schemes.map((scheme) => ({ url: `${scheme}://${document.host}${document.basePath ?? ""}` }));
+		delete document.basePath;
+		delete document.schemes;
+		delete document.host;
+	} else if (document.basePath) {
+		document.servers = [{ url: document.basePath }];
+		delete document.basePath;
+	}
+	if (document.definitions) {
+		document.components = Object.assign({}, document.components, { schemas: document.definitions });
+		delete document.definitions;
+		document = traverse(document, (schema) => {
+			if (typeof schema.$ref === "string" && schema.$ref.startsWith("#/definitions/")) schema.$ref = schema.$ref.replace(/^#\/definitions\//, "#/components/schemas/");
+			return schema;
+		});
+	}
+	document = traverse(document, (schema) => {
+		if (schema.type === "file") {
+			schema.type = "string";
+			schema.format = "binary";
+		}
+		return schema;
+	});
+	if (Object.hasOwn(document, "parameters")) {
+		document = traverse(document, (schema) => {
+			if (typeof schema.$ref === "string" && schema.$ref.startsWith("#/parameters/")) {
+				const schemaName = schema.$ref.split("/")[2];
+				if (!schemaName) return schema;
+				const param = document.parameters && typeof document.parameters === "object" && schemaName in document.parameters ? document.parameters[schemaName] : void 0;
+				if (param && typeof param === "object" && "in" in param && (param.in === "body" || param.in === "formData")) schema.$ref = schema.$ref.replace(/^#\/parameters\//, "#/components/requestBodies/");
+				else schema.$ref = schema.$ref.replace(/^#\/parameters\//, "#/components/parameters/");
+			}
+			return schema;
+		});
+		document.components ??= {};
+		const params = {};
+		const bodyParams = {};
+		const parameters = document.parameters && typeof document.parameters === "object" ? document.parameters : {};
+		for (const [name, param] of Object.entries(parameters)) if (param && typeof param === "object") {
+			if ("$ref" in param) params[name] = transformParameterObject(param);
+			else if ("in" in param) if (param.in === "body") bodyParams[name] = migrateBodyParameter(param, document.consumes ?? [DEFAULT_MEDIA_TYPE]);
+			else if (param.in === "formData") bodyParams[name] = migrateFormDataParameter([param], document.consumes);
+			else params[name] = transformParameterObject(param);
+		}
+		if (Object.keys(params).length > 0) document.components.parameters = params;
+		if (Object.keys(bodyParams).length > 0) document.components.requestBodies = bodyParams;
+		delete document.parameters;
+	}
+	if (Object.hasOwn(document, "responses") && typeof document.responses === "object" && document.responses !== null) {
+		document = traverse(document, (schema) => {
+			if (typeof schema.$ref === "string" && schema.$ref.startsWith("#/responses/")) schema.$ref = schema.$ref.replace(/^#\/responses\//, "#/components/responses/");
+			return schema;
+		});
+		document.components ??= {};
+		const migratedResponses = {};
+		const responses = document.responses;
+		for (const [name, response] of Object.entries(responses)) if (response && typeof response === "object") if ("$ref" in response) migratedResponses[name] = response;
+		else {
+			const responseObj = response;
+			const produces = document.produces ?? [DEFAULT_MEDIA_TYPE];
+			if (responseObj.schema) {
+				if (typeof responseObj.content !== "object") responseObj.content = {};
+				for (const type of produces) responseObj.content[type] = { schema: responseObj.schema };
+				delete responseObj.schema;
+			}
+			if (responseObj.examples && typeof responseObj.examples === "object") {
+				if (typeof responseObj.content !== "object") responseObj.content = {};
+				const defaultMediaType = produces[0] ?? DEFAULT_MEDIA_TYPE;
+				for (const [key, exampleValue] of Object.entries(responseObj.examples)) if (isMediaTypeKey(key)) {
+					if (typeof responseObj.content[key] !== "object") responseObj.content[key] = {};
+					responseObj.content[key].example = exampleValue;
+				} else {
+					if (typeof responseObj.content[defaultMediaType] !== "object") responseObj.content[defaultMediaType] = {};
+					const mediaEntry = responseObj.content[defaultMediaType];
+					if (typeof mediaEntry.examples !== "object") mediaEntry.examples = {};
+					mediaEntry.examples[key] = wrapAsExampleObject(exampleValue);
+				}
+				delete responseObj.examples;
+			}
+			if (responseObj.content && typeof responseObj.content === "object") removeEmptySchemaOnlyContentEntries(responseObj.content);
+			if (responseObj.headers && typeof responseObj.headers === "object") responseObj.headers = Object.entries(responseObj.headers).reduce((acc, [headerName, header]) => {
+				if (header && typeof header === "object") return {
+					[headerName]: transformResponseHeader(header),
+					...acc
+				};
+				return acc;
+			}, {});
+			migratedResponses[name] = responseObj;
+		}
+		if (Object.keys(migratedResponses).length > 0) document.components.responses = migratedResponses;
+		delete document.responses;
+	}
+	if (typeof document.paths === "object") {
+		for (const path in document.paths) if (Object.hasOwn(document.paths, path)) {
+			const pathItem = document.paths && typeof document.paths === "object" && path in document.paths ? document.paths[path] : void 0;
+			if (!pathItem || typeof pathItem !== "object") continue;
+			let requestBodyObject;
+			for (const methodOrParameters in pathItem) if (methodOrParameters === "parameters" && Object.hasOwn(pathItem, methodOrParameters)) {
+				const pathItemParameters = migrateParameters(pathItem.parameters, document.consumes ?? [DEFAULT_MEDIA_TYPE]);
+				pathItem.parameters = pathItemParameters.parameters;
+				requestBodyObject = pathItemParameters.requestBody;
+			} else if (Object.hasOwn(pathItem, methodOrParameters)) {
+				const operationItem = pathItem[methodOrParameters];
+				if (requestBodyObject) operationItem.requestBody = requestBodyObject;
+				if (operationItem.parameters) {
+					const migrationResult = migrateParameters(operationItem.parameters, operationItem.consumes ?? document.consumes ?? [DEFAULT_MEDIA_TYPE]);
+					operationItem.parameters = migrationResult.parameters;
+					if (migrationResult.requestBody) operationItem.requestBody = migrationResult.requestBody;
+				}
+				delete operationItem.consumes;
+				if (operationItem.responses) {
+					for (const response in operationItem.responses) if (Object.hasOwn(operationItem.responses, response)) {
+						const responseItem = operationItem.responses[response];
+						if (responseItem.headers && typeof responseItem.headers === "object") responseItem.headers = Object.entries(responseItem.headers).reduce((acc, [name, header]) => {
+							if (header && typeof header === "object") return {
+								[name]: transformResponseHeader(header),
+								...acc
+							};
+							return acc;
+						}, {});
+						if (responseItem.schema) {
+							const produces = document.produces ?? operationItem.produces ?? [DEFAULT_MEDIA_TYPE];
+							if (typeof responseItem.content !== "object") responseItem.content = {};
+							for (const type of produces) responseItem.content[type] = { schema: responseItem.schema };
+							delete responseItem.schema;
+						}
+						if (responseItem.examples && typeof responseItem.examples === "object") {
+							if (typeof responseItem.content !== "object") responseItem.content = {};
+							const defaultMediaType = (document.produces ?? operationItem.produces ?? [DEFAULT_MEDIA_TYPE])[0] ?? DEFAULT_MEDIA_TYPE;
+							for (const [key, exampleValue] of Object.entries(responseItem.examples)) if (isMediaTypeKey(key)) {
+								if (typeof responseItem.content[key] !== "object") responseItem.content[key] = {};
+								responseItem.content[key].example = exampleValue;
+							} else {
+								if (typeof responseItem.content[defaultMediaType] !== "object") responseItem.content[defaultMediaType] = {};
+								const mediaEntry = responseItem.content[defaultMediaType];
+								if (typeof mediaEntry.examples !== "object") mediaEntry.examples = {};
+								mediaEntry.examples[key] = wrapAsExampleObject(exampleValue);
+							}
+							delete responseItem.examples;
+						}
+						if (responseItem.content && typeof responseItem.content === "object") removeEmptySchemaOnlyContentEntries(responseItem.content);
+					}
+				}
+				delete operationItem.produces;
+				if (operationItem.parameters?.length === 0) delete operationItem.parameters;
+			}
+		}
+	}
+	if (document.securityDefinitions) {
+		if (typeof document.components !== "object" || document.components === null) document.components = {};
+		if (document.components && typeof document.components === "object") Object.assign(document.components, { securitySchemes: {} });
+		for (const [key, securityScheme] of Object.entries(document.securityDefinitions)) if (typeof securityScheme === "object") {
+			if ("type" in securityScheme && securityScheme.type === "oauth2") {
+				const { flow, authorizationUrl, tokenUrl, scopes } = securityScheme;
+				if (document.components && typeof document.components === "object" && "securitySchemes" in document.components && document.components.securitySchemes) Object.assign(document.components.securitySchemes, { [key]: {
+					type: "oauth2",
+					flows: { [upgradeFlow(flow || "implicit")]: Object.assign({}, authorizationUrl && { authorizationUrl }, tokenUrl && { tokenUrl }, scopes && { scopes }) }
+				} });
+			} else if ("type" in securityScheme && securityScheme.type === "basic") {
+				if (document.components && typeof document.components === "object" && "securitySchemes" in document.components && document.components.securitySchemes) Object.assign(document.components.securitySchemes, { [key]: {
+					type: "http",
+					scheme: "basic"
+				} });
+			} else if (document.components && typeof document.components === "object" && "securitySchemes" in document.components && document.components.securitySchemes) Object.assign(document.components.securitySchemes, { [key]: securityScheme });
+		}
+		delete document.securityDefinitions;
+	}
+	delete document.consumes;
+	delete document.produces;
+	return document;
+}
+function transformItemsObject(obj) {
+	return [
+		"type",
+		"format",
+		"default",
+		"items",
+		"maximum",
+		"exclusiveMaximum",
+		"minimum",
+		"exclusiveMinimum",
+		"maxLength",
+		"minLength",
+		"pattern",
+		"maxItems",
+		"minItems",
+		"uniqueItems",
+		"enum",
+		"multipleOf"
+	].reduce((acc, property) => {
+		if (Object.hasOwn(obj, property)) {
+			acc[property] = obj[property];
+			delete obj[property];
+		}
+		return acc;
+	}, {});
+}
+function getParameterLocation(location) {
+	if (location === "formData") throw new Error("Encountered a formData parameter which should have been filtered out by the caller");
+	if (location === "body") throw new Error("Encountered a body parameter which should have been filtered out by the caller");
+	return location;
+}
+function transformParameterObject(parameter) {
+	if (Object.hasOwn(parameter, "$ref") && typeof parameter.$ref === "string") return { $ref: parameter.$ref };
+	const serializationStyle = getParameterSerializationStyle(parameter);
+	const schema = transformItemsObject(parameter);
+	const { xExample, xExamples } = extractXExampleExtensions(parameter);
+	if (isNonEmptyObject(xExample)) parameter.examples = transformXExampleToExamples(xExample);
+	else if (isNonEmptyObject(xExamples)) parameter.examples = Object.entries(xExamples).reduce((acc, [key, exampleValue]) => {
+		acc[key] = wrapAsExampleObject(exampleValue);
+		return acc;
+	}, {});
+	delete parameter.collectionFormat;
+	delete parameter.default;
+	if (!parameter.in) throw new Error("Parameter object must have an \"in\" property");
+	return {
+		schema,
+		...serializationStyle,
+		...parameter,
+		in: getParameterLocation(parameter.in)
+	};
+}
+/**
+* Transform OpenAPI 2.0 response header to OpenAPI 3.0 format.
+* Response headers do not have "in", "name", "style", or "explode" properties.
+*/
+function transformResponseHeader(header) {
+	if (Object.hasOwn(header, "$ref") && typeof header.$ref === "string") return { $ref: header.$ref };
+	const schema = transformItemsObject(header);
+	return {
+		...header,
+		schema
+	};
+}
+const querySerialization = {
+	ssv: {
+		style: "spaceDelimited",
+		explode: false
+	},
+	pipes: {
+		style: "pipeDelimited",
+		explode: false
+	},
+	multi: {
+		style: "form",
+		explode: true
+	},
+	csv: {
+		style: "form",
+		explode: false
+	},
+	tsv: {}
+};
+const pathAndHeaderSerialization = {
+	ssv: {},
+	pipes: {},
+	multi: {},
+	csv: {
+		style: "simple",
+		explode: false
+	},
+	tsv: {}
+};
+const serializationStyles = {
+	header: pathAndHeaderSerialization,
+	query: querySerialization,
+	path: pathAndHeaderSerialization
+};
+function getParameterSerializationStyle(parameter) {
+	if (parameter.type !== "array" || !(parameter.in === "query" || parameter.in === "path" || parameter.in === "header")) return {};
+	const collectionFormat = parameter.collectionFormat ?? "csv";
+	if (parameter.in in serializationStyles && collectionFormat in serializationStyles[parameter.in]) return serializationStyles[parameter.in][collectionFormat];
+	return {};
+}
+function migrateBodyParameter(bodyParameter, consumes) {
+	const { xExample, xExamples } = extractXExampleExtensions(bodyParameter);
+	delete bodyParameter.name;
+	delete bodyParameter.in;
+	const { schema, ...requestBody } = bodyParameter;
+	const requestBodyObject = {
+		content: {},
+		...requestBody
+	};
+	if (requestBodyObject.content) for (const type of consumes) {
+		requestBodyObject.content[type] = { schema };
+		if (isNonEmptyObject(xExamples) && type in xExamples) {
+			const examples = xExamples[type];
+			if (isNonEmptyObject(examples) && Object.values(examples).every((example) => isExampleObject(example))) requestBodyObject.content[type].examples = examples;
+			else if (isNamedExamplesCollection(examples)) requestBodyObject.content[type].examples = Object.entries(examples).reduce((acc, [key, exampleValue]) => {
+				acc[key] = wrapAsExampleObject(exampleValue);
+				return acc;
+			}, {});
+			else requestBodyObject.content[type].examples = { default: wrapAsExampleObject(examples) };
+		} else if (isNonEmptyObject(xExamples) && !Object.keys(xExamples).some(isMediaTypeKey)) requestBodyObject.content[type].examples = Object.entries(xExamples).reduce((acc, [key, exampleValue]) => {
+			acc[key] = wrapAsExampleObject(exampleValue);
+			return acc;
+		}, {});
+		if (!requestBodyObject.content[type].examples && isNonEmptyObject(xExample) && type in xExample) requestBodyObject.content[type].example = xExample[type];
+	}
+	return requestBodyObject;
+}
+function migrateFormDataParameter(parameters, consumes = ["multipart/form-data"]) {
+	const requestBodyObject = { content: {} };
+	const filtered = consumes.filter((type) => type === "multipart/form-data" || type === "application/x-www-form-urlencoded");
+	const contentTypes = filtered.length > 0 ? filtered : ["multipart/form-data"];
+	if (requestBodyObject.content) for (const contentType of contentTypes) {
+		requestBodyObject.content[contentType] = { schema: {
+			type: "object",
+			properties: {},
+			required: []
+		} };
+		const formContent = requestBodyObject.content?.[contentType];
+		if (formContent?.schema && typeof formContent.schema === "object" && "properties" in formContent.schema) {
+			for (const param of parameters) if (param.name && formContent.schema.properties) {
+				formContent.schema.properties[param.name] = {
+					type: param.type,
+					description: param.description,
+					...param.format ? { format: param.format } : {}
+				};
+				if (param.required && Array.isArray(formContent.schema.required)) formContent.schema.required.push(param.name);
+			}
+		}
+	}
+	return requestBodyObject;
+}
+function migrateParameters(parameters, consumes) {
+	const result = { parameters: parameters.filter((parameter) => !(parameter.in === "body" || parameter.in === "formData")).map((parameter) => transformParameterObject(parameter)) };
+	const bodyParameter = structuredClone(parameters.find((parameter) => parameter.in === "body") ?? {});
+	if (bodyParameter && Object.keys(bodyParameter).length) result.requestBody = migrateBodyParameter(bodyParameter, consumes);
+	const formDataParameters = parameters.filter((parameter) => parameter.in === "formData");
+	if (formDataParameters.length > 0) {
+		const requestBodyObject = migrateFormDataParameter(formDataParameters, consumes);
+		if (typeof result.requestBody !== "object") result.requestBody = requestBodyObject;
+		else result.requestBody = {
+			...result.requestBody,
+			content: {
+				...result.requestBody.content,
+				...requestBodyObject.content
+			}
+		};
+		if (typeof result.requestBody !== "object") result.requestBody = { content: {} };
+	}
+	return result;
+}
+//#endregion
+export { upgradeFromTwoToThree };

package/dist/node_modules/.pnpm/@scalar_openapi-upgrader@0.2.4/node_modules/@scalar/openapi-upgrader/dist/3.0-to-3.1/upgrade-from-three-to-three-one.js

@@ -0,0 +1,95 @@
+import { traverse } from "../helpers/traverse.js";
+//#region ../../node_modules/.pnpm/@scalar+openapi-upgrader@0.2.4/node_modules/@scalar/openapi-upgrader/dist/3.0-to-3.1/upgrade-from-three-to-three-one.js
+const SCHEMA_SEGMENTS = new Set([
+	"properties",
+	"items",
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"not",
+	"additionalProperties",
+	"schema"
+]);
+/** Determine if the current path is within a schema - optimized version */
+function isSchemaPath(path) {
+	if (!path) return false;
+	if (path.some((segment) => SCHEMA_SEGMENTS.has(segment))) return true;
+	if (path.some((segment) => segment.endsWith("Schema"))) return true;
+	if (path.length >= 2 && path[0] === "components" && path[1] === "schemas") return true;
+	return false;
+}
+/**
+* Upgrade from OpenAPI 3.0.x to 3.1.1
+*
+* https://www.openapis.org/blog/2021/02/16/migrating-from-openapi-3-0-to-3-1-0
+*/
+function upgradeFromThreeToThreeOne(originalContent) {
+	let content = originalContent;
+	if (content === null || typeof content.openapi !== "string" || !content.openapi.startsWith("3.0")) return content;
+	content.openapi = "3.1.1";
+	content = traverse(content, applyChangesToDocument);
+	return content;
+}
+const applyChangesToDocument = (schema, path) => {
+	if (schema.type !== void 0 && schema.nullable === true) {
+		schema.type = [schema.type, "null"];
+		delete schema.nullable;
+	}
+	if (schema.exclusiveMinimum === true) {
+		schema.exclusiveMinimum = schema.minimum;
+		delete schema.minimum;
+	} else if (schema.exclusiveMinimum === false) delete schema.exclusiveMinimum;
+	if (schema.exclusiveMaximum === true) {
+		schema.exclusiveMaximum = schema.maximum;
+		delete schema.maximum;
+	} else if (schema.exclusiveMaximum === false) delete schema.exclusiveMaximum;
+	const isInsideExamplesMap = path?.some((segment, index) => {
+		if (segment === "examples" && index > 0) return path[index - 1] !== "properties";
+		return false;
+	});
+	if (schema.example !== void 0 && !isInsideExamplesMap) {
+		if (isSchemaPath(path)) schema.examples = [schema.example];
+		else schema.examples = { default: { value: schema.example } };
+		delete schema.example;
+	}
+	if (schema.type === "object" && schema.properties !== void 0) {
+		if ((path?.slice(0, -1))?.some((segment, index) => {
+			return segment === "content" && path?.[index + 1] === "multipart/form-data";
+		}) && schema.properties !== null) {
+			for (const value of Object.values(schema.properties)) if (typeof value === "object" && value !== null && "type" in value && "format" in value && value.type === "string" && value.format === "binary") {
+				value.contentMediaType = "application/octet-stream";
+				delete value.format;
+			}
+		}
+	}
+	if (path?.includes("content") && path?.includes("application/octet-stream")) return {};
+	const { format: _, ...rest } = schema;
+	if (schema.type === "string") {
+		if (schema.format === "binary") return {
+			...rest,
+			type: "string",
+			contentMediaType: "application/octet-stream"
+		};
+		if (schema.format === "base64") return {
+			...rest,
+			type: "string",
+			contentEncoding: "base64"
+		};
+		if (schema.format === "byte") {
+			const contentMediaType = (path?.slice(0, -1))?.find((_, index) => path?.[index - 1] === "content");
+			return {
+				...rest,
+				type: "string",
+				contentEncoding: "base64",
+				contentMediaType
+			};
+		}
+	}
+	if (schema["x-webhooks"] !== void 0) {
+		schema.webhooks = schema["x-webhooks"];
+		delete schema["x-webhooks"];
+	}
+	return schema;
+};
+//#endregion
+export { upgradeFromThreeToThreeOne };

package/dist/node_modules/.pnpm/@scalar_openapi-upgrader@0.2.4/node_modules/@scalar/openapi-upgrader/dist/3.1-to-3.2/upgrade-from-three-one-to-three-two.js

@@ -0,0 +1,59 @@
+//#region ../../node_modules/.pnpm/@scalar+openapi-upgrader@0.2.4/node_modules/@scalar/openapi-upgrader/dist/3.1-to-3.2/upgrade-from-three-one-to-three-two.js
+/**
+* Recursively migrate XML object properties from 3.1 to 3.2 format
+*/
+function migrateXmlObjects(obj) {
+	if (obj === null || typeof obj !== "object") return;
+	if (Array.isArray(obj)) {
+		for (const item of obj) migrateXmlObjects(item);
+		return;
+	}
+	if (obj.xml && typeof obj.xml === "object") {
+		if (obj.xml.wrapped === true && obj.xml.attribute === true) throw new Error("Invalid XML configuration: wrapped and attribute cannot be true at the same time.");
+		if (obj.xml.wrapped === true) {
+			delete obj.xml.wrapped;
+			obj.xml.nodeType = "element";
+		}
+		if (obj.xml.attribute === true) {
+			delete obj.xml.attribute;
+			obj.xml.nodeType = "attribute";
+		}
+	}
+	for (const key in obj) if (Object.hasOwn(obj, key)) migrateXmlObjects(obj[key]);
+}
+/**
+* Migrate x-tagGroups to kind property on tags
+*/
+function migrateTagGroups(document) {
+	if (document["x-tagGroups"] && Array.isArray(document["x-tagGroups"])) {
+		const tagGroups = document["x-tagGroups"];
+		if (!document.tags) document.tags = [];
+		const tagGroupMap = /* @__PURE__ */ new Map();
+		for (const group of tagGroups) for (const tagName of group.tags) tagGroupMap.set(tagName, group.name);
+		if (Array.isArray(document.tags)) {
+			for (const tag of document.tags) if (typeof tag === "object" && tag !== null && "name" in tag) {
+				const groupName = tagGroupMap.get(tag.name);
+				if (groupName) if (groupName.toLowerCase().includes("nav") || groupName.toLowerCase().includes("navigation")) tag.kind = "nav";
+				else if (groupName.toLowerCase().includes("audience")) tag.kind = "audience";
+				else if (groupName.toLowerCase().includes("badge")) tag.kind = "badge";
+				else tag.kind = "nav";
+			}
+		}
+		delete document["x-tagGroups"];
+	}
+}
+/**
+* Upgrade OpenAPI 3.1 to 3.2
+*
+* @see https://github.com/OAI/OpenAPI-Specification/compare/main...v3.2-dev
+*/
+function upgradeFromThreeOneToThreeTwo(originalDocument) {
+	const document = originalDocument;
+	if (document !== null && typeof document === "object" && typeof document.openapi === "string" && document.openapi?.startsWith("3.1")) document.openapi = "3.2.0";
+	else return document;
+	migrateTagGroups(document);
+	migrateXmlObjects(document);
+	return document;
+}
+//#endregion
+export { upgradeFromThreeOneToThreeTwo };

package/dist/node_modules/.pnpm/@scalar_openapi-upgrader@0.2.4/node_modules/@scalar/openapi-upgrader/dist/helpers/traverse.js

@@ -0,0 +1,25 @@
+//#region ../../node_modules/.pnpm/@scalar+openapi-upgrader@0.2.4/node_modules/@scalar/openapi-upgrader/dist/helpers/traverse.js
+/**
+* Recursively traverses the content and applies the transform function to each node.
+*/
+function traverse(content, transform, path = []) {
+	const result = {};
+	for (const [key, value] of Object.entries(content)) {
+		const currentPath = [...path, key];
+		if (Array.isArray(value)) {
+			result[key] = value.map((item, index) => {
+				if (typeof item === "object" && !Array.isArray(item) && item !== null) return traverse(item, transform, [...currentPath, index.toString()]);
+				return item;
+			});
+			continue;
+		}
+		if (typeof value === "object" && value !== null) {
+			result[key] = traverse(value, transform, currentPath);
+			continue;
+		}
+		result[key] = value;
+	}
+	return transform(result, path);
+}
+//#endregion
+export { traverse };