fumadocs-openapi 10.6.7 → 10.7.0

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/stringify/stringifyDocument.js

@@ -0,0 +1,59 @@
+import { isNode } from "../nodes/identity.js";
+import { indentComment, lineComment } from "./stringifyComment.js";
+import { createStringifyContext, stringify } from "./stringify.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/stringify/stringifyDocument.js
+function stringifyDocument(doc, options) {
+	const lines = [];
+	let hasDirectives = options.directives === true;
+	if (options.directives !== false && doc.directives) {
+		const dir = doc.directives.toString(doc);
+		if (dir) {
+			lines.push(dir);
+			hasDirectives = true;
+		} else if (doc.directives.docStart) hasDirectives = true;
+	}
+	if (hasDirectives) lines.push("---");
+	const ctx = createStringifyContext(doc, options);
+	const { commentString } = ctx.options;
+	if (doc.commentBefore) {
+		if (lines.length !== 1) lines.unshift("");
+		const cs = commentString(doc.commentBefore);
+		lines.unshift(indentComment(cs, ""));
+	}
+	let chompKeep = false;
+	let contentComment = null;
+	if (doc.contents) {
+		if (isNode(doc.contents)) {
+			if (doc.contents.spaceBefore && hasDirectives) lines.push("");
+			if (doc.contents.commentBefore) {
+				const cs = commentString(doc.contents.commentBefore);
+				lines.push(indentComment(cs, ""));
+			}
+			ctx.forceBlockIndent = !!doc.comment;
+			contentComment = doc.contents.comment;
+		}
+		const onChompKeep = contentComment ? void 0 : () => chompKeep = true;
+		let body = stringify(doc.contents, ctx, () => contentComment = null, onChompKeep);
+		if (contentComment) body += lineComment(body, "", commentString(contentComment));
+		if ((body[0] === "|" || body[0] === ">") && lines[lines.length - 1] === "---") lines[lines.length - 1] = `--- ${body}`;
+		else lines.push(body);
+	} else lines.push(stringify(doc.contents, ctx));
+	if (doc.directives?.docEnd) if (doc.comment) {
+		const cs = commentString(doc.comment);
+		if (cs.includes("\n")) {
+			lines.push("...");
+			lines.push(indentComment(cs, ""));
+		} else lines.push(`... ${cs}`);
+	} else lines.push("...");
+	else {
+		let dc = doc.comment;
+		if (dc && chompKeep) dc = dc.replace(/^\n+/, "");
+		if (dc) {
+			if ((!chompKeep || contentComment) && lines[lines.length - 1] !== "") lines.push("");
+			lines.push(indentComment(commentString(dc), ""));
+		}
+	}
+	return lines.join("\n") + "\n";
+}
+//#endregion
+export { stringifyDocument };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/stringify/stringifyNumber.js

@@ -0,0 +1,19 @@
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/stringify/stringifyNumber.js
+function stringifyNumber({ format, minFractionDigits, tag, value }) {
+	if (typeof value === "bigint") return String(value);
+	const num = typeof value === "number" ? value : Number(value);
+	if (!isFinite(num)) return isNaN(num) ? ".nan" : num < 0 ? "-.inf" : ".inf";
+	let n = Object.is(value, -0) ? "-0" : JSON.stringify(value);
+	if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^\d/.test(n)) {
+		let i = n.indexOf(".");
+		if (i < 0) {
+			i = n.length;
+			n += ".";
+		}
+		let d = minFractionDigits - (n.length - i - 1);
+		while (d-- > 0) n += "0";
+	}
+	return n;
+}
+//#endregion
+export { stringifyNumber };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/stringify/stringifyPair.js

@@ -0,0 +1,95 @@
+import { isCollection, isNode, isScalar, isSeq } from "../nodes/identity.js";
+import { Scalar } from "../nodes/Scalar.js";
+import { indentComment, lineComment } from "./stringifyComment.js";
+import { stringify } from "./stringify.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/stringify/stringifyPair.js
+function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
+	const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
+	let keyComment = isNode(key) && key.comment || null;
+	if (simpleKeys) {
+		if (keyComment) throw new Error("With simple keys, key nodes cannot have comments");
+		if (isCollection(key) || !isNode(key) && typeof key === "object") throw new Error("With simple keys, collection cannot be used as a key value");
+	}
+	let explicitKey = !simpleKeys && (!key || keyComment && value == null && !ctx.inFlow || isCollection(key) || (isScalar(key) ? key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL : typeof key === "object"));
+	ctx = Object.assign({}, ctx, {
+		allNullValues: false,
+		implicitKey: !explicitKey && (simpleKeys || !allNullValues),
+		indent: indent + indentStep
+	});
+	let keyCommentDone = false;
+	let chompKeep = false;
+	let str = stringify(key, ctx, () => keyCommentDone = true, () => chompKeep = true);
+	if (!explicitKey && !ctx.inFlow && str.length > 1024) {
+		if (simpleKeys) throw new Error("With simple keys, single line scalar must not span more than 1024 characters");
+		explicitKey = true;
+	}
+	if (ctx.inFlow) {
+		if (allNullValues || value == null) {
+			if (keyCommentDone && onComment) onComment();
+			return str === "" ? "?" : explicitKey ? `? ${str}` : str;
+		}
+	} else if (allNullValues && !simpleKeys || value == null && explicitKey) {
+		str = `? ${str}`;
+		if (keyComment && !keyCommentDone) str += lineComment(str, ctx.indent, commentString(keyComment));
+		else if (chompKeep && onChompKeep) onChompKeep();
+		return str;
+	}
+	if (keyCommentDone) keyComment = null;
+	if (explicitKey) {
+		if (keyComment) str += lineComment(str, ctx.indent, commentString(keyComment));
+		str = `? ${str}\n${indent}:`;
+	} else {
+		str = `${str}:`;
+		if (keyComment) str += lineComment(str, ctx.indent, commentString(keyComment));
+	}
+	let vsb, vcb, valueComment;
+	if (isNode(value)) {
+		vsb = !!value.spaceBefore;
+		vcb = value.commentBefore;
+		valueComment = value.comment;
+	} else {
+		vsb = false;
+		vcb = null;
+		valueComment = null;
+		if (value && typeof value === "object") value = doc.createNode(value);
+	}
+	ctx.implicitKey = false;
+	if (!explicitKey && !keyComment && isScalar(value)) ctx.indentAtStart = str.length + 1;
+	chompKeep = false;
+	if (!indentSeq && indentStep.length >= 2 && !ctx.inFlow && !explicitKey && isSeq(value) && !value.flow && !value.tag && !value.anchor) ctx.indent = ctx.indent.substring(2);
+	let valueCommentDone = false;
+	const valueStr = stringify(value, ctx, () => valueCommentDone = true, () => chompKeep = true);
+	let ws = " ";
+	if (keyComment || vsb || vcb) {
+		ws = vsb ? "\n" : "";
+		if (vcb) {
+			const cs = commentString(vcb);
+			ws += `\n${indentComment(cs, ctx.indent)}`;
+		}
+		if (valueStr === "" && !ctx.inFlow) {
+			if (ws === "\n" && valueComment) ws = "\n\n";
+		} else ws += `\n${ctx.indent}`;
+	} else if (!explicitKey && isCollection(value)) {
+		const vs0 = valueStr[0];
+		const nl0 = valueStr.indexOf("\n");
+		const hasNewline = nl0 !== -1;
+		const flow = ctx.inFlow ?? value.flow ?? value.items.length === 0;
+		if (hasNewline || !flow) {
+			let hasPropsLine = false;
+			if (hasNewline && (vs0 === "&" || vs0 === "!")) {
+				let sp0 = valueStr.indexOf(" ");
+				if (vs0 === "&" && sp0 !== -1 && sp0 < nl0 && valueStr[sp0 + 1] === "!") sp0 = valueStr.indexOf(" ", sp0 + 1);
+				if (sp0 === -1 || nl0 < sp0) hasPropsLine = true;
+			}
+			if (!hasPropsLine) ws = `\n${ctx.indent}`;
+		}
+	} else if (valueStr === "" || valueStr[0] === "\n") ws = "";
+	str += ws + valueStr;
+	if (ctx.inFlow) {
+		if (valueCommentDone && onComment) onComment();
+	} else if (valueComment && !valueCommentDone) str += lineComment(str, ctx.indent, commentString(valueComment));
+	else if (chompKeep && onChompKeep) onChompKeep();
+	return str;
+}
+//#endregion
+export { stringifyPair };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/stringify/stringifyString.js

@@ -0,0 +1,222 @@
+import { Scalar } from "../nodes/Scalar.js";
+import { FOLD_BLOCK, FOLD_FLOW, FOLD_QUOTED, foldFlowLines } from "./foldFlowLines.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/stringify/stringifyString.js
+const getFoldOptions = (ctx, isBlock) => ({
+	indentAtStart: isBlock ? ctx.indent.length : ctx.indentAtStart,
+	lineWidth: ctx.options.lineWidth,
+	minContentWidth: ctx.options.minContentWidth
+});
+const containsDocumentMarker = (str) => /^(%|---|\.\.\.)/m.test(str);
+function lineLengthOverLimit(str, lineWidth, indentLength) {
+	if (!lineWidth || lineWidth < 0) return false;
+	const limit = lineWidth - indentLength;
+	const strLen = str.length;
+	if (strLen <= limit) return false;
+	for (let i = 0, start = 0; i < strLen; ++i) if (str[i] === "\n") {
+		if (i - start > limit) return true;
+		start = i + 1;
+		if (strLen - start <= limit) return false;
+	}
+	return true;
+}
+function doubleQuotedString(value, ctx) {
+	const json = JSON.stringify(value);
+	if (ctx.options.doubleQuotedAsJSON) return json;
+	const { implicitKey } = ctx;
+	const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;
+	const indent = ctx.indent || (containsDocumentMarker(value) ? "  " : "");
+	let str = "";
+	let start = 0;
+	for (let i = 0, ch = json[i]; ch; ch = json[++i]) {
+		if (ch === " " && json[i + 1] === "\\" && json[i + 2] === "n") {
+			str += json.slice(start, i) + "\\ ";
+			i += 1;
+			start = i;
+			ch = "\\";
+		}
+		if (ch === "\\") switch (json[i + 1]) {
+			case "u":
+				{
+					str += json.slice(start, i);
+					const code = json.substr(i + 2, 4);
+					switch (code) {
+						case "0000":
+							str += "\\0";
+							break;
+						case "0007":
+							str += "\\a";
+							break;
+						case "000b":
+							str += "\\v";
+							break;
+						case "001b":
+							str += "\\e";
+							break;
+						case "0085":
+							str += "\\N";
+							break;
+						case "00a0":
+							str += "\\_";
+							break;
+						case "2028":
+							str += "\\L";
+							break;
+						case "2029":
+							str += "\\P";
+							break;
+						default: if (code.substr(0, 2) === "00") str += "\\x" + code.substr(2);
+						else str += json.substr(i, 6);
+					}
+					i += 5;
+					start = i + 1;
+				}
+				break;
+			case "n":
+				if (implicitKey || json[i + 2] === "\"" || json.length < minMultiLineLength) i += 1;
+				else {
+					str += json.slice(start, i) + "\n\n";
+					while (json[i + 2] === "\\" && json[i + 3] === "n" && json[i + 4] !== "\"") {
+						str += "\n";
+						i += 2;
+					}
+					str += indent;
+					if (json[i + 2] === " ") str += "\\";
+					i += 1;
+					start = i + 1;
+				}
+				break;
+			default: i += 1;
+		}
+	}
+	str = start ? str + json.slice(start) : json;
+	return implicitKey ? str : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx, false));
+}
+function singleQuotedString(value, ctx) {
+	if (ctx.options.singleQuote === false || ctx.implicitKey && value.includes("\n") || /[ \t]\n|\n[ \t]/.test(value)) return doubleQuotedString(value, ctx);
+	const indent = ctx.indent || (containsDocumentMarker(value) ? "  " : "");
+	const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&\n${indent}`) + "'";
+	return ctx.implicitKey ? res : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx, false));
+}
+function quotedString(value, ctx) {
+	const { singleQuote } = ctx.options;
+	let qs;
+	if (singleQuote === false) qs = doubleQuotedString;
+	else {
+		const hasDouble = value.includes("\"");
+		const hasSingle = value.includes("'");
+		if (hasDouble && !hasSingle) qs = singleQuotedString;
+		else if (hasSingle && !hasDouble) qs = doubleQuotedString;
+		else qs = singleQuote ? singleQuotedString : doubleQuotedString;
+	}
+	return qs(value, ctx);
+}
+let blockEndNewlines;
+try {
+	blockEndNewlines = /* @__PURE__ */ new RegExp("(^|(?<!\n))\n+(?!\n|$)", "g");
+} catch {
+	blockEndNewlines = /\n+(?!\n|$)/g;
+}
+function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
+	const { blockQuote, commentString, lineWidth } = ctx.options;
+	if (!blockQuote || /\n[\t ]+$/.test(value)) return quotedString(value, ctx);
+	const indent = ctx.indent || (ctx.forceBlockIndent || containsDocumentMarker(value) ? "  " : "");
+	const literal = blockQuote === "literal" ? true : blockQuote === "folded" || type === Scalar.BLOCK_FOLDED ? false : type === Scalar.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, lineWidth, indent.length);
+	if (!value) return literal ? "|\n" : ">\n";
+	let chomp;
+	let endStart;
+	for (endStart = value.length; endStart > 0; --endStart) {
+		const ch = value[endStart - 1];
+		if (ch !== "\n" && ch !== "	" && ch !== " ") break;
+	}
+	let end = value.substring(endStart);
+	const endNlPos = end.indexOf("\n");
+	if (endNlPos === -1) chomp = "-";
+	else if (value === end || endNlPos !== end.length - 1) {
+		chomp = "+";
+		if (onChompKeep) onChompKeep();
+	} else chomp = "";
+	if (end) {
+		value = value.slice(0, -end.length);
+		if (end[end.length - 1] === "\n") end = end.slice(0, -1);
+		end = end.replace(blockEndNewlines, `$&${indent}`);
+	}
+	let startWithSpace = false;
+	let startEnd;
+	let startNlPos = -1;
+	for (startEnd = 0; startEnd < value.length; ++startEnd) {
+		const ch = value[startEnd];
+		if (ch === " ") startWithSpace = true;
+		else if (ch === "\n") startNlPos = startEnd;
+		else break;
+	}
+	let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);
+	if (start) {
+		value = value.substring(start.length);
+		start = start.replace(/\n+/g, `$&${indent}`);
+	}
+	let header = (startWithSpace ? indent ? "2" : "1" : "") + chomp;
+	if (comment) {
+		header += " " + commentString(comment.replace(/ ?[\r\n]+/g, " "));
+		if (onComment) onComment();
+	}
+	if (!literal) {
+		const foldedValue = value.replace(/\n+/g, "\n$&").replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${indent}`);
+		let literalFallback = false;
+		const foldOptions = getFoldOptions(ctx, true);
+		if (blockQuote !== "folded" && type !== Scalar.BLOCK_FOLDED) foldOptions.onOverflow = () => {
+			literalFallback = true;
+		};
+		const body = foldFlowLines(`${start}${foldedValue}${end}`, indent, FOLD_BLOCK, foldOptions);
+		if (!literalFallback) return `>${header}\n${indent}${body}`;
+	}
+	value = value.replace(/\n+/g, `$&${indent}`);
+	return `|${header}\n${indent}${start}${value}${end}`;
+}
+function plainString(item, ctx, onComment, onChompKeep) {
+	const { type, value } = item;
+	const { actualString, implicitKey, indent, indentStep, inFlow } = ctx;
+	if (implicitKey && value.includes("\n") || inFlow && /[[\]{},]/.test(value)) return quotedString(value, ctx);
+	if (/^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) return implicitKey || inFlow || !value.includes("\n") ? quotedString(value, ctx) : blockString(item, ctx, onComment, onChompKeep);
+	if (!implicitKey && !inFlow && type !== Scalar.PLAIN && value.includes("\n")) return blockString(item, ctx, onComment, onChompKeep);
+	if (containsDocumentMarker(value)) {
+		if (indent === "") {
+			ctx.forceBlockIndent = true;
+			return blockString(item, ctx, onComment, onChompKeep);
+		} else if (implicitKey && indent === indentStep) return quotedString(value, ctx);
+	}
+	const str = value.replace(/\n+/g, `$&\n${indent}`);
+	if (actualString) {
+		const test = (tag) => tag.default && tag.tag !== "tag:yaml.org,2002:str" && tag.test?.test(str);
+		const { compat, tags } = ctx.doc.schema;
+		if (tags.some(test) || compat?.some(test)) return quotedString(value, ctx);
+	}
+	return implicitKey ? str : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx, false));
+}
+function stringifyString(item, ctx, onComment, onChompKeep) {
+	const { implicitKey, inFlow } = ctx;
+	const ss = typeof item.value === "string" ? item : Object.assign({}, item, { value: String(item.value) });
+	let { type } = item;
+	if (type !== Scalar.QUOTE_DOUBLE) {
+		if (/[\x00-\x08\x0b-\x1f\x7f-\x9f\u{D800}-\u{DFFF}]/u.test(ss.value)) type = Scalar.QUOTE_DOUBLE;
+	}
+	const _stringify = (_type) => {
+		switch (_type) {
+			case Scalar.BLOCK_FOLDED:
+			case Scalar.BLOCK_LITERAL: return implicitKey || inFlow ? quotedString(ss.value, ctx) : blockString(ss, ctx, onComment, onChompKeep);
+			case Scalar.QUOTE_DOUBLE: return doubleQuotedString(ss.value, ctx);
+			case Scalar.QUOTE_SINGLE: return singleQuotedString(ss.value, ctx);
+			case Scalar.PLAIN: return plainString(ss, ctx, onComment, onChompKeep);
+			default: return null;
+		}
+	};
+	let res = _stringify(type);
+	if (res === null) {
+		const { defaultKeyType, defaultStringType } = ctx.options;
+		const t = implicitKey && defaultKeyType || defaultStringType;
+		res = _stringify(t);
+		if (res === null) throw new Error(`Unsupported default string type ${t}`);
+	}
+	return res;
+}
+//#endregion
+export { stringifyString };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/visit.js

@@ -0,0 +1,187 @@
+import { isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq } from "./nodes/identity.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/visit.js
+const BREAK = Symbol("break visit");
+const SKIP = Symbol("skip children");
+const REMOVE = Symbol("remove node");
+/**
+* Apply a visitor to an AST node or document.
+*
+* Walks through the tree (depth-first) starting from `node`, calling a
+* `visitor` function with three arguments:
+*   - `key`: For sequence values and map `Pair`, the node's index in the
+*     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+*     `null` for the root node.
+*   - `node`: The current node.
+*   - `path`: The ancestry of the current node.
+*
+* The return value of the visitor may be used to control the traversal:
+*   - `undefined` (default): Do nothing and continue
+*   - `visit.SKIP`: Do not visit the children of this node, continue with next
+*     sibling
+*   - `visit.BREAK`: Terminate traversal completely
+*   - `visit.REMOVE`: Remove the current node, then continue with the next one
+*   - `Node`: Replace the current node, then continue by visiting it
+*   - `number`: While iterating the items of a sequence or map, set the index
+*     of the next step. This is useful especially if the index of the current
+*     node has changed.
+*
+* If `visitor` is a single function, it will be called with all values
+* encountered in the tree, including e.g. `null` values. Alternatively,
+* separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+* `Alias` and `Scalar` node. To define the same visitor function for more than
+* one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+* and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+* specific defined one will be used for each node.
+*/
+function visit(node, visitor) {
+	const visitor_ = initVisitor(visitor);
+	if (isDocument(node)) {
+		if (visit_(null, node.contents, visitor_, Object.freeze([node])) === REMOVE) node.contents = null;
+	} else visit_(null, node, visitor_, Object.freeze([]));
+}
+/** Terminate visit traversal completely */
+visit.BREAK = BREAK;
+/** Do not visit the children of the current node */
+visit.SKIP = SKIP;
+/** Remove the current node */
+visit.REMOVE = REMOVE;
+function visit_(key, node, visitor, path) {
+	const ctrl = callVisitor(key, node, visitor, path);
+	if (isNode(ctrl) || isPair(ctrl)) {
+		replaceNode(key, path, ctrl);
+		return visit_(key, ctrl, visitor, path);
+	}
+	if (typeof ctrl !== "symbol") {
+		if (isCollection(node)) {
+			path = Object.freeze(path.concat(node));
+			for (let i = 0; i < node.items.length; ++i) {
+				const ci = visit_(i, node.items[i], visitor, path);
+				if (typeof ci === "number") i = ci - 1;
+				else if (ci === BREAK) return BREAK;
+				else if (ci === REMOVE) {
+					node.items.splice(i, 1);
+					i -= 1;
+				}
+			}
+		} else if (isPair(node)) {
+			path = Object.freeze(path.concat(node));
+			const ck = visit_("key", node.key, visitor, path);
+			if (ck === BREAK) return BREAK;
+			else if (ck === REMOVE) node.key = null;
+			const cv = visit_("value", node.value, visitor, path);
+			if (cv === BREAK) return BREAK;
+			else if (cv === REMOVE) node.value = null;
+		}
+	}
+	return ctrl;
+}
+/**
+* Apply an async visitor to an AST node or document.
+*
+* Walks through the tree (depth-first) starting from `node`, calling a
+* `visitor` function with three arguments:
+*   - `key`: For sequence values and map `Pair`, the node's index in the
+*     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+*     `null` for the root node.
+*   - `node`: The current node.
+*   - `path`: The ancestry of the current node.
+*
+* The return value of the visitor may be used to control the traversal:
+*   - `Promise`: Must resolve to one of the following values
+*   - `undefined` (default): Do nothing and continue
+*   - `visit.SKIP`: Do not visit the children of this node, continue with next
+*     sibling
+*   - `visit.BREAK`: Terminate traversal completely
+*   - `visit.REMOVE`: Remove the current node, then continue with the next one
+*   - `Node`: Replace the current node, then continue by visiting it
+*   - `number`: While iterating the items of a sequence or map, set the index
+*     of the next step. This is useful especially if the index of the current
+*     node has changed.
+*
+* If `visitor` is a single function, it will be called with all values
+* encountered in the tree, including e.g. `null` values. Alternatively,
+* separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+* `Alias` and `Scalar` node. To define the same visitor function for more than
+* one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+* and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+* specific defined one will be used for each node.
+*/
+async function visitAsync(node, visitor) {
+	const visitor_ = initVisitor(visitor);
+	if (isDocument(node)) {
+		if (await visitAsync_(null, node.contents, visitor_, Object.freeze([node])) === REMOVE) node.contents = null;
+	} else await visitAsync_(null, node, visitor_, Object.freeze([]));
+}
+/** Terminate visit traversal completely */
+visitAsync.BREAK = BREAK;
+/** Do not visit the children of the current node */
+visitAsync.SKIP = SKIP;
+/** Remove the current node */
+visitAsync.REMOVE = REMOVE;
+async function visitAsync_(key, node, visitor, path) {
+	const ctrl = await callVisitor(key, node, visitor, path);
+	if (isNode(ctrl) || isPair(ctrl)) {
+		replaceNode(key, path, ctrl);
+		return visitAsync_(key, ctrl, visitor, path);
+	}
+	if (typeof ctrl !== "symbol") {
+		if (isCollection(node)) {
+			path = Object.freeze(path.concat(node));
+			for (let i = 0; i < node.items.length; ++i) {
+				const ci = await visitAsync_(i, node.items[i], visitor, path);
+				if (typeof ci === "number") i = ci - 1;
+				else if (ci === BREAK) return BREAK;
+				else if (ci === REMOVE) {
+					node.items.splice(i, 1);
+					i -= 1;
+				}
+			}
+		} else if (isPair(node)) {
+			path = Object.freeze(path.concat(node));
+			const ck = await visitAsync_("key", node.key, visitor, path);
+			if (ck === BREAK) return BREAK;
+			else if (ck === REMOVE) node.key = null;
+			const cv = await visitAsync_("value", node.value, visitor, path);
+			if (cv === BREAK) return BREAK;
+			else if (cv === REMOVE) node.value = null;
+		}
+	}
+	return ctrl;
+}
+function initVisitor(visitor) {
+	if (typeof visitor === "object" && (visitor.Collection || visitor.Node || visitor.Value)) return Object.assign({
+		Alias: visitor.Node,
+		Map: visitor.Node,
+		Scalar: visitor.Node,
+		Seq: visitor.Node
+	}, visitor.Value && {
+		Map: visitor.Value,
+		Scalar: visitor.Value,
+		Seq: visitor.Value
+	}, visitor.Collection && {
+		Map: visitor.Collection,
+		Seq: visitor.Collection
+	}, visitor);
+	return visitor;
+}
+function callVisitor(key, node, visitor, path) {
+	if (typeof visitor === "function") return visitor(key, node, path);
+	if (isMap(node)) return visitor.Map?.(key, node, path);
+	if (isSeq(node)) return visitor.Seq?.(key, node, path);
+	if (isPair(node)) return visitor.Pair?.(key, node, path);
+	if (isScalar(node)) return visitor.Scalar?.(key, node, path);
+	if (isAlias(node)) return visitor.Alias?.(key, node, path);
+}
+function replaceNode(key, path, node) {
+	const parent = path[path.length - 1];
+	if (isCollection(parent)) parent.items[key] = node;
+	else if (isPair(parent)) if (key === "key") parent.key = node;
+	else parent.value = node;
+	else if (isDocument(parent)) parent.contents = node;
+	else {
+		const pt = isAlias(parent) ? "alias" : "scalar";
+		throw new Error(`Cannot replace node with ${pt} parent`);
+	}
+}
+//#endregion
+export { visit, visitAsync };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/index.js

@@ -0,0 +1,16 @@
+import "./dist/nodes/identity.js";
+import "./dist/visit.js";
+import "./dist/nodes/Alias.js";
+import "./dist/nodes/Scalar.js";
+import "./dist/nodes/Pair.js";
+import "./dist/nodes/YAMLMap.js";
+import "./dist/nodes/YAMLSeq.js";
+import "./dist/schema/Schema.js";
+import "./dist/doc/Document.js";
+import "./dist/errors.js";
+import "./dist/compose/composer.js";
+import "./dist/parse/lexer.js";
+import "./dist/parse/line-counter.js";
+import "./dist/parse/parser.js";
+import "./dist/public-api.js";
+import "./dist/index.js";