fumadocs-openapi 10.6.8 → 10.7.0

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/resolve-flow-collection.js

@@ -0,0 +1,153 @@
+import { isPair } from "../nodes/identity.js";
+import { Pair } from "../nodes/Pair.js";
+import { YAMLMap } from "../nodes/YAMLMap.js";
+import { YAMLSeq } from "../nodes/YAMLSeq.js";
+import { resolveProps } from "./resolve-props.js";
+import { containsNewline } from "./util-contains-newline.js";
+import { mapIncludes } from "./util-map-includes.js";
+import { resolveEnd } from "./resolve-end.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/resolve-flow-collection.js
+const blockMsg = "Block collections are not allowed within flow collections";
+const isBlock = (token) => token && (token.type === "block-map" || token.type === "block-seq");
+function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError, tag) {
+	const isMap = fc.start.source === "{";
+	const fcName = isMap ? "flow map" : "flow sequence";
+	const coll = new (tag?.nodeClass ?? (isMap ? YAMLMap : YAMLSeq))(ctx.schema);
+	coll.flow = true;
+	const atRoot = ctx.atRoot;
+	if (atRoot) ctx.atRoot = false;
+	if (ctx.atKey) ctx.atKey = false;
+	let offset = fc.offset + fc.start.source.length;
+	for (let i = 0; i < fc.items.length; ++i) {
+		const collItem = fc.items[i];
+		const { start, key, sep, value } = collItem;
+		const props = resolveProps(start, {
+			flow: fcName,
+			indicator: "explicit-key-ind",
+			next: key ?? sep?.[0],
+			offset,
+			onError,
+			parentIndent: fc.indent,
+			startOnNewline: false
+		});
+		if (!props.found) {
+			if (!props.anchor && !props.tag && !sep && !value) {
+				if (i === 0 && props.comma) onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
+				else if (i < fc.items.length - 1) onError(props.start, "UNEXPECTED_TOKEN", `Unexpected empty item in ${fcName}`);
+				if (props.comment) if (coll.comment) coll.comment += "\n" + props.comment;
+				else coll.comment = props.comment;
+				offset = props.end;
+				continue;
+			}
+			if (!isMap && ctx.options.strict && containsNewline(key)) onError(key, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
+		}
+		if (i === 0) {
+			if (props.comma) onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
+		} else {
+			if (!props.comma) onError(props.start, "MISSING_CHAR", `Missing , between ${fcName} items`);
+			if (props.comment) {
+				let prevItemComment = "";
+				loop: for (const st of start) switch (st.type) {
+					case "comma":
+					case "space": break;
+					case "comment":
+						prevItemComment = st.source.substring(1);
+						break loop;
+					default: break loop;
+				}
+				if (prevItemComment) {
+					let prev = coll.items[coll.items.length - 1];
+					if (isPair(prev)) prev = prev.value ?? prev.key;
+					if (prev.comment) prev.comment += "\n" + prevItemComment;
+					else prev.comment = prevItemComment;
+					props.comment = props.comment.substring(prevItemComment.length + 1);
+				}
+			}
+		}
+		if (!isMap && !sep && !props.found) {
+			const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep, null, props, onError);
+			coll.items.push(valueNode);
+			offset = valueNode.range[2];
+			if (isBlock(value)) onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
+		} else {
+			ctx.atKey = true;
+			const keyStart = props.end;
+			const keyNode = key ? composeNode(ctx, key, props, onError) : composeEmptyNode(ctx, keyStart, start, null, props, onError);
+			if (isBlock(key)) onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
+			ctx.atKey = false;
+			const valueProps = resolveProps(sep ?? [], {
+				flow: fcName,
+				indicator: "map-value-ind",
+				next: value,
+				offset: keyNode.range[2],
+				onError,
+				parentIndent: fc.indent,
+				startOnNewline: false
+			});
+			if (valueProps.found) {
+				if (!isMap && !props.found && ctx.options.strict) {
+					if (sep) for (const st of sep) {
+						if (st === valueProps.found) break;
+						if (st.type === "newline") {
+							onError(st, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
+							break;
+						}
+					}
+					if (props.start < valueProps.found.offset - 1024) onError(valueProps.found, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit flow sequence key");
+				}
+			} else if (value) if ("source" in value && value.source?.[0] === ":") onError(value, "MISSING_CHAR", `Missing space after : in ${fcName}`);
+			else onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
+			const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep, null, valueProps, onError) : null;
+			if (valueNode) {
+				if (isBlock(value)) onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
+			} else if (valueProps.comment) if (keyNode.comment) keyNode.comment += "\n" + valueProps.comment;
+			else keyNode.comment = valueProps.comment;
+			const pair = new Pair(keyNode, valueNode);
+			if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
+			if (isMap) {
+				const map = coll;
+				if (mapIncludes(ctx, map.items, keyNode)) onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
+				map.items.push(pair);
+			} else {
+				const map = new YAMLMap(ctx.schema);
+				map.flow = true;
+				map.items.push(pair);
+				const endRange = (valueNode ?? keyNode).range;
+				map.range = [
+					keyNode.range[0],
+					endRange[1],
+					endRange[2]
+				];
+				coll.items.push(map);
+			}
+			offset = valueNode ? valueNode.range[2] : valueProps.end;
+		}
+	}
+	const expectedEnd = isMap ? "}" : "]";
+	const [ce, ...ee] = fc.end;
+	let cePos = offset;
+	if (ce?.source === expectedEnd) cePos = ce.offset + ce.source.length;
+	else {
+		const name = fcName[0].toUpperCase() + fcName.substring(1);
+		const msg = atRoot ? `${name} must end with a ${expectedEnd}` : `${name} in block collection must be sufficiently indented and end with a ${expectedEnd}`;
+		onError(offset, atRoot ? "MISSING_CHAR" : "BAD_INDENT", msg);
+		if (ce && ce.source.length !== 1) ee.unshift(ce);
+	}
+	if (ee.length > 0) {
+		const end = resolveEnd(ee, cePos, ctx.options.strict, onError);
+		if (end.comment) if (coll.comment) coll.comment += "\n" + end.comment;
+		else coll.comment = end.comment;
+		coll.range = [
+			fc.offset,
+			cePos,
+			end.offset
+		];
+	} else coll.range = [
+		fc.offset,
+		cePos,
+		cePos
+	];
+	return coll;
+}
+//#endregion
+export { resolveFlowCollection };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/resolve-flow-scalar.js

@@ -0,0 +1,204 @@
+import { Scalar } from "../nodes/Scalar.js";
+import { resolveEnd } from "./resolve-end.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/resolve-flow-scalar.js
+function resolveFlowScalar(scalar, strict, onError) {
+	const { offset, type, source, end } = scalar;
+	let _type;
+	let value;
+	const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
+	switch (type) {
+		case "scalar":
+			_type = Scalar.PLAIN;
+			value = plainValue(source, _onError);
+			break;
+		case "single-quoted-scalar":
+			_type = Scalar.QUOTE_SINGLE;
+			value = singleQuotedValue(source, _onError);
+			break;
+		case "double-quoted-scalar":
+			_type = Scalar.QUOTE_DOUBLE;
+			value = doubleQuotedValue(source, _onError);
+			break;
+		default:
+			onError(scalar, "UNEXPECTED_TOKEN", `Expected a flow scalar value, but found: ${type}`);
+			return {
+				value: "",
+				type: null,
+				comment: "",
+				range: [
+					offset,
+					offset + source.length,
+					offset + source.length
+				]
+			};
+	}
+	const valueEnd = offset + source.length;
+	const re = resolveEnd(end, valueEnd, strict, onError);
+	return {
+		value,
+		type: _type,
+		comment: re.comment,
+		range: [
+			offset,
+			valueEnd,
+			re.offset
+		]
+	};
+}
+function plainValue(source, onError) {
+	let badChar = "";
+	switch (source[0]) {
+		case "	":
+			badChar = "a tab character";
+			break;
+		case ",":
+			badChar = "flow indicator character ,";
+			break;
+		case "%":
+			badChar = "directive indicator character %";
+			break;
+		case "|":
+		case ">":
+			badChar = `block scalar indicator ${source[0]}`;
+			break;
+		case "@":
+		case "`":
+			badChar = `reserved character ${source[0]}`;
+			break;
+	}
+	if (badChar) onError(0, "BAD_SCALAR_START", `Plain value cannot start with ${badChar}`);
+	return foldLines(source);
+}
+function singleQuotedValue(source, onError) {
+	if (source[source.length - 1] !== "'" || source.length === 1) onError(source.length, "MISSING_CHAR", "Missing closing 'quote");
+	return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+}
+function foldLines(source) {
+	/**
+	* The negative lookbehind here and in the `re` RegExp is to
+	* prevent causing a polynomial search time in certain cases.
+	*
+	* The try-catch is for Safari, which doesn't support this yet:
+	* https://caniuse.com/js-regexp-lookbehind
+	*/
+	let first, line;
+	try {
+		first = /* @__PURE__ */ new RegExp("(.*?)(?<![ 	])[ 	]*\r?\n", "sy");
+		line = /* @__PURE__ */ new RegExp("[ 	]*(.*?)(?:(?<![ 	])[ 	]*)?\r?\n", "sy");
+	} catch {
+		first = /(.*?)[ \t]*\r?\n/sy;
+		line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+	}
+	let match = first.exec(source);
+	if (!match) return source;
+	let res = match[1];
+	let sep = " ";
+	let pos = first.lastIndex;
+	line.lastIndex = pos;
+	while (match = line.exec(source)) {
+		if (match[1] === "") if (sep === "\n") res += sep;
+		else sep = "\n";
+		else {
+			res += sep + match[1];
+			sep = " ";
+		}
+		pos = line.lastIndex;
+	}
+	const last = /[ \t]*(.*)/sy;
+	last.lastIndex = pos;
+	match = last.exec(source);
+	return res + sep + (match?.[1] ?? "");
+}
+function doubleQuotedValue(source, onError) {
+	let res = "";
+	for (let i = 1; i < source.length - 1; ++i) {
+		const ch = source[i];
+		if (ch === "\r" && source[i + 1] === "\n") continue;
+		if (ch === "\n") {
+			const { fold, offset } = foldNewline(source, i);
+			res += fold;
+			i = offset;
+		} else if (ch === "\\") {
+			let next = source[++i];
+			const cc = escapeCodes[next];
+			if (cc) res += cc;
+			else if (next === "\n") {
+				next = source[i + 1];
+				while (next === " " || next === "	") next = source[++i + 1];
+			} else if (next === "\r" && source[i + 1] === "\n") {
+				next = source[++i + 1];
+				while (next === " " || next === "	") next = source[++i + 1];
+			} else if (next === "x" || next === "u" || next === "U") {
+				const length = {
+					x: 2,
+					u: 4,
+					U: 8
+				}[next];
+				res += parseCharCode(source, i + 1, length, onError);
+				i += length;
+			} else {
+				const raw = source.substr(i - 1, 2);
+				onError(i - 1, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
+				res += raw;
+			}
+		} else if (ch === " " || ch === "	") {
+			const wsStart = i;
+			let next = source[i + 1];
+			while (next === " " || next === "	") next = source[++i + 1];
+			if (next !== "\n" && !(next === "\r" && source[i + 2] === "\n")) res += i > wsStart ? source.slice(wsStart, i + 1) : ch;
+		} else res += ch;
+	}
+	if (source[source.length - 1] !== "\"" || source.length === 1) onError(source.length, "MISSING_CHAR", "Missing closing \"quote");
+	return res;
+}
+/**
+* Fold a single newline into a space, multiple newlines to N - 1 newlines.
+* Presumes `source[offset] === '\n'`
+*/
+function foldNewline(source, offset) {
+	let fold = "";
+	let ch = source[offset + 1];
+	while (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+		if (ch === "\r" && source[offset + 2] !== "\n") break;
+		if (ch === "\n") fold += "\n";
+		offset += 1;
+		ch = source[offset + 1];
+	}
+	if (!fold) fold = " ";
+	return {
+		fold,
+		offset
+	};
+}
+const escapeCodes = {
+	"0": "\0",
+	a: "\x07",
+	b: "\b",
+	e: "\x1B",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	",
+	v: "\v",
+	N: "…",
+	_: "\xA0",
+	L: "\u2028",
+	P: "\u2029",
+	" ": " ",
+	"\"": "\"",
+	"/": "/",
+	"\\": "\\",
+	"	": "	"
+};
+function parseCharCode(source, offset, length, onError) {
+	const cc = source.substr(offset, length);
+	const code = cc.length === length && /^[0-9a-fA-F]+$/.test(cc) ? parseInt(cc, 16) : NaN;
+	if (isNaN(code)) {
+		const raw = source.substr(offset - 2, length + 2);
+		onError(offset - 2, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
+		return raw;
+	}
+	return String.fromCodePoint(code);
+}
+//#endregion
+export { resolveFlowScalar };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/resolve-props.js

@@ -0,0 +1,105 @@
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/resolve-props.js
+function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIndent, startOnNewline }) {
+	let spaceBefore = false;
+	let atNewline = startOnNewline;
+	let hasSpace = startOnNewline;
+	let comment = "";
+	let commentSep = "";
+	let hasNewline = false;
+	let reqSpace = false;
+	let tab = null;
+	let anchor = null;
+	let tag = null;
+	let newlineAfterProp = null;
+	let comma = null;
+	let found = null;
+	let start = null;
+	for (const token of tokens) {
+		if (reqSpace) {
+			if (token.type !== "space" && token.type !== "newline" && token.type !== "comma") onError(token.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space");
+			reqSpace = false;
+		}
+		if (tab) {
+			if (atNewline && token.type !== "comment" && token.type !== "newline") onError(tab, "TAB_AS_INDENT", "Tabs are not allowed as indentation");
+			tab = null;
+		}
+		switch (token.type) {
+			case "space":
+				if (!flow && (indicator !== "doc-start" || next?.type !== "flow-collection") && token.source.includes("	")) tab = token;
+				hasSpace = true;
+				break;
+			case "comment": {
+				if (!hasSpace) onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
+				const cb = token.source.substring(1) || " ";
+				if (!comment) comment = cb;
+				else comment += commentSep + cb;
+				commentSep = "";
+				atNewline = false;
+				break;
+			}
+			case "newline":
+				if (atNewline) {
+					if (comment) comment += token.source;
+					else if (!found || indicator !== "seq-item-ind") spaceBefore = true;
+				} else commentSep += token.source;
+				atNewline = true;
+				hasNewline = true;
+				if (anchor || tag) newlineAfterProp = token;
+				hasSpace = true;
+				break;
+			case "anchor":
+				if (anchor) onError(token, "MULTIPLE_ANCHORS", "A node can have at most one anchor");
+				if (token.source.endsWith(":")) onError(token.offset + token.source.length - 1, "BAD_ALIAS", "Anchor ending in : is ambiguous", true);
+				anchor = token;
+				start ?? (start = token.offset);
+				atNewline = false;
+				hasSpace = false;
+				reqSpace = true;
+				break;
+			case "tag":
+				if (tag) onError(token, "MULTIPLE_TAGS", "A node can have at most one tag");
+				tag = token;
+				start ?? (start = token.offset);
+				atNewline = false;
+				hasSpace = false;
+				reqSpace = true;
+				break;
+			case indicator:
+				if (anchor || tag) onError(token, "BAD_PROP_ORDER", `Anchors and tags must be after the ${token.source} indicator`);
+				if (found) onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.source} in ${flow ?? "collection"}`);
+				found = token;
+				atNewline = indicator === "seq-item-ind" || indicator === "explicit-key-ind";
+				hasSpace = false;
+				break;
+			case "comma": if (flow) {
+				if (comma) onError(token, "UNEXPECTED_TOKEN", `Unexpected , in ${flow}`);
+				comma = token;
+				atNewline = false;
+				hasSpace = false;
+				break;
+			}
+			default:
+				onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.type} token`);
+				atNewline = false;
+				hasSpace = false;
+		}
+	}
+	const last = tokens[tokens.length - 1];
+	const end = last ? last.offset + last.source.length : offset;
+	if (reqSpace && next && next.type !== "space" && next.type !== "newline" && next.type !== "comma" && (next.type !== "scalar" || next.source !== "")) onError(next.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space");
+	if (tab && (atNewline && tab.indent <= parentIndent || next?.type === "block-map" || next?.type === "block-seq")) onError(tab, "TAB_AS_INDENT", "Tabs are not allowed as indentation");
+	return {
+		comma,
+		found,
+		spaceBefore,
+		comment,
+		hasNewline,
+		anchor,
+		tag,
+		newlineAfterProp,
+		end,
+		start: start ?? end
+	};
+}
+//#endregion
+export { resolveProps };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/util-contains-newline.js

@@ -0,0 +1,27 @@
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/util-contains-newline.js
+function containsNewline(key) {
+	if (!key) return null;
+	switch (key.type) {
+		case "alias":
+		case "scalar":
+		case "double-quoted-scalar":
+		case "single-quoted-scalar":
+			if (key.source.includes("\n")) return true;
+			if (key.end) {
+				for (const st of key.end) if (st.type === "newline") return true;
+			}
+			return false;
+		case "flow-collection":
+			for (const it of key.items) {
+				for (const st of it.start) if (st.type === "newline") return true;
+				if (it.sep) {
+					for (const st of it.sep) if (st.type === "newline") return true;
+				}
+				if (containsNewline(it.key) || containsNewline(it.value)) return true;
+			}
+			return false;
+		default: return true;
+	}
+}
+//#endregion
+export { containsNewline };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/util-empty-scalar-position.js

@@ -0,0 +1,25 @@
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/util-empty-scalar-position.js
+function emptyScalarPosition(offset, before, pos) {
+	if (before) {
+		pos ?? (pos = before.length);
+		for (let i = pos - 1; i >= 0; --i) {
+			let st = before[i];
+			switch (st.type) {
+				case "space":
+				case "comment":
+				case "newline":
+					offset -= st.source.length;
+					continue;
+			}
+			st = before[++i];
+			while (st?.type === "space") {
+				offset += st.source.length;
+				st = before[++i];
+			}
+			break;
+		}
+	}
+	return offset;
+}
+//#endregion
+export { emptyScalarPosition };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/util-flow-indent-check.js

@@ -0,0 +1,10 @@
+import { containsNewline } from "./util-contains-newline.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/util-flow-indent-check.js
+function flowIndentCheck(indent, fc, onError) {
+	if (fc?.type === "flow-collection") {
+		const end = fc.end[0];
+		if (end.indent === indent && (end.source === "]" || end.source === "}") && containsNewline(fc)) onError(end, "BAD_INDENT", "Flow end indicator should be more indented than parent", true);
+	}
+}
+//#endregion
+export { flowIndentCheck };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/util-map-includes.js

@@ -0,0 +1,10 @@
+import { isScalar } from "../nodes/identity.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/util-map-includes.js
+function mapIncludes(ctx, items, search) {
+	const { uniqueKeys } = ctx.options;
+	if (uniqueKeys === false) return false;
+	const isEqual = typeof uniqueKeys === "function" ? uniqueKeys : (a, b) => a === b || isScalar(a) && isScalar(b) && a.value === b.value;
+	return items.some((pair) => isEqual(pair.key, search));
+}
+//#endregion
+export { mapIncludes };