fumadocs-openapi 10.6.7 → 10.7.0

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/Alias.js

@@ -0,0 +1,91 @@
+import { ALIAS, hasAnchor, isAlias, isCollection, isPair } from "./identity.js";
+import { visit } from "../visit.js";
+import { anchorIsValid } from "../doc/anchors.js";
+import { toJS } from "./toJS.js";
+import { NodeBase } from "./Node.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/Alias.js
+var Alias = class extends NodeBase {
+	constructor(source) {
+		super(ALIAS);
+		this.source = source;
+		Object.defineProperty(this, "tag", { set() {
+			throw new Error("Alias nodes cannot have tags");
+		} });
+	}
+	/**
+	* Resolve the value of this alias within `doc`, finding the last
+	* instance of the `source` anchor before this node.
+	*/
+	resolve(doc, ctx) {
+		let nodes;
+		if (ctx?.aliasResolveCache) nodes = ctx.aliasResolveCache;
+		else {
+			nodes = [];
+			visit(doc, { Node: (_key, node) => {
+				if (isAlias(node) || hasAnchor(node)) nodes.push(node);
+			} });
+			if (ctx) ctx.aliasResolveCache = nodes;
+		}
+		let found = void 0;
+		for (const node of nodes) {
+			if (node === this) break;
+			if (node.anchor === this.source) found = node;
+		}
+		return found;
+	}
+	toJSON(_arg, ctx) {
+		if (!ctx) return { source: this.source };
+		const { anchors, doc, maxAliasCount } = ctx;
+		const source = this.resolve(doc, ctx);
+		if (!source) {
+			const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+			throw new ReferenceError(msg);
+		}
+		let data = anchors.get(source);
+		if (!data) {
+			toJS(source, null, ctx);
+			data = anchors.get(source);
+		}
+		/* istanbul ignore if */
+		if (data?.res === void 0) throw new ReferenceError("This should not happen: Alias anchor was not resolved?");
+		if (maxAliasCount >= 0) {
+			data.count += 1;
+			if (data.aliasCount === 0) data.aliasCount = getAliasCount(doc, source, anchors);
+			if (data.count * data.aliasCount > maxAliasCount) throw new ReferenceError("Excessive alias count indicates a resource exhaustion attack");
+		}
+		return data.res;
+	}
+	toString(ctx, _onComment, _onChompKeep) {
+		const src = `*${this.source}`;
+		if (ctx) {
+			anchorIsValid(this.source);
+			if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {
+				const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+				throw new Error(msg);
+			}
+			if (ctx.implicitKey) return `${src} `;
+		}
+		return src;
+	}
+};
+function getAliasCount(doc, node, anchors) {
+	if (isAlias(node)) {
+		const source = node.resolve(doc);
+		const anchor = anchors && source && anchors.get(source);
+		return anchor ? anchor.count * anchor.aliasCount : 0;
+	} else if (isCollection(node)) {
+		let count = 0;
+		for (const item of node.items) {
+			const c = getAliasCount(doc, item, anchors);
+			if (c > count) count = c;
+		}
+		return count;
+	} else if (isPair(node)) {
+		const kc = getAliasCount(doc, node.key, anchors);
+		const vc = getAliasCount(doc, node.value, anchors);
+		return Math.max(kc, vc);
+	}
+	return 1;
+}
+//#endregion
+export { Alias };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/Collection.js

@@ -0,0 +1,117 @@
+import { isCollection, isNode, isPair, isScalar } from "./identity.js";
+import { NodeBase } from "./Node.js";
+import { createNode } from "../doc/createNode.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/Collection.js
+function collectionFromPath(schema, path, value) {
+	let v = value;
+	for (let i = path.length - 1; i >= 0; --i) {
+		const k = path[i];
+		if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
+			const a = [];
+			a[k] = v;
+			v = a;
+		} else v = new Map([[k, v]]);
+	}
+	return createNode(v, void 0, {
+		aliasDuplicateObjects: false,
+		keepUndefined: false,
+		onAnchor: () => {
+			throw new Error("This should not happen, please report a bug.");
+		},
+		schema,
+		sourceObjects: /* @__PURE__ */ new Map()
+	});
+}
+const isEmptyPath = (path) => path == null || typeof path === "object" && !!path[Symbol.iterator]().next().done;
+var Collection = class extends NodeBase {
+	constructor(type, schema) {
+		super(type);
+		Object.defineProperty(this, "schema", {
+			value: schema,
+			configurable: true,
+			enumerable: false,
+			writable: true
+		});
+	}
+	/**
+	* Create a copy of this collection.
+	*
+	* @param schema - If defined, overwrites the original's schema
+	*/
+	clone(schema) {
+		const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+		if (schema) copy.schema = schema;
+		copy.items = copy.items.map((it) => isNode(it) || isPair(it) ? it.clone(schema) : it);
+		if (this.range) copy.range = this.range.slice();
+		return copy;
+	}
+	/**
+	* Adds a value to the collection. For `!!map` and `!!omap` the value must
+	* be a Pair instance or a `{ key, value }` object, which may not have a key
+	* that already exists in the map.
+	*/
+	addIn(path, value) {
+		if (isEmptyPath(path)) this.add(value);
+		else {
+			const [key, ...rest] = path;
+			const node = this.get(key, true);
+			if (isCollection(node)) node.addIn(rest, value);
+			else if (node === void 0 && this.schema) this.set(key, collectionFromPath(this.schema, rest, value));
+			else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+		}
+	}
+	/**
+	* Removes a value from the collection.
+	* @returns `true` if the item was found and removed.
+	*/
+	deleteIn(path) {
+		const [key, ...rest] = path;
+		if (rest.length === 0) return this.delete(key);
+		const node = this.get(key, true);
+		if (isCollection(node)) return node.deleteIn(rest);
+		else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+	}
+	/**
+	* Returns item at `key`, or `undefined` if not found. By default unwraps
+	* scalar values from their surrounding node; to disable set `keepScalar` to
+	* `true` (collections are always returned intact).
+	*/
+	getIn(path, keepScalar) {
+		const [key, ...rest] = path;
+		const node = this.get(key, true);
+		if (rest.length === 0) return !keepScalar && isScalar(node) ? node.value : node;
+		else return isCollection(node) ? node.getIn(rest, keepScalar) : void 0;
+	}
+	hasAllNullValues(allowScalar) {
+		return this.items.every((node) => {
+			if (!isPair(node)) return false;
+			const n = node.value;
+			return n == null || allowScalar && isScalar(n) && n.value == null && !n.commentBefore && !n.comment && !n.tag;
+		});
+	}
+	/**
+	* Checks if the collection includes a value with the key `key`.
+	*/
+	hasIn(path) {
+		const [key, ...rest] = path;
+		if (rest.length === 0) return this.has(key);
+		const node = this.get(key, true);
+		return isCollection(node) ? node.hasIn(rest) : false;
+	}
+	/**
+	* Sets a value in this collection. For `!!set`, `value` needs to be a
+	* boolean to add/remove the item from the set.
+	*/
+	setIn(path, value) {
+		const [key, ...rest] = path;
+		if (rest.length === 0) this.set(key, value);
+		else {
+			const node = this.get(key, true);
+			if (isCollection(node)) node.setIn(rest, value);
+			else if (node === void 0 && this.schema) this.set(key, collectionFromPath(this.schema, rest, value));
+			else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+		}
+	}
+};
+//#endregion
+export { Collection, collectionFromPath, isEmptyPath };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/Node.js

@@ -0,0 +1,32 @@
+import { NODE_TYPE, isDocument } from "./identity.js";
+import { applyReviver } from "../doc/applyReviver.js";
+import { toJS } from "./toJS.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/Node.js
+var NodeBase = class {
+	constructor(type) {
+		Object.defineProperty(this, NODE_TYPE, { value: type });
+	}
+	/** Create a copy of this node.  */
+	clone() {
+		const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+		if (this.range) copy.range = this.range.slice();
+		return copy;
+	}
+	/** A plain JavaScript representation of this node. */
+	toJS(doc, { mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
+		if (!isDocument(doc)) throw new TypeError("A document argument is required");
+		const ctx = {
+			anchors: /* @__PURE__ */ new Map(),
+			doc,
+			keep: true,
+			mapAsMap: mapAsMap === true,
+			mapKeyWarned: false,
+			maxAliasCount: typeof maxAliasCount === "number" ? maxAliasCount : 100
+		};
+		const res = toJS(this, "", ctx);
+		if (typeof onAnchor === "function") for (const { count, res } of ctx.anchors.values()) onAnchor(res, count);
+		return typeof reviver === "function" ? applyReviver(reviver, { "": res }, "", res) : res;
+	}
+};
+//#endregion
+export { NodeBase };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/Pair.js

@@ -0,0 +1,29 @@
+import { NODE_TYPE, PAIR, isNode } from "./identity.js";
+import { createNode } from "../doc/createNode.js";
+import { stringifyPair } from "../stringify/stringifyPair.js";
+import { addPairToJSMap } from "./addPairToJSMap.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/Pair.js
+function createPair(key, value, ctx) {
+	return new Pair(createNode(key, void 0, ctx), createNode(value, void 0, ctx));
+}
+var Pair = class Pair {
+	constructor(key, value = null) {
+		Object.defineProperty(this, NODE_TYPE, { value: PAIR });
+		this.key = key;
+		this.value = value;
+	}
+	clone(schema) {
+		let { key, value } = this;
+		if (isNode(key)) key = key.clone(schema);
+		if (isNode(value)) value = value.clone(schema);
+		return new Pair(key, value);
+	}
+	toJSON(_, ctx) {
+		return addPairToJSMap(ctx, ctx?.mapAsMap ? /* @__PURE__ */ new Map() : {}, this);
+	}
+	toString(ctx, onComment, onChompKeep) {
+		return ctx?.doc ? stringifyPair(this, ctx, onComment, onChompKeep) : JSON.stringify(this);
+	}
+};
+//#endregion
+export { Pair, createPair };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/Scalar.js

@@ -0,0 +1,24 @@
+import { SCALAR } from "./identity.js";
+import { toJS } from "./toJS.js";
+import { NodeBase } from "./Node.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/Scalar.js
+const isScalarValue = (value) => !value || typeof value !== "function" && typeof value !== "object";
+var Scalar = class extends NodeBase {
+	constructor(value) {
+		super(SCALAR);
+		this.value = value;
+	}
+	toJSON(arg, ctx) {
+		return ctx?.keep ? this.value : toJS(this.value, arg, ctx);
+	}
+	toString() {
+		return String(this.value);
+	}
+};
+Scalar.BLOCK_FOLDED = "BLOCK_FOLDED";
+Scalar.BLOCK_LITERAL = "BLOCK_LITERAL";
+Scalar.PLAIN = "PLAIN";
+Scalar.QUOTE_DOUBLE = "QUOTE_DOUBLE";
+Scalar.QUOTE_SINGLE = "QUOTE_SINGLE";
+//#endregion
+export { Scalar, isScalarValue };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/YAMLMap.js

@@ -0,0 +1,106 @@
+import { MAP, isPair, isScalar } from "./identity.js";
+import { isScalarValue } from "./Scalar.js";
+import { Collection } from "./Collection.js";
+import { addPairToJSMap } from "./addPairToJSMap.js";
+import { Pair, createPair } from "./Pair.js";
+import { stringifyCollection } from "../stringify/stringifyCollection.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/YAMLMap.js
+function findPair(items, key) {
+	const k = isScalar(key) ? key.value : key;
+	for (const it of items) if (isPair(it)) {
+		if (it.key === key || it.key === k) return it;
+		if (isScalar(it.key) && it.key.value === k) return it;
+	}
+}
+var YAMLMap = class extends Collection {
+	static get tagName() {
+		return "tag:yaml.org,2002:map";
+	}
+	constructor(schema) {
+		super(MAP, schema);
+		this.items = [];
+	}
+	/**
+	* A generic collection parsing method that can be extended
+	* to other node classes that inherit from YAMLMap
+	*/
+	static from(schema, obj, ctx) {
+		const { keepUndefined, replacer } = ctx;
+		const map = new this(schema);
+		const add = (key, value) => {
+			if (typeof replacer === "function") value = replacer.call(obj, key, value);
+			else if (Array.isArray(replacer) && !replacer.includes(key)) return;
+			if (value !== void 0 || keepUndefined) map.items.push(createPair(key, value, ctx));
+		};
+		if (obj instanceof Map) for (const [key, value] of obj) add(key, value);
+		else if (obj && typeof obj === "object") for (const key of Object.keys(obj)) add(key, obj[key]);
+		if (typeof schema.sortMapEntries === "function") map.items.sort(schema.sortMapEntries);
+		return map;
+	}
+	/**
+	* Adds a value to the collection.
+	*
+	* @param overwrite - If not set `true`, using a key that is already in the
+	*   collection will throw. Otherwise, overwrites the previous value.
+	*/
+	add(pair, overwrite) {
+		let _pair;
+		if (isPair(pair)) _pair = pair;
+		else if (!pair || typeof pair !== "object" || !("key" in pair)) _pair = new Pair(pair, pair?.value);
+		else _pair = new Pair(pair.key, pair.value);
+		const prev = findPair(this.items, _pair.key);
+		const sortEntries = this.schema?.sortMapEntries;
+		if (prev) {
+			if (!overwrite) throw new Error(`Key ${_pair.key} already set`);
+			if (isScalar(prev.value) && isScalarValue(_pair.value)) prev.value.value = _pair.value;
+			else prev.value = _pair.value;
+		} else if (sortEntries) {
+			const i = this.items.findIndex((item) => sortEntries(_pair, item) < 0);
+			if (i === -1) this.items.push(_pair);
+			else this.items.splice(i, 0, _pair);
+		} else this.items.push(_pair);
+	}
+	delete(key) {
+		const it = findPair(this.items, key);
+		if (!it) return false;
+		return this.items.splice(this.items.indexOf(it), 1).length > 0;
+	}
+	get(key, keepScalar) {
+		const node = findPair(this.items, key)?.value;
+		return (!keepScalar && isScalar(node) ? node.value : node) ?? void 0;
+	}
+	has(key) {
+		return !!findPair(this.items, key);
+	}
+	set(key, value) {
+		this.add(new Pair(key, value), true);
+	}
+	/**
+	* @param ctx - Conversion context, originally set in Document#toJS()
+	* @param {Class} Type - If set, forces the returned collection type
+	* @returns Instance of Type, Map, or Object
+	*/
+	toJSON(_, ctx, Type) {
+		const map = Type ? new Type() : ctx?.mapAsMap ? /* @__PURE__ */ new Map() : {};
+		if (ctx?.onCreate) ctx.onCreate(map);
+		for (const item of this.items) addPairToJSMap(ctx, map, item);
+		return map;
+	}
+	toString(ctx, onComment, onChompKeep) {
+		if (!ctx) return JSON.stringify(this);
+		for (const item of this.items) if (!isPair(item)) throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);
+		if (!ctx.allNullValues && this.hasAllNullValues(false)) ctx = Object.assign({}, ctx, { allNullValues: true });
+		return stringifyCollection(this, ctx, {
+			blockItemPrefix: "",
+			flowChars: {
+				start: "{",
+				end: "}"
+			},
+			itemIndent: ctx.indent || "",
+			onChompKeep,
+			onComment
+		});
+	}
+};
+//#endregion
+export { YAMLMap, findPair };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/YAMLSeq.js

@@ -0,0 +1,104 @@
+import { SEQ, isScalar } from "./identity.js";
+import { toJS } from "./toJS.js";
+import { isScalarValue } from "./Scalar.js";
+import { createNode } from "../doc/createNode.js";
+import { Collection } from "./Collection.js";
+import { stringifyCollection } from "../stringify/stringifyCollection.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/YAMLSeq.js
+var YAMLSeq = class extends Collection {
+	static get tagName() {
+		return "tag:yaml.org,2002:seq";
+	}
+	constructor(schema) {
+		super(SEQ, schema);
+		this.items = [];
+	}
+	add(value) {
+		this.items.push(value);
+	}
+	/**
+	* Removes a value from the collection.
+	*
+	* `key` must contain a representation of an integer for this to succeed.
+	* It may be wrapped in a `Scalar`.
+	*
+	* @returns `true` if the item was found and removed.
+	*/
+	delete(key) {
+		const idx = asItemIndex(key);
+		if (typeof idx !== "number") return false;
+		return this.items.splice(idx, 1).length > 0;
+	}
+	get(key, keepScalar) {
+		const idx = asItemIndex(key);
+		if (typeof idx !== "number") return void 0;
+		const it = this.items[idx];
+		return !keepScalar && isScalar(it) ? it.value : it;
+	}
+	/**
+	* Checks if the collection includes a value with the key `key`.
+	*
+	* `key` must contain a representation of an integer for this to succeed.
+	* It may be wrapped in a `Scalar`.
+	*/
+	has(key) {
+		const idx = asItemIndex(key);
+		return typeof idx === "number" && idx < this.items.length;
+	}
+	/**
+	* Sets a value in this collection. For `!!set`, `value` needs to be a
+	* boolean to add/remove the item from the set.
+	*
+	* If `key` does not contain a representation of an integer, this will throw.
+	* It may be wrapped in a `Scalar`.
+	*/
+	set(key, value) {
+		const idx = asItemIndex(key);
+		if (typeof idx !== "number") throw new Error(`Expected a valid index, not ${key}.`);
+		const prev = this.items[idx];
+		if (isScalar(prev) && isScalarValue(value)) prev.value = value;
+		else this.items[idx] = value;
+	}
+	toJSON(_, ctx) {
+		const seq = [];
+		if (ctx?.onCreate) ctx.onCreate(seq);
+		let i = 0;
+		for (const item of this.items) seq.push(toJS(item, String(i++), ctx));
+		return seq;
+	}
+	toString(ctx, onComment, onChompKeep) {
+		if (!ctx) return JSON.stringify(this);
+		return stringifyCollection(this, ctx, {
+			blockItemPrefix: "- ",
+			flowChars: {
+				start: "[",
+				end: "]"
+			},
+			itemIndent: (ctx.indent || "") + "  ",
+			onChompKeep,
+			onComment
+		});
+	}
+	static from(schema, obj, ctx) {
+		const { replacer } = ctx;
+		const seq = new this(schema);
+		if (obj && Symbol.iterator in Object(obj)) {
+			let i = 0;
+			for (let it of obj) {
+				if (typeof replacer === "function") {
+					const key = obj instanceof Set ? it : String(i++);
+					it = replacer.call(obj, key, it);
+				}
+				seq.items.push(createNode(it, void 0, ctx));
+			}
+		}
+		return seq;
+	}
+};
+function asItemIndex(key) {
+	let idx = isScalar(key) ? key.value : key;
+	if (idx && typeof idx === "string") idx = Number(idx);
+	return typeof idx === "number" && Number.isInteger(idx) && idx >= 0 ? idx : null;
+}
+//#endregion
+export { YAMLSeq };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/addPairToJSMap.js

@@ -0,0 +1,49 @@
+import { isNode } from "./identity.js";
+import { toJS } from "./toJS.js";
+import { createStringifyContext } from "../stringify/stringify.js";
+import { warn } from "../log.js";
+import { addMergeToJSMap, isMergeKey } from "../schema/yaml-1.1/merge.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/addPairToJSMap.js
+function addPairToJSMap(ctx, map, { key, value }) {
+	if (isNode(key) && key.addToJSMap) key.addToJSMap(ctx, map, value);
+	else if (isMergeKey(ctx, key)) addMergeToJSMap(ctx, map, value);
+	else {
+		const jsKey = toJS(key, "", ctx);
+		if (map instanceof Map) map.set(jsKey, toJS(value, jsKey, ctx));
+		else if (map instanceof Set) map.add(jsKey);
+		else {
+			const stringKey = stringifyKey(key, jsKey, ctx);
+			const jsValue = toJS(value, stringKey, ctx);
+			if (stringKey in map) Object.defineProperty(map, stringKey, {
+				value: jsValue,
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+			else map[stringKey] = jsValue;
+		}
+	}
+	return map;
+}
+function stringifyKey(key, jsKey, ctx) {
+	if (jsKey === null) return "";
+	if (typeof jsKey !== "object") return String(jsKey);
+	if (isNode(key) && ctx?.doc) {
+		const strCtx = createStringifyContext(ctx.doc, {});
+		strCtx.anchors = /* @__PURE__ */ new Set();
+		for (const node of ctx.anchors.keys()) strCtx.anchors.add(node.anchor);
+		strCtx.inFlow = true;
+		strCtx.inStringifyKey = true;
+		const strKey = key.toString(strCtx);
+		if (!ctx.mapKeyWarned) {
+			let jsonStr = JSON.stringify(strKey);
+			if (jsonStr.length > 40) jsonStr = jsonStr.substring(0, 36) + "...\"";
+			warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
+			ctx.mapKeyWarned = true;
+		}
+		return strKey;
+	}
+	return JSON.stringify(jsKey);
+}
+//#endregion
+export { addPairToJSMap };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/identity.js

@@ -0,0 +1,33 @@
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/identity.js
+const ALIAS = Symbol.for("yaml.alias");
+const DOC = Symbol.for("yaml.document");
+const MAP = Symbol.for("yaml.map");
+const PAIR = Symbol.for("yaml.pair");
+const SCALAR = Symbol.for("yaml.scalar");
+const SEQ = Symbol.for("yaml.seq");
+const NODE_TYPE = Symbol.for("yaml.node.type");
+const isAlias = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === ALIAS;
+const isDocument = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === DOC;
+const isMap = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === MAP;
+const isPair = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === PAIR;
+const isScalar = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SCALAR;
+const isSeq = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SEQ;
+function isCollection(node) {
+	if (node && typeof node === "object") switch (node[NODE_TYPE]) {
+		case MAP:
+		case SEQ: return true;
+	}
+	return false;
+}
+function isNode(node) {
+	if (node && typeof node === "object") switch (node[NODE_TYPE]) {
+		case ALIAS:
+		case MAP:
+		case SCALAR:
+		case SEQ: return true;
+	}
+	return false;
+}
+const hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor;
+//#endregion
+export { ALIAS, DOC, MAP, NODE_TYPE, PAIR, SCALAR, SEQ, hasAnchor, isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/toJS.js

@@ -0,0 +1,35 @@
+import { hasAnchor } from "./identity.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/toJS.js
+/**
+* Recursively convert any node or its contents to native JavaScript
+*
+* @param value - The input value
+* @param arg - If `value` defines a `toJSON()` method, use this
+*   as its first argument
+* @param ctx - Conversion context, originally set in Document#toJS(). If
+*   `{ keep: true }` is not set, output should be suitable for JSON
+*   stringification.
+*/
+function toJS(value, arg, ctx) {
+	if (Array.isArray(value)) return value.map((v, i) => toJS(v, String(i), ctx));
+	if (value && typeof value.toJSON === "function") {
+		if (!ctx || !hasAnchor(value)) return value.toJSON(arg, ctx);
+		const data = {
+			aliasCount: 0,
+			count: 1,
+			res: void 0
+		};
+		ctx.anchors.set(value, data);
+		ctx.onCreate = (res) => {
+			data.res = res;
+			delete ctx.onCreate;
+		};
+		const res = value.toJSON(arg, ctx);
+		if (ctx.onCreate) ctx.onCreate(res);
+		return res;
+	}
+	if (typeof value === "bigint" && !ctx?.keep) return Number(value);
+	return value;
+}
+//#endregion
+export { toJS };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/parse/cst-scalar.js

@@ -0,0 +1,3 @@
+import "../stringify/stringifyString.js";
+import "../compose/resolve-block-scalar.js";
+import "../compose/resolve-flow-scalar.js";