fumadocs-openapi 10.6.8 → 10.7.0

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/omap.js

@@ -0,0 +1,60 @@
+import { isPair, isScalar } from "../../nodes/identity.js";
+import { toJS } from "../../nodes/toJS.js";
+import { YAMLMap } from "../../nodes/YAMLMap.js";
+import { YAMLSeq } from "../../nodes/YAMLSeq.js";
+import { createPairs, resolvePairs } from "./pairs.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/omap.js
+var YAMLOMap = class YAMLOMap extends YAMLSeq {
+	constructor() {
+		super();
+		this.add = YAMLMap.prototype.add.bind(this);
+		this.delete = YAMLMap.prototype.delete.bind(this);
+		this.get = YAMLMap.prototype.get.bind(this);
+		this.has = YAMLMap.prototype.has.bind(this);
+		this.set = YAMLMap.prototype.set.bind(this);
+		this.tag = YAMLOMap.tag;
+	}
+	/**
+	* If `ctx` is given, the return type is actually `Map<unknown, unknown>`,
+	* but TypeScript won't allow widening the signature of a child method.
+	*/
+	toJSON(_, ctx) {
+		if (!ctx) return super.toJSON(_);
+		const map = /* @__PURE__ */ new Map();
+		if (ctx?.onCreate) ctx.onCreate(map);
+		for (const pair of this.items) {
+			let key, value;
+			if (isPair(pair)) {
+				key = toJS(pair.key, "", ctx);
+				value = toJS(pair.value, key, ctx);
+			} else key = toJS(pair, "", ctx);
+			if (map.has(key)) throw new Error("Ordered maps must not include duplicate keys");
+			map.set(key, value);
+		}
+		return map;
+	}
+	static from(schema, iterable, ctx) {
+		const pairs = createPairs(schema, iterable, ctx);
+		const omap = new this();
+		omap.items = pairs.items;
+		return omap;
+	}
+};
+YAMLOMap.tag = "tag:yaml.org,2002:omap";
+const omap = {
+	collection: "seq",
+	identify: (value) => value instanceof Map,
+	nodeClass: YAMLOMap,
+	default: false,
+	tag: "tag:yaml.org,2002:omap",
+	resolve(seq, onError) {
+		const pairs = resolvePairs(seq, onError);
+		const seenKeys = [];
+		for (const { key } of pairs.items) if (isScalar(key)) if (seenKeys.includes(key.value)) onError(`Ordered maps must not include duplicate keys: ${key.value}`);
+		else seenKeys.push(key.value);
+		return Object.assign(new YAMLOMap(), pairs);
+	},
+	createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx)
+};
+//#endregion
+export { omap };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/pairs.js

@@ -0,0 +1,56 @@
+import { isMap, isPair, isSeq } from "../../nodes/identity.js";
+import { Scalar } from "../../nodes/Scalar.js";
+import { Pair, createPair } from "../../nodes/Pair.js";
+import { YAMLSeq } from "../../nodes/YAMLSeq.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/pairs.js
+function resolvePairs(seq, onError) {
+	if (isSeq(seq)) for (let i = 0; i < seq.items.length; ++i) {
+		let item = seq.items[i];
+		if (isPair(item)) continue;
+		else if (isMap(item)) {
+			if (item.items.length > 1) onError("Each pair must have its own sequence indicator");
+			const pair = item.items[0] || new Pair(new Scalar(null));
+			if (item.commentBefore) pair.key.commentBefore = pair.key.commentBefore ? `${item.commentBefore}\n${pair.key.commentBefore}` : item.commentBefore;
+			if (item.comment) {
+				const cn = pair.value ?? pair.key;
+				cn.comment = cn.comment ? `${item.comment}\n${cn.comment}` : item.comment;
+			}
+			item = pair;
+		}
+		seq.items[i] = isPair(item) ? item : new Pair(item);
+	}
+	else onError("Expected a sequence for this tag");
+	return seq;
+}
+function createPairs(schema, iterable, ctx) {
+	const { replacer } = ctx;
+	const pairs = new YAMLSeq(schema);
+	pairs.tag = "tag:yaml.org,2002:pairs";
+	let i = 0;
+	if (iterable && Symbol.iterator in Object(iterable)) for (let it of iterable) {
+		if (typeof replacer === "function") it = replacer.call(iterable, String(i++), it);
+		let key, value;
+		if (Array.isArray(it)) if (it.length === 2) {
+			key = it[0];
+			value = it[1];
+		} else throw new TypeError(`Expected [key, value] tuple: ${it}`);
+		else if (it && it instanceof Object) {
+			const keys = Object.keys(it);
+			if (keys.length === 1) {
+				key = keys[0];
+				value = it[key];
+			} else throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`);
+		} else key = it;
+		pairs.items.push(createPair(key, value, ctx));
+	}
+	return pairs;
+}
+const pairs = {
+	collection: "seq",
+	default: false,
+	tag: "tag:yaml.org,2002:pairs",
+	resolve: resolvePairs,
+	createNode: createPairs
+};
+//#endregion
+export { createPairs, pairs, resolvePairs };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/schema.js

@@ -0,0 +1,39 @@
+import { merge } from "./merge.js";
+import { map } from "../common/map.js";
+import { seq } from "../common/seq.js";
+import { string } from "../common/string.js";
+import { nullTag } from "../common/null.js";
+import { binary } from "./binary.js";
+import { pairs } from "./pairs.js";
+import { omap } from "./omap.js";
+import { falseTag, trueTag } from "./bool.js";
+import { float, floatExp, floatNaN } from "./float.js";
+import { int, intBin, intHex, intOct } from "./int.js";
+import { set } from "./set.js";
+import { floatTime, intTime, timestamp } from "./timestamp.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/schema.js
+const schema = [
+	map,
+	seq,
+	string,
+	nullTag,
+	trueTag,
+	falseTag,
+	intBin,
+	intOct,
+	int,
+	intHex,
+	floatNaN,
+	floatExp,
+	float,
+	binary,
+	merge,
+	omap,
+	pairs,
+	set,
+	intTime,
+	floatTime,
+	timestamp
+];
+//#endregion
+export { schema };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/set.js

@@ -0,0 +1,65 @@
+import { isMap, isPair, isScalar } from "../../nodes/identity.js";
+import { Pair, createPair } from "../../nodes/Pair.js";
+import { YAMLMap, findPair } from "../../nodes/YAMLMap.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/set.js
+var YAMLSet = class YAMLSet extends YAMLMap {
+	constructor(schema) {
+		super(schema);
+		this.tag = YAMLSet.tag;
+	}
+	add(key) {
+		let pair;
+		if (isPair(key)) pair = key;
+		else if (key && typeof key === "object" && "key" in key && "value" in key && key.value === null) pair = new Pair(key.key, null);
+		else pair = new Pair(key, null);
+		if (!findPair(this.items, pair.key)) this.items.push(pair);
+	}
+	/**
+	* If `keepPair` is `true`, returns the Pair matching `key`.
+	* Otherwise, returns the value of that Pair's key.
+	*/
+	get(key, keepPair) {
+		const pair = findPair(this.items, key);
+		return !keepPair && isPair(pair) ? isScalar(pair.key) ? pair.key.value : pair.key : pair;
+	}
+	set(key, value) {
+		if (typeof value !== "boolean") throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);
+		const prev = findPair(this.items, key);
+		if (prev && !value) this.items.splice(this.items.indexOf(prev), 1);
+		else if (!prev && value) this.items.push(new Pair(key));
+	}
+	toJSON(_, ctx) {
+		return super.toJSON(_, ctx, Set);
+	}
+	toString(ctx, onComment, onChompKeep) {
+		if (!ctx) return JSON.stringify(this);
+		if (this.hasAllNullValues(true)) return super.toString(Object.assign({}, ctx, { allNullValues: true }), onComment, onChompKeep);
+		else throw new Error("Set items must all have null values");
+	}
+	static from(schema, iterable, ctx) {
+		const { replacer } = ctx;
+		const set = new this(schema);
+		if (iterable && Symbol.iterator in Object(iterable)) for (let value of iterable) {
+			if (typeof replacer === "function") value = replacer.call(iterable, value, value);
+			set.items.push(createPair(value, null, ctx));
+		}
+		return set;
+	}
+};
+YAMLSet.tag = "tag:yaml.org,2002:set";
+const set = {
+	collection: "map",
+	identify: (value) => value instanceof Set,
+	nodeClass: YAMLSet,
+	default: false,
+	tag: "tag:yaml.org,2002:set",
+	createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx),
+	resolve(map, onError) {
+		if (isMap(map)) if (map.hasAllNullValues(true)) return Object.assign(new YAMLSet(), map);
+		else onError("Set items must all have null values");
+		else onError("Expected a mapping for this tag");
+		return map;
+	}
+};
+//#endregion
+export { set };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/timestamp.js

@@ -0,0 +1,79 @@
+import { stringifyNumber } from "../../stringify/stringifyNumber.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/timestamp.js
+/** Internal types handle bigint as number, because TS can't figure it out. */
+function parseSexagesimal(str, asBigInt) {
+	const sign = str[0];
+	const parts = sign === "-" || sign === "+" ? str.substring(1) : str;
+	const num = (n) => asBigInt ? BigInt(n) : Number(n);
+	const res = parts.replace(/_/g, "").split(":").reduce((res, p) => res * num(60) + num(p), num(0));
+	return sign === "-" ? num(-1) * res : res;
+}
+/**
+* hhhh:mm:ss.sss
+*
+* Internal types handle bigint as number, because TS can't figure it out.
+*/
+function stringifySexagesimal(node) {
+	let { value } = node;
+	let num = (n) => n;
+	if (typeof value === "bigint") num = (n) => BigInt(n);
+	else if (isNaN(value) || !isFinite(value)) return stringifyNumber(node);
+	let sign = "";
+	if (value < 0) {
+		sign = "-";
+		value *= num(-1);
+	}
+	const _60 = num(60);
+	const parts = [value % _60];
+	if (value < 60) parts.unshift(0);
+	else {
+		value = (value - parts[0]) / _60;
+		parts.unshift(value % _60);
+		if (value >= 60) {
+			value = (value - parts[0]) / _60;
+			parts.unshift(value);
+		}
+	}
+	return sign + parts.map((n) => String(n).padStart(2, "0")).join(":").replace(/000000\d*$/, "");
+}
+const intTime = {
+	identify: (value) => typeof value === "bigint" || Number.isInteger(value),
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	format: "TIME",
+	test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,
+	resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt),
+	stringify: stringifySexagesimal
+};
+const floatTime = {
+	identify: (value) => typeof value === "number",
+	default: true,
+	tag: "tag:yaml.org,2002:float",
+	format: "TIME",
+	test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/,
+	resolve: (str) => parseSexagesimal(str, false),
+	stringify: stringifySexagesimal
+};
+const timestamp = {
+	identify: (value) => value instanceof Date,
+	default: true,
+	tag: "tag:yaml.org,2002:timestamp",
+	test: RegExp("^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})(?:(?:t|T|[ \\t]+)([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?)?$"),
+	resolve(str) {
+		const match = str.match(timestamp.test);
+		if (!match) throw new Error("!!timestamp expects a date, starting with yyyy-mm-dd");
+		const [, year, month, day, hour, minute, second] = match.map(Number);
+		const millisec = match[7] ? Number((match[7] + "00").substr(1, 3)) : 0;
+		let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);
+		const tz = match[8];
+		if (tz && tz !== "Z") {
+			let d = parseSexagesimal(tz, false);
+			if (Math.abs(d) < 30) d *= 60;
+			date -= 6e4 * d;
+		}
+		return new Date(date);
+	},
+	stringify: ({ value }) => value?.toISOString().replace(/(T00:00:00)?\.000Z$/, "") ?? ""
+};
+//#endregion
+export { floatTime, intTime, timestamp };

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

@@ -0,0 +1,111 @@
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/stringify/foldFlowLines.js
+const FOLD_FLOW = "flow";
+const FOLD_BLOCK = "block";
+const FOLD_QUOTED = "quoted";
+/**
+* Tries to keep input at up to `lineWidth` characters, splitting only on spaces
+* not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are
+* terminated with `\n` and started with `indent`.
+*/
+function foldFlowLines(text, indent, mode = "flow", { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {
+	if (!lineWidth || lineWidth < 0) return text;
+	if (lineWidth < minContentWidth) minContentWidth = 0;
+	const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);
+	if (text.length <= endStep) return text;
+	const folds = [];
+	const escapedFolds = {};
+	let end = lineWidth - indent.length;
+	if (typeof indentAtStart === "number") if (indentAtStart > lineWidth - Math.max(2, minContentWidth)) folds.push(0);
+	else end = lineWidth - indentAtStart;
+	let split = void 0;
+	let prev = void 0;
+	let overflow = false;
+	let i = -1;
+	let escStart = -1;
+	let escEnd = -1;
+	if (mode === "block") {
+		i = consumeMoreIndentedLines(text, i, indent.length);
+		if (i !== -1) end = i + endStep;
+	}
+	for (let ch; ch = text[i += 1];) {
+		if (mode === "quoted" && ch === "\\") {
+			escStart = i;
+			switch (text[i + 1]) {
+				case "x":
+					i += 3;
+					break;
+				case "u":
+					i += 5;
+					break;
+				case "U":
+					i += 9;
+					break;
+				default: i += 1;
+			}
+			escEnd = i;
+		}
+		if (ch === "\n") {
+			if (mode === "block") i = consumeMoreIndentedLines(text, i, indent.length);
+			end = i + indent.length + endStep;
+			split = void 0;
+		} else {
+			if (ch === " " && prev && prev !== " " && prev !== "\n" && prev !== "	") {
+				const next = text[i + 1];
+				if (next && next !== " " && next !== "\n" && next !== "	") split = i;
+			}
+			if (i >= end) if (split) {
+				folds.push(split);
+				end = split + endStep;
+				split = void 0;
+			} else if (mode === "quoted") {
+				while (prev === " " || prev === "	") {
+					prev = ch;
+					ch = text[i += 1];
+					overflow = true;
+				}
+				const j = i > escEnd + 1 ? i - 2 : escStart - 1;
+				if (escapedFolds[j]) return text;
+				folds.push(j);
+				escapedFolds[j] = true;
+				end = j + endStep;
+				split = void 0;
+			} else overflow = true;
+		}
+		prev = ch;
+	}
+	if (overflow && onOverflow) onOverflow();
+	if (folds.length === 0) return text;
+	if (onFold) onFold();
+	let res = text.slice(0, folds[0]);
+	for (let i = 0; i < folds.length; ++i) {
+		const fold = folds[i];
+		const end = folds[i + 1] || text.length;
+		if (fold === 0) res = `\n${indent}${text.slice(0, end)}`;
+		else {
+			if (mode === "quoted" && escapedFolds[fold]) res += `${text[fold]}\\`;
+			res += `\n${indent}${text.slice(fold + 1, end)}`;
+		}
+	}
+	return res;
+}
+/**
+* Presumes `i + 1` is at the start of a line
+* @returns index of last newline in more-indented block
+*/
+function consumeMoreIndentedLines(text, i, indent) {
+	let end = i;
+	let start = i + 1;
+	let ch = text[start];
+	while (ch === " " || ch === "	") if (i < start + indent) ch = text[++i];
+	else {
+		do
+			ch = text[++i];
+		while (ch && ch !== "\n");
+		end = i;
+		start = i + 1;
+		ch = text[start];
+	}
+	return end;
+}
+//#endregion
+export { FOLD_BLOCK, FOLD_FLOW, FOLD_QUOTED, foldFlowLines };

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

@@ -0,0 +1,105 @@
+import { isAlias, isCollection, isNode, isPair, isScalar } from "../nodes/identity.js";
+import { anchorIsValid } from "../doc/anchors.js";
+import { stringifyComment } from "./stringifyComment.js";
+import { stringifyString } from "./stringifyString.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/stringify/stringify.js
+function createStringifyContext(doc, options) {
+	const opt = Object.assign({
+		blockQuote: true,
+		commentString: stringifyComment,
+		defaultKeyType: null,
+		defaultStringType: "PLAIN",
+		directives: null,
+		doubleQuotedAsJSON: false,
+		doubleQuotedMinMultiLineLength: 40,
+		falseStr: "false",
+		flowCollectionPadding: true,
+		indentSeq: true,
+		lineWidth: 80,
+		minContentWidth: 20,
+		nullStr: "null",
+		simpleKeys: false,
+		singleQuote: null,
+		trailingComma: false,
+		trueStr: "true",
+		verifyAliasOrder: true
+	}, doc.schema.toStringOptions, options);
+	let inFlow;
+	switch (opt.collectionStyle) {
+		case "block":
+			inFlow = false;
+			break;
+		case "flow":
+			inFlow = true;
+			break;
+		default: inFlow = null;
+	}
+	return {
+		anchors: /* @__PURE__ */ new Set(),
+		doc,
+		flowCollectionPadding: opt.flowCollectionPadding ? " " : "",
+		indent: "",
+		indentStep: typeof opt.indent === "number" ? " ".repeat(opt.indent) : "  ",
+		inFlow,
+		options: opt
+	};
+}
+function getTagObject(tags, item) {
+	if (item.tag) {
+		const match = tags.filter((t) => t.tag === item.tag);
+		if (match.length > 0) return match.find((t) => t.format === item.format) ?? match[0];
+	}
+	let tagObj = void 0;
+	let obj;
+	if (isScalar(item)) {
+		obj = item.value;
+		let match = tags.filter((t) => t.identify?.(obj));
+		if (match.length > 1) {
+			const testMatch = match.filter((t) => t.test);
+			if (testMatch.length > 0) match = testMatch;
+		}
+		tagObj = match.find((t) => t.format === item.format) ?? match.find((t) => !t.format);
+	} else {
+		obj = item;
+		tagObj = tags.find((t) => t.nodeClass && obj instanceof t.nodeClass);
+	}
+	if (!tagObj) {
+		const name = obj?.constructor?.name ?? (obj === null ? "null" : typeof obj);
+		throw new Error(`Tag not resolved for ${name} value`);
+	}
+	return tagObj;
+}
+function stringifyProps(node, tagObj, { anchors, doc }) {
+	if (!doc.directives) return "";
+	const props = [];
+	const anchor = (isScalar(node) || isCollection(node)) && node.anchor;
+	if (anchor && anchorIsValid(anchor)) {
+		anchors.add(anchor);
+		props.push(`&${anchor}`);
+	}
+	const tag = node.tag ?? (tagObj.default ? null : tagObj.tag);
+	if (tag) props.push(doc.directives.tagString(tag));
+	return props.join(" ");
+}
+function stringify(item, ctx, onComment, onChompKeep) {
+	if (isPair(item)) return item.toString(ctx, onComment, onChompKeep);
+	if (isAlias(item)) {
+		if (ctx.doc.directives) return item.toString(ctx);
+		if (ctx.resolvedAliases?.has(item)) throw new TypeError(`Cannot stringify circular structure without alias nodes`);
+		else {
+			if (ctx.resolvedAliases) ctx.resolvedAliases.add(item);
+			else ctx.resolvedAliases = new Set([item]);
+			item = item.resolve(ctx.doc);
+		}
+	}
+	let tagObj = void 0;
+	const node = isNode(item) ? item : ctx.doc.createNode(item, { onTagObj: (o) => tagObj = o });
+	tagObj ?? (tagObj = getTagObject(ctx.doc.schema.tags, node));
+	const props = stringifyProps(node, tagObj, ctx);
+	if (props.length > 0) ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;
+	const str = typeof tagObj.stringify === "function" ? tagObj.stringify(node, ctx, onComment, onChompKeep) : isScalar(node) ? stringifyString(node, ctx, onComment, onChompKeep) : node.toString(ctx, onComment, onChompKeep);
+	if (!props) return str;
+	return isScalar(node) || str[0] === "{" || str[0] === "[" ? `${props} ${str}` : `${props}\n${ctx.indent}${str}`;
+}
+//#endregion
+export { createStringifyContext, stringify };

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

@@ -0,0 +1,116 @@
+import { isNode, isPair } from "../nodes/identity.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/stringifyCollection.js
+function stringifyCollection(collection, ctx, options) {
+	return (ctx.inFlow ?? collection.flow ? stringifyFlowCollection : stringifyBlockCollection)(collection, ctx, options);
+}
+function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) {
+	const { indent, options: { commentString } } = ctx;
+	const itemCtx = Object.assign({}, ctx, {
+		indent: itemIndent,
+		type: null
+	});
+	let chompKeep = false;
+	const lines = [];
+	for (let i = 0; i < items.length; ++i) {
+		const item = items[i];
+		let comment = null;
+		if (isNode(item)) {
+			if (!chompKeep && item.spaceBefore) lines.push("");
+			addCommentBefore(ctx, lines, item.commentBefore, chompKeep);
+			if (item.comment) comment = item.comment;
+		} else if (isPair(item)) {
+			const ik = isNode(item.key) ? item.key : null;
+			if (ik) {
+				if (!chompKeep && ik.spaceBefore) lines.push("");
+				addCommentBefore(ctx, lines, ik.commentBefore, chompKeep);
+			}
+		}
+		chompKeep = false;
+		let str = stringify(item, itemCtx, () => comment = null, () => chompKeep = true);
+		if (comment) str += lineComment(str, itemIndent, commentString(comment));
+		if (chompKeep && comment) chompKeep = false;
+		lines.push(blockItemPrefix + str);
+	}
+	let str;
+	if (lines.length === 0) str = flowChars.start + flowChars.end;
+	else {
+		str = lines[0];
+		for (let i = 1; i < lines.length; ++i) {
+			const line = lines[i];
+			str += line ? `\n${indent}${line}` : "\n";
+		}
+	}
+	if (comment) {
+		str += "\n" + indentComment(commentString(comment), indent);
+		if (onComment) onComment();
+	} else if (chompKeep && onChompKeep) onChompKeep();
+	return str;
+}
+function stringifyFlowCollection({ items }, ctx, { flowChars, itemIndent }) {
+	const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;
+	itemIndent += indentStep;
+	const itemCtx = Object.assign({}, ctx, {
+		indent: itemIndent,
+		inFlow: true,
+		type: null
+	});
+	let reqNewline = false;
+	let linesAtValue = 0;
+	const lines = [];
+	for (let i = 0; i < items.length; ++i) {
+		const item = items[i];
+		let comment = null;
+		if (isNode(item)) {
+			if (item.spaceBefore) lines.push("");
+			addCommentBefore(ctx, lines, item.commentBefore, false);
+			if (item.comment) comment = item.comment;
+		} else if (isPair(item)) {
+			const ik = isNode(item.key) ? item.key : null;
+			if (ik) {
+				if (ik.spaceBefore) lines.push("");
+				addCommentBefore(ctx, lines, ik.commentBefore, false);
+				if (ik.comment) reqNewline = true;
+			}
+			const iv = isNode(item.value) ? item.value : null;
+			if (iv) {
+				if (iv.comment) comment = iv.comment;
+				if (iv.commentBefore) reqNewline = true;
+			} else if (item.value == null && ik?.comment) comment = ik.comment;
+		}
+		if (comment) reqNewline = true;
+		let str = stringify(item, itemCtx, () => comment = null);
+		reqNewline || (reqNewline = lines.length > linesAtValue || str.includes("\n"));
+		if (i < items.length - 1) str += ",";
+		else if (ctx.options.trailingComma) {
+			if (ctx.options.lineWidth > 0) reqNewline || (reqNewline = lines.reduce((sum, line) => sum + line.length + 2, 2) + (str.length + 2) > ctx.options.lineWidth);
+			if (reqNewline) str += ",";
+		}
+		if (comment) str += lineComment(str, itemIndent, commentString(comment));
+		lines.push(str);
+		linesAtValue = lines.length;
+	}
+	const { start, end } = flowChars;
+	if (lines.length === 0) return start + end;
+	else {
+		if (!reqNewline) {
+			const len = lines.reduce((sum, line) => sum + line.length + 2, 2);
+			reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;
+		}
+		if (reqNewline) {
+			let str = start;
+			for (const line of lines) str += line ? `\n${indentStep}${indent}${line}` : "\n";
+			return `${str}\n${indent}${end}`;
+		} else return `${start}${fcPadding}${lines.join(" ")}${fcPadding}${end}`;
+	}
+}
+function addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) {
+	if (comment && chompKeep) comment = comment.replace(/^\n+/, "");
+	if (comment) {
+		const ic = indentComment(commentString(comment), indent);
+		lines.push(ic.trimStart());
+	}
+}
+//#endregion
+export { stringifyCollection };

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

@@ -0,0 +1,16 @@
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/stringify/stringifyComment.js
+/**
+* Stringifies a comment.
+*
+* Empty comment lines are left empty,
+* lines consisting of a single space are replaced by `#`,
+* and all other lines are prefixed with a `#`.
+*/
+const stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, "#");
+function indentComment(comment, indent) {
+	if (/^\n+$/.test(comment)) return comment.substring(1);
+	return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;
+}
+const lineComment = (str, indent, comment) => str.endsWith("\n") ? indentComment(comment, indent) : comment.includes("\n") ? "\n" + indentComment(comment, indent) : (str.endsWith(" ") ? "" : " ") + comment;
+//#endregion
+export { indentComment, lineComment, stringifyComment };