@andesine/pages 0.0.0-stage → 0.4.0

package/dist/chunks/view-C-9ZM1zK.js

@@ -0,0 +1,745 @@
+import { r as prepareMarkdown, t as highlightCode } from "./prepare-lnuw_ycM.js";
+import { t as isObject } from "./normalize-DG5nxOLm.js";
+import { c as resolveSchemaDetails, d as toSchemeLabel, f as toStatusLabel, l as toFacts, o as getRequiredNames, p as toTypeLabel, s as resolveSchema } from "./stored-CcEfvCQH.js";
+import { toHtml } from "hast-util-to-html";
+//#region src/sources/openapi/styles.ts
+/** A value in the default `simple` style of path and header parameters, e.g. `a,b`. */
+const toSimpleValue = (value, encode = String) => {
+	if (Array.isArray(value)) return value.map(encode).join(",");
+	if (isObject(value)) return Object.entries(value).flat().map(encode).join(",");
+	return encode(value);
+};
+/** A value in the `simple` style; `explode` writes object values as `key=value` pairs. */
+const toSimpleStyleValue = (parameter, value) => {
+	if (!parameter.explode || !isObject(value)) return toSimpleValue(value);
+	return Object.entries(value).map(([key, item]) => `${key}=${String(item)}`).join(",");
+};
+/** A path value in the parameter's style: `simple` by default, `label` (`.a`), or `matrix` (`;id=a`). */
+const toPathValue = (parameter, value) => {
+	const isObjectValue = isObject(value);
+	const encode = (item) => encodeURIComponent(String(item));
+	const items = isObjectValue ? Object.entries(value).flatMap(([key, item]) => {
+		return parameter.explode ? [`${encode(key)}=${encode(item)}`] : [encode(key), encode(item)];
+	}) : (Array.isArray(value) ? value : [value]).map(encode);
+	if (parameter.style === "label") return `.${items.join(parameter.explode ? "." : ",")}`;
+	if (parameter.style === "matrix") return parameter.explode ? items.map((item) => `;${isObjectValue ? "" : `${encode(parameter.name)}=`}${item}`).join("") : `;${encode(parameter.name)}=${items.join(",")}`;
+	return items.join(",");
+};
+/** Query entries in the parameter's style: by default `form`, which repeats the name for each array item. */
+const toQueryEntries = (parameter, value, encode = String) => {
+	const { name, style = "form" } = parameter;
+	const explode = parameter.explode ?? style === "form";
+	const delimiter = {
+		spaceDelimited: " ",
+		pipeDelimited: "|"
+	}[style];
+	if (style === "deepObject" && isObject(value)) return Object.entries(value).map(([key, item]) => [`${name}[${key}]`, encode(item)]);
+	if (Array.isArray(value) && delimiter) return [[name, value.map(encode).join(style === "spaceDelimited" ? encode(delimiter) : delimiter)]];
+	if (!explode) return [[name, toSimpleValue(value, encode)]];
+	if (Array.isArray(value)) return value.map((item) => [name, encode(item)]);
+	if (isObject(value)) return Object.entries(value).map(([key, item]) => [key, encode(item)]);
+	return [[name, encode(value)]];
+};
+//#endregion
+//#region src/sources/openapi/samples.ts
+const maxDepth$1 = 8;
+const formatSamples = {
+	"date-time": "2026-01-01T00:00:00Z",
+	"date": "2026-01-01",
+	"time": "00:00:00Z",
+	"email": "user@example.com",
+	"uri": "https://example.com",
+	"url": "https://example.com",
+	"hostname": "example.com",
+	"uuid": "00000000-0000-0000-0000-000000000000",
+	"ipv4": "192.0.2.1",
+	"ipv6": "2001:db8::1",
+	"byte": "U3RyaW5n",
+	"binary": "<binary>"
+};
+const limitKeys = [
+	"minimum",
+	"exclusiveMinimum",
+	"maximum",
+	"exclusiveMaximum"
+];
+/**
+* A number within the limits: the lower limit, or 0 without one, up to the upper limit.
+* Integers round toward the inside of the limits.
+*/
+const toNumberSample = (constraints = {}, integer) => {
+	const [minimum, exclusiveMinimum, maximum, exclusiveMaximum] = limitKeys.map((key) => {
+		const value = constraints[key];
+		return typeof value === "number" ? value : void 0;
+	});
+	const lower = minimum ?? (exclusiveMinimum === void 0 ? void 0 : exclusiveMinimum + 1);
+	const upper = maximum ?? (exclusiveMaximum === void 0 ? void 0 : exclusiveMaximum - 1);
+	const isNarrow = lower !== void 0 && upper !== void 0 && lower > upper;
+	const usesUpper = upper !== void 0 && upper < (lower ?? 0);
+	if (isNarrow) {
+		const middle = ((minimum ?? exclusiveMinimum) + (maximum ?? exclusiveMaximum)) / 2;
+		return integer ? Math.ceil(middle) : middle;
+	}
+	if (usesUpper) return integer ? Math.floor(upper) : upper;
+	return integer ? Math.ceil(lower ?? 0) : lower ?? 0;
+};
+const toTypeSample = (schema) => {
+	const type = schema.type?.find((item) => item !== "null") ?? schema.type?.[0];
+	if (type === "string") return formatSamples[schema.format ?? ""] ?? "string";
+	if (type === "integer" || type === "number") return toNumberSample(schema.constraints, type === "integer");
+	if (type === "boolean") return true;
+	if (type === "null") return null;
+};
+const mergeSamples = (previous, next) => {
+	if (!isObject(previous) || !isObject(next)) return next === void 0 ? previous : next;
+	const names = /* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(next)]);
+	return Object.fromEntries([...names].map((name) => [name, mergeSamples(previous[name], next[name])]));
+};
+/** Applies visibility to the combined sample, including nested fields from other branches. */
+const filterSample = (value, schema, model, mode, seen = []) => {
+	const target = resolveSchema(schema, model);
+	const hidden = mode === "request" ? "readOnly" : "writeOnly";
+	const path = schema.ref ? [...seen, schema.ref] : seen;
+	if (target?.[hidden]) return void 0;
+	if (!target || schema.ref && seen.includes(schema.ref)) return value;
+	let filtered = value;
+	for (const part of target.allOf ?? []) filtered = filterSample(filtered, part, model, mode, path);
+	if (Array.isArray(filtered) && target.items) {
+		const items = target.items;
+		return filtered.map((item) => filterSample(item, items, model, mode, path));
+	}
+	if (!isObject(filtered)) return filtered;
+	return Object.fromEntries(Object.entries(filtered).flatMap(([name, item]) => {
+		const property = target.properties?.find((property) => property.name === name);
+		const sample = property ? filterSample(item, property.schema, model, mode, path) : item;
+		return sample === void 0 ? [] : [[name, sample]];
+	}));
+};
+/**
+* Creates a sample value for a schema: its example, constant, default, or first enum value, or a
+* value from its type. Recursive schemas stop at their first repetition.
+*/
+const createSample = (schema, model, mode, seen = []) => {
+	if (schema.ref) {
+		const target = resolveSchema(schema, model);
+		if (!target || seen.includes(schema.ref) || seen.length >= maxDepth$1) return void 0;
+		return createSample(target, model, mode, [...seen, schema.ref]);
+	}
+	const value = [
+		schema.examples?.[0],
+		schema.const,
+		schema.default,
+		schema.enum?.[0]
+	].find((item) => item !== void 0);
+	if (value !== void 0) return value;
+	if (schema.allOf) {
+		const { allOf, ...own } = schema;
+		const sample = [...allOf, own].reduce((merged, part) => {
+			const sample = createSample(part, model, mode, seen);
+			return mergeSamples(merged, sample);
+		}, void 0);
+		return filterSample(sample, schema, model, mode);
+	}
+	const option = schema.oneOf?.[0] ?? schema.anyOf?.[0];
+	if (option) {
+		const { oneOf: _oneOf, anyOf: _anyOf, ...own } = schema;
+		return createSample({ allOf: [own, option] }, model, mode, seen);
+	}
+	if (schema.type?.includes("array") || schema.items) {
+		const item = schema.items && createSample(schema.items, model, mode, seen);
+		return item === void 0 ? [] : [item];
+	}
+	if (schema.type?.includes("object") || schema.properties) {
+		const hidden = mode === "request" ? "readOnly" : "writeOnly";
+		const entries = (schema.properties ?? []).flatMap(({ name, schema: property }) => {
+			const sample = resolveSchema(property, model)?.[hidden] ? void 0 : createSample(property, model, mode, seen);
+			return sample === void 0 ? [] : [[name, sample]];
+		});
+		return Object.fromEntries(entries);
+	}
+	return toTypeSample(schema);
+};
+//#endregion
+//#region src/sources/openapi/forms.ts
+const isJSON = (mediaType) => /^application\/(.+\+)?json\b/.test(mediaType ?? "");
+const isForm = (mediaType) => {
+	return mediaType === "application/x-www-form-urlencoded" || mediaType === "multipart/form-data";
+};
+const toFormEntries = (request) => {
+	const { body } = request;
+	return (typeof body === "object" && body !== null ? Object.entries(body) : []).flatMap(([name, value]) => {
+		const encoding = request.encoding?.[name];
+		if (request.mediaType === "application/x-www-form-urlencoded" || encoding?.style !== void 0 || encoding?.explode !== void 0) return toQueryEntries({
+			name,
+			...encoding
+		}, value).map(([name, value]) => ({
+			name,
+			value
+		}));
+		return (Array.isArray(value) ? value : [value]).map((item) => {
+			const contentType = encoding?.contentType ?? (typeof item === "object" && item !== null ? "application/json" : void 0);
+			return {
+				name,
+				value: typeof item === "string" && !isJSON(contentType) ? item : JSON.stringify(item),
+				contentType
+			};
+		});
+	});
+};
+//#endregion
+//#region src/sources/openapi/examples.ts
+const placeholderURL = "https://api.example.com";
+const placeholderFile = "path/to/file";
+const fileSetup = "const file = new File([\"<file content>\"], \"file\");";
+const aliases = {
+	shell: "curl",
+	bash: "curl",
+	sh: "curl",
+	js: "javascript",
+	node: "javascript",
+	py: "python"
+};
+const languages = {
+	"curl": "bash",
+	"javascript": "javascript",
+	"typescript": "typescript",
+	"ts": "typescript",
+	"python": "python",
+	"go": "go",
+	"golang": "go",
+	"ruby": "ruby",
+	"php": "php",
+	"java": "java",
+	"kotlin": "kotlin",
+	"csharp": "csharp",
+	"c#": "csharp",
+	"rust": "rust",
+	"swift": "swift"
+};
+const toJSON = (value) => JSON.stringify(value, null, 2);
+const quoteShell = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+const quoteForm = (value) => `"${value.replace(/[\\"]/g, "\\$&")}"`;
+const encodeQueryValue = (value) => encodeURIComponent(String(value));
+/** A parameter with `content` is one value in its media type, e.g. JSON, without a style. */
+const toContentValue = (parameter, value) => {
+	if (parameter.mediaType === void 0 || value === void 0) return void 0;
+	return isJSON(parameter.mediaType) ? JSON.stringify(value) : String(value);
+};
+/** Binary strings: `format: binary` in OpenAPI 3.0, or a media type without an encoding in 3.1. */
+const isBinary = (schema) => {
+	return schema?.format === "binary" || Boolean(schema?.contentMediaType && !schema.contentEncoding);
+};
+const isFile = (schema, model) => {
+	const target = resolveSchema(schema, model);
+	return isBinary(target) || isBinary(target?.items && resolveSchema(target.items, model));
+};
+/** The properties of an object schema, with those of its `allOf` parts. */
+const listProperties = (schema, model, seen = []) => {
+	const target = resolveSchema(schema, model);
+	const isRepeated = Boolean(schema.ref && seen.includes(schema.ref));
+	if (!target || isRepeated) return [];
+	const path = schema.ref ? [...seen, schema.ref] : seen;
+	return [...target.properties ?? [], ...(target.allOf ?? []).flatMap((part) => listProperties(part, model, path))];
+};
+/** Writes JSON values as Python literals. */
+const toPython = (value, indent = "") => {
+	const inner = `${indent}    `;
+	if (value === null || value === void 0) return "None";
+	if (value === true) return "True";
+	if (value === false) return "False";
+	if (typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) {
+		if (!value.length) return "[]";
+		return `[\n${value.map((item) => `${inner}${toPython(item, inner)}`).join(",\n")},\n${indent}]`;
+	}
+	const entries = Object.entries(value);
+	if (!entries.length) return "{}";
+	return `{\n${entries.map(([key, item]) => `${inner}${JSON.stringify(key)}: ${toPython(item, inner)}`).join(",\n")},\n${indent}}`;
+};
+const toBodyText = (request) => {
+	return !isJSON(request.mediaType) && typeof request.body === "string" ? request.body : toJSON(request.body);
+};
+const generators = {
+	curl: {
+		label: "cURL",
+		language: "bash",
+		generate: (request) => {
+			const lines = [`curl --request ${request.method.toUpperCase()}`, `--url ${quoteShell(request.url)}`];
+			request.headers.forEach(([name, value]) => {
+				lines.push(`--header ${quoteShell(`${name}: ${value}`)}`);
+			});
+			if (request.body !== void 0 && request.mediaType === "multipart/form-data") toFormEntries(request).forEach(({ name, value, contentType }) => {
+				const isFile = request.files.includes(name);
+				const part = isFile ? `@${placeholderFile}` : quoteForm(value);
+				const type = contentType ? `;type=${contentType}` : "";
+				lines.push(isFile || contentType ? `--form ${quoteShell(`${name}=${part}${type}`)}` : `--form-string ${quoteShell(`${name}=${value}`)}`);
+			});
+			else if (request.body !== void 0 && isForm(request.mediaType)) toFormEntries(request).forEach(({ name, value }) => {
+				lines.push(`--data-urlencode ${quoteShell(`${name}=${value}`)}`);
+			});
+			else if (request.isFileBody) lines.push(`--data-binary ${quoteShell(`@${placeholderFile}`)}`);
+			else if (request.body !== void 0) lines.push(`--data-raw ${quoteShell(toBodyText(request))}`);
+			return lines.join(" \\\n  ");
+		}
+	},
+	javascript: {
+		label: "JavaScript",
+		language: "javascript",
+		generate: (request) => {
+			const headers = request.headers.filter(([name]) => {
+				return !(request.mediaType === "multipart/form-data" && name === "Content-Type");
+			});
+			const options = [`  method: ${JSON.stringify(request.method.toUpperCase())}`];
+			const setup = [];
+			if (headers.length) {
+				const entries = headers.map(([name, value]) => `    ${JSON.stringify(name)}: ${JSON.stringify(value)}`);
+				options.push(`  headers: {\n${entries.join(",\n")}\n  }`);
+			}
+			if (request.body !== void 0 && isForm(request.mediaType)) {
+				const form = request.mediaType === "multipart/form-data" ? "FormData" : "URLSearchParams";
+				if (request.files.length) setup.push(fileSetup);
+				setup.push(`const body = new ${form}();`);
+				toFormEntries(request).forEach(({ name, value, contentType }) => {
+					const isFile = request.files.includes(name);
+					const item = isFile ? "file" : JSON.stringify(value);
+					const part = contentType ? `new Blob([${item}], { type: ${JSON.stringify(contentType)} })` : item;
+					const filename = contentType ? isFile ? ", file.name" : ", \"\"" : "";
+					setup.push(`body.append(${JSON.stringify(name)}, ${part}${filename});`);
+				});
+				options.push("  body");
+			} else if (request.isFileBody) {
+				setup.push(fileSetup);
+				options.push("  body: file");
+			} else if (request.body !== void 0) {
+				const body = isJSON(request.mediaType) ? `JSON.stringify(${toJSON(request.body).replaceAll("\n", "\n  ")})` : JSON.stringify(toBodyText(request));
+				options.push(`  body: ${body}`);
+			}
+			return [
+				...setup.length ? [setup.join("\n"), ""] : [],
+				`const response = await fetch(${JSON.stringify(request.url)}, {\n${options.join(",\n")}\n});`,
+				...request.response ? ["", `const data = await response.${request.response}();`] : []
+			].join("\n");
+		}
+	},
+	python: {
+		label: "Python",
+		language: "python",
+		generate: (request) => {
+			const headers = request.headers.filter(([name]) => {
+				return request.mediaType !== "multipart/form-data" || name !== "Content-Type";
+			});
+			const method = request.method.toLowerCase();
+			const isTrace = method === "trace";
+			const args = [...isTrace ? ["    \"TRACE\""] : [], `    ${JSON.stringify(request.url)}`];
+			if (headers.length) args.push(`    headers=${toPython(Object.fromEntries(headers), "    ")}`);
+			if (request.body !== void 0 && isJSON(request.mediaType)) args.push(request.body === null ? "    data=\"null\"" : `    json=${toPython(request.body, "    ")}`);
+			else if (request.body !== void 0 && request.mediaType === "multipart/form-data") {
+				const files = toFormEntries(request).map(({ name, value, contentType }) => {
+					const isFile = request.files.includes(name);
+					const item = isFile ? `open(${JSON.stringify(placeholderFile)}, "rb")` : JSON.stringify(value);
+					const part = `(${isFile ? "\"file\"" : "None"}, ${item}${contentType ? `, ${JSON.stringify(contentType)}` : ""})`;
+					return `        (${JSON.stringify(name)}, ${part}),`;
+				});
+				if (files.length) args.push(`    files=[\n${files.join("\n")}\n    ]`);
+			} else if (request.isFileBody) args.push(`    data=open(${JSON.stringify(placeholderFile)}, "rb")`);
+			else if (request.body !== void 0) {
+				const body = isForm(request.mediaType) ? toPython(toFormEntries(request).map(({ name, value }) => [name, value]), "    ") : JSON.stringify(toBodyText(request));
+				args.push(`    data=${body}`);
+			}
+			const output = {
+				json: "response.json()",
+				text: "response.text",
+				none: "response.status_code"
+			}[request.response ?? "none"];
+			return [
+				"import requests",
+				"",
+				`response = requests.${isTrace ? "request" : method}(\n${args.join(",\n")},\n)`,
+				"",
+				`print(${output})`
+			].join("\n");
+		}
+	}
+};
+/**
+* Adds placeholders for the schemes of the first security requirement, which all apply. A request
+* has one `Authorization` header, so only the first scheme that uses it adds it.
+*/
+const addCredentials = (operation, model, headers, query, cookies) => {
+	const setHeader = (name, value) => {
+		const index = headers.findIndex(([item]) => item.toLowerCase() === name.toLowerCase());
+		if (index === -1) headers.push([name, value]);
+		else headers[index] = [name, value];
+	};
+	const setAuthorization = (value) => {
+		if (!headers.some(([name]) => name === "Authorization")) headers.push(["Authorization", value]);
+	};
+	Object.keys(operation.security[0] ?? {}).forEach((id) => {
+		const scheme = model.securitySchemes.find((item) => item.id === id);
+		const httpScheme = scheme?.scheme?.toLowerCase();
+		const usesToken = scheme?.type === "oauth2" || scheme?.type === "openIdConnect";
+		if (scheme?.type === "http" && httpScheme === "basic") setAuthorization("Basic <credentials>");
+		else if (usesToken || scheme?.type === "http" && httpScheme === "bearer") setAuthorization("Bearer <token>");
+		else if (scheme?.type === "http" && scheme.scheme) {
+			const name = `${scheme.scheme[0].toUpperCase()}${scheme.scheme.slice(1)}`;
+			setAuthorization(`${name} <credentials>`);
+		} else if (scheme?.type === "apiKey" && scheme.name && scheme.in === "header") setHeader(scheme.name, "<api-key>");
+		else if (scheme?.type === "apiKey" && scheme.name && scheme.in === "query") query.set(scheme.name, [encodeQueryValue("<api-key>")]);
+		else if (scheme?.type === "apiKey" && scheme.name && scheme.in === "cookie") cookies.set(scheme.name, "<api-key>");
+	});
+};
+/**
+* Creates the sample request of an operation: path values, required query, header, and cookie
+* values, and parameters with examples, credential placeholders, and a body from examples or the
+* schema.
+*/
+const createRequestSample = (operation, model) => {
+	const headers = [];
+	const query = /* @__PURE__ */ new Map();
+	const cookies = /* @__PURE__ */ new Map();
+	const media = operation.requestBody?.contents[0];
+	const isMultipart = media?.type === "multipart/form-data";
+	const isFileBody = Boolean(media?.schema && !isForm(media.type) && isFile(media.schema, model));
+	const files = (isMultipart && media.schema ? listProperties(media.schema, model) : []).filter((property) => isFile(property.schema, model)).map((property) => property.name);
+	const responseMedia = (operation.responses.find((response) => response.status.startsWith("2")) ?? operation.responses.find((response) => response.status === "default"))?.contents[0];
+	const server = (operation.servers[0]?.url ?? placeholderURL).replace(/\/$/, "");
+	const toValue = (parameter) => {
+		const example = parameter.examples[0]?.value;
+		return example === void 0 ? parameter.schema && createSample(parameter.schema, model, "request") : example;
+	};
+	let path = operation.path;
+	operation.parameters.forEach((parameter) => {
+		const value = toValue(parameter);
+		const isShown = parameter.required || parameter.examples.length > 0;
+		const content = toContentValue(parameter, value);
+		if (parameter.in === "path") {
+			const text = content === void 0 ? toPathValue(parameter, value === void 0 ? parameter.name : value) : encodeURIComponent(content);
+			path = path.replace(`{${parameter.name}}`, text);
+		} else if (parameter.in === "query" && isShown && value !== void 0) (content === void 0 ? toQueryEntries(parameter, value, encodeQueryValue) : [[parameter.name, encodeQueryValue(content)]]).forEach(([name, item]) => query.set(name, [...query.get(name) ?? [], item]));
+		else if (parameter.in === "header" && isShown && value !== void 0) headers.push([parameter.name, content ?? toSimpleStyleValue(parameter, value)]);
+		else if (parameter.in === "cookie" && isShown && value !== void 0) cookies.set(parameter.name, encodeURIComponent(content ?? toSimpleValue(value)));
+	});
+	addCredentials(operation, model, headers, query, cookies);
+	if (cookies.size) headers.push(["Cookie", [...cookies].map(([name, value]) => `${name}=${value}`).join("; ")]);
+	const example = media?.examples[0]?.value;
+	const body = example === void 0 ? media?.schema && createSample(media.schema, model, "request") : example;
+	const queryString = [...query].flatMap(([name, values]) => values.map((value) => `${encodeQueryValue(name)}=${value}`)).join("&");
+	const search = queryString ? `?${queryString}` : "";
+	if (media && body !== void 0) headers.push(["Content-Type", media.type]);
+	return {
+		method: operation.method,
+		url: `${server}${path}${search}`,
+		headers,
+		mediaType: media?.type,
+		encoding: media?.encoding,
+		body,
+		files,
+		isFileBody,
+		response: responseMedia && (isJSON(responseMedia.type) ? "json" : "text")
+	};
+};
+/**
+* Lists the request examples of an operation: cURL, JavaScript, and Python, where a code sample
+* from `x-codeSamples` with the same language replaces the generated one. Other samples follow.
+*/
+const createCodeExamples = (operation, model) => {
+	const request = createRequestSample(operation, model);
+	const samples = operation.codeSamples.map((sample) => {
+		const lang = sample.lang.toLowerCase();
+		const id = aliases[lang] ?? lang;
+		return {
+			id,
+			label: sample.label,
+			language: languages[id] ?? languages[lang] ?? "text",
+			code: sample.source
+		};
+	});
+	const generated = Object.entries(generators).map(([id, generator]) => {
+		return samples.find((sample) => sample.id === id) ?? {
+			id,
+			label: generator.label,
+			language: generator.language,
+			code: generator.generate(request)
+		};
+	});
+	const counts = /* @__PURE__ */ new Map();
+	return [...generated, ...samples.filter((sample) => !generated.includes(sample))].map((example) => {
+		const count = (counts.get(example.label) ?? 0) + 1;
+		counts.set(example.label, count);
+		return count > 1 ? {
+			...example,
+			label: `${example.label} ${count}`
+		} : example;
+	});
+};
+//#endregion
+//#region src/sources/openapi/fields.ts
+const maxDepth = 12;
+const descriptions = /* @__PURE__ */ new Map();
+const toID = (value) => value.replace(/[^\w-]+/g, "-");
+/** Removes the IDs of headings, which could repeat the IDs of operation sections. */
+const removeHeadingIDs = (node) => {
+	node.children.forEach((child) => {
+		if (child.type !== "element") return;
+		if (/^h[1-6]$/.test(child.tagName)) delete child.properties.id;
+		removeHeadingIDs(child);
+	});
+	return node;
+};
+const toHTML = (markdown, highlight) => {
+	if (!markdown) return void 0;
+	if (!descriptions.has(markdown)) descriptions.set(markdown, prepareMarkdown(markdown, highlight).then(({ nodes }) => toHtml(removeHeadingIDs(nodes))));
+	return descriptions.get(markdown);
+};
+/** Merges fields that `allOf` parts repeat, e.g. a part that makes a base field read-only. */
+const mergeFields = (fields) => {
+	const merged = /* @__PURE__ */ new Map();
+	fields.forEach((field) => {
+		const previous = merged.get(field.name);
+		if (!previous) {
+			merged.set(field.name, field);
+			return;
+		}
+		merged.set(field.name, {
+			...previous,
+			type: field.type === "any" ? previous.type : field.type,
+			required: previous.required || field.required,
+			deprecated: previous.deprecated || field.deprecated,
+			readOnly: previous.readOnly || field.readOnly,
+			writeOnly: previous.writeOnly || field.writeOnly,
+			description: field.description ?? previous.description,
+			facts: [...new Map([...previous.facts, ...field.facts].map((fact) => [fact.label, fact])).values()],
+			fields: mergeFields([...previous.fields, ...field.fields]),
+			variants: [...previous.variants, ...field.variants],
+			recursive: previous.recursive ?? field.recursive
+		});
+	});
+	return [...merged.values()];
+};
+/** Builds field trees of schemas. A field that repeats a schema that contains it links to it. */
+const createFieldBuilder = (model, highlight) => {
+	const expand = async (schema, id, ancestors, depth, required = /* @__PURE__ */ new Set()) => {
+		const ancestor = schema.ref && ancestors.find((item) => item.ref === schema.ref);
+		if (ancestor) return {
+			fields: [],
+			variants: [],
+			recursive: {
+				name: ancestor.ref,
+				href: `#${ancestor.id}`
+			}
+		};
+		const target = resolveSchema(schema, model);
+		const path = schema.ref ? [...ancestors, {
+			ref: schema.ref,
+			id
+		}] : ancestors;
+		const requiredNames = /* @__PURE__ */ new Set([...required, ...getRequiredNames(schema, model)]);
+		if (!target || depth > maxDepth) return {
+			fields: [],
+			variants: []
+		};
+		const fields = await Promise.all((target.properties ?? []).map((property) => {
+			return toField(property.name, property.required || requiredNames.has(property.name), property.schema, `${id}-${toID(property.name)}`, path, depth);
+		}));
+		const variants = [];
+		if (typeof target.additionalProperties === "object") fields.push(await toField("{key}", false, target.additionalProperties, `${id}-key`, path, depth));
+		let recursive;
+		if (target.items) {
+			const nested = await expand(target.items, id, path, depth);
+			fields.push(...nested.fields);
+			variants.push(...nested.variants);
+			recursive = nested.recursive;
+		}
+		for (const part of target.allOf ?? []) {
+			const nested = await expand(part, id, path, depth, requiredNames);
+			fields.push(...nested.fields);
+			variants.push(...nested.variants);
+			recursive ??= nested.recursive;
+		}
+		for (const kind of ["oneOf", "anyOf"]) {
+			const options = await Promise.all((target[kind] ?? []).map(async (option, index) => {
+				const optionID = `${id}-${kind}-${index + 1}`;
+				const nested = await expand(option, optionID, path, depth + 1, requiredNames);
+				const optionTarget = resolveSchemaDetails(option, model);
+				return {
+					id: optionID,
+					label: option.ref ?? option.title ?? `Option ${index + 1}`,
+					kind,
+					type: toTypeLabel(optionTarget ?? option),
+					description: await toHTML(optionTarget?.description, highlight),
+					facts: optionTarget ? toFacts(optionTarget) : [],
+					fields: nested.fields,
+					variants: nested.variants
+				};
+			}));
+			variants.push(...options);
+		}
+		return {
+			fields: mergeFields(fields),
+			variants,
+			recursive
+		};
+	};
+	const toField = async (name, required, schema, id, ancestors, depth) => {
+		const target = resolveSchemaDetails(schema, model);
+		const nested = await expand(schema, id, ancestors, depth + 1);
+		return {
+			id,
+			name,
+			type: toTypeLabel(schema.ref ? schema : target ?? schema),
+			required,
+			deprecated: Boolean(target?.deprecated),
+			readOnly: Boolean(target?.readOnly),
+			writeOnly: Boolean(target?.writeOnly),
+			description: await toHTML(target?.description, highlight),
+			facts: target ? toFacts(target) : [],
+			...nested
+		};
+	};
+	const toMedia = async (media, id) => {
+		const schema = media.schema ? await toField("Body", false, media.schema, `${id}-schema`, [], 0) : void 0;
+		if (schema && media.schema) schema.type = toTypeLabel(resolveSchemaDetails(media.schema, model) ?? media.schema);
+		return {
+			id,
+			type: media.type,
+			schema
+		};
+	};
+	return {
+		toField,
+		toMedia
+	};
+};
+//#endregion
+//#region src/sources/openapi/view.ts
+const locations = [
+	["path", "Path parameters"],
+	["query", "Query parameters"],
+	["header", "Headers"],
+	["cookie", "Cookies"]
+];
+const toPlainText = (value = "") => value.replace(/[^\p{L}\p{N}]+/gu, "").toLowerCase();
+const toCodeView = async (label, language, code, highlight) => {
+	const pre = await highlightCode(code, language, highlight);
+	return {
+		label,
+		language,
+		code,
+		html: toHtml(pre.children)
+	};
+};
+const toResponseExample = async (media, label, model, highlight) => {
+	const example = media?.examples[0]?.value;
+	const value = example === void 0 ? media?.schema && createSample(media.schema, model, "response") : example;
+	if (value === void 0) return void 0;
+	const json = isJSON(media?.type) || typeof value !== "string";
+	return toCodeView(label, json ? "json" : "text", json ? JSON.stringify(value, null, 2) : String(value), highlight);
+};
+/**
+* Resolves an operation for the template: HTML descriptions, field trees with anchors,
+* highlighted request examples, and response examples.
+*/
+const createOperationView = async (operation, model, options) => {
+	const { highlight, anchor = "" } = options;
+	const builder = createFieldBuilder(model, highlight);
+	const show = (part) => {
+		return options.parts?.[part] ?? (part !== "examples" || options.anchor === void 0);
+	};
+	const body = show("requestBody") ? operation.requestBody : void 0;
+	const toParameter = async (parameter, id) => {
+		const field = await builder.toField(parameter.name, parameter.required, parameter.schema ?? {}, id, [], 0);
+		const description = await toHTML(parameter.description, highlight);
+		return {
+			...field,
+			deprecated: field.deprecated || parameter.deprecated,
+			description: description ?? field.description
+		};
+	};
+	const parameters = await Promise.all((show("parameters") ? locations : []).map(([location, label]) => {
+		return {
+			location,
+			label,
+			items: operation.parameters.filter((parameter) => parameter.in === location)
+		};
+	}).filter((group) => group.items.length).map(async ({ location, label, items }) => {
+		const id = `${anchor}${location}`;
+		return {
+			id,
+			label,
+			fields: await Promise.all(items.map((parameter) => toParameter(parameter, `${id}-${toID(parameter.name)}`)))
+		};
+	}));
+	const responses = await Promise.all((show("responses") ? operation.responses : []).map(async (response) => {
+		const id = `${anchor}response-${toID(response.status)}`;
+		const label = toStatusLabel(response.status);
+		const isRepeated = [response.status, label].some((text) => {
+			return toPlainText(text) === toPlainText(response.description);
+		});
+		return {
+			id,
+			status: response.status,
+			label,
+			description: isRepeated ? void 0 : await toHTML(response.description, highlight),
+			headers: await Promise.all(response.headers.map(async (header) => {
+				const field = await builder.toField(header.name, header.required, header.schema ?? {}, `${id}-header-${toID(header.name)}`, [], 0);
+				const description = await toHTML(header.description, highlight);
+				return {
+					...field,
+					description: description ?? field.description
+				};
+			})),
+			contents: await Promise.all(response.contents.map((media, index) => {
+				return builder.toMedia(media, index ? `${id}-${index + 1}` : `${id}-body`);
+			}))
+		};
+	}));
+	const examples = await Promise.all((show("examples") ? createCodeExamples(operation, model) : []).map((example) => {
+		return toCodeView(example.label, example.language, example.code, highlight);
+	}));
+	const responseExamples = await Promise.all((show("examples") ? operation.responses : []).map((response) => {
+		return toResponseExample(response.contents[0], response.status, model, highlight);
+	}));
+	return {
+		anchor,
+		embedded: options.anchor !== void 0,
+		title: options.title,
+		href: options.href,
+		method: operation.method,
+		path: operation.path,
+		deprecated: operation.deprecated,
+		description: show("description") ? await toHTML(operation.description, highlight) : void 0,
+		servers: await Promise.all(operation.servers.map(async (server) => {
+			return {
+				url: server.url,
+				description: await toHTML(server.description, highlight)
+			};
+		})),
+		security: await Promise.all((show("authentication") ? operation.security : []).map((requirement) => {
+			return Promise.all(Object.entries(requirement).map(async ([id, scopes]) => {
+				const scheme = model.securitySchemes.find((item) => item.id === id);
+				return {
+					id,
+					label: scheme ? toSchemeLabel(scheme) : id,
+					description: await toHTML(scheme?.description, highlight),
+					scopes
+				};
+			}));
+		})),
+		parameters,
+		requestBody: body && {
+			id: `${anchor}request-body`,
+			required: body.required,
+			description: await toHTML(body.description, highlight),
+			contents: await Promise.all(body.contents.map((media, index) => {
+				return builder.toMedia(media, index ? `${anchor}body-${index + 1}` : `${anchor}body`);
+			}))
+		},
+		responses,
+		examples,
+		responseExamples: responseExamples.filter((example) => Boolean(example))
+	};
+};
+//#endregion
+export { toID as n, createOperationView as t };
+
+//# sourceMappingURL=view-C-9ZM1zK.js.map