fumadocs-openapi 10.6.7 → 10.7.0

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/public-api.js

@@ -0,0 +1,44 @@
+import { warn } from "./log.js";
+import "./doc/Document.js";
+import { YAMLParseError, prettifyError } from "./errors.js";
+import { Composer } from "./compose/composer.js";
+import { LineCounter } from "./parse/line-counter.js";
+import { Parser } from "./parse/parser.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/public-api.js
+function parseOptions(options) {
+	const prettyErrors = options.prettyErrors !== false;
+	return {
+		lineCounter: options.lineCounter || prettyErrors && new LineCounter() || null,
+		prettyErrors
+	};
+}
+/** Parse an input string into a single YAML.Document */
+function parseDocument(source, options = {}) {
+	const { lineCounter, prettyErrors } = parseOptions(options);
+	const parser = new Parser(lineCounter?.addNewLine);
+	const composer = new Composer(options);
+	let doc = null;
+	for (const _doc of composer.compose(parser.parse(source), true, source.length)) if (!doc) doc = _doc;
+	else if (doc.options.logLevel !== "silent") {
+		doc.errors.push(new YAMLParseError(_doc.range.slice(0, 2), "MULTIPLE_DOCS", "Source contains multiple documents; please use YAML.parseAllDocuments()"));
+		break;
+	}
+	if (prettyErrors && lineCounter) {
+		doc.errors.forEach(prettifyError(source, lineCounter));
+		doc.warnings.forEach(prettifyError(source, lineCounter));
+	}
+	return doc;
+}
+function parse(src, reviver, options) {
+	let _reviver = void 0;
+	if (typeof reviver === "function") _reviver = reviver;
+	else if (options === void 0 && reviver && typeof reviver === "object") options = reviver;
+	const doc = parseDocument(src, options);
+	if (!doc) return null;
+	doc.warnings.forEach((warning) => warn(doc.options.logLevel, warning));
+	if (doc.errors.length > 0) if (doc.options.logLevel !== "silent") throw doc.errors[0];
+	else doc.errors = [];
+	return doc.toJS(Object.assign({ reviver: _reviver }, options));
+}
+//#endregion
+export { parse, parseDocument };

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

@@ -0,0 +1,27 @@
+import { MAP, SCALAR, SEQ } from "../nodes/identity.js";
+import { map } from "./common/map.js";
+import { seq } from "./common/seq.js";
+import { string } from "./common/string.js";
+import { coreKnownTags, getTags } from "./tags.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/Schema.js
+const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+var Schema = class Schema {
+	constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {
+		this.compat = Array.isArray(compat) ? getTags(compat, "compat") : compat ? getTags(null, compat) : null;
+		this.name = typeof schema === "string" && schema || "core";
+		this.knownTags = resolveKnownTags ? coreKnownTags : {};
+		this.tags = getTags(customTags, this.name, merge);
+		this.toStringOptions = toStringDefaults ?? null;
+		Object.defineProperty(this, MAP, { value: map });
+		Object.defineProperty(this, SCALAR, { value: string });
+		Object.defineProperty(this, SEQ, { value: seq });
+		this.sortMapEntries = typeof sortMapEntries === "function" ? sortMapEntries : sortMapEntries === true ? sortMapEntriesByKey : null;
+	}
+	clone() {
+		const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this));
+		copy.tags = this.tags.slice();
+		return copy;
+	}
+};
+//#endregion
+export { Schema };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/common/map.js

@@ -0,0 +1,16 @@
+import { isMap } from "../../nodes/identity.js";
+import { YAMLMap } from "../../nodes/YAMLMap.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/common/map.js
+const map = {
+	collection: "map",
+	default: true,
+	nodeClass: YAMLMap,
+	tag: "tag:yaml.org,2002:map",
+	resolve(map, onError) {
+		if (!isMap(map)) onError("Expected a mapping for this tag");
+		return map;
+	},
+	createNode: (schema, obj, ctx) => YAMLMap.from(schema, obj, ctx)
+};
+//#endregion
+export { map };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/common/null.js

@@ -0,0 +1,13 @@
+import { Scalar } from "../../nodes/Scalar.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/common/null.js
+const nullTag = {
+	identify: (value) => value == null,
+	createNode: () => new Scalar(null),
+	default: true,
+	tag: "tag:yaml.org,2002:null",
+	test: /^(?:~|[Nn]ull|NULL)?$/,
+	resolve: () => new Scalar(null),
+	stringify: ({ source }, ctx) => typeof source === "string" && nullTag.test.test(source) ? source : ctx.options.nullStr
+};
+//#endregion
+export { nullTag };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/common/seq.js

@@ -0,0 +1,16 @@
+import { isSeq } from "../../nodes/identity.js";
+import { YAMLSeq } from "../../nodes/YAMLSeq.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/common/seq.js
+const seq = {
+	collection: "seq",
+	default: true,
+	nodeClass: YAMLSeq,
+	tag: "tag:yaml.org,2002:seq",
+	resolve(seq, onError) {
+		if (!isSeq(seq)) onError("Expected a sequence for this tag");
+		return seq;
+	},
+	createNode: (schema, obj, ctx) => YAMLSeq.from(schema, obj, ctx)
+};
+//#endregion
+export { seq };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/common/string.js

@@ -0,0 +1,14 @@
+import { stringifyString } from "../../stringify/stringifyString.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/common/string.js
+const string = {
+	identify: (value) => typeof value === "string",
+	default: true,
+	tag: "tag:yaml.org,2002:str",
+	resolve: (str) => str,
+	stringify(item, ctx, onComment, onChompKeep) {
+		ctx = Object.assign({ actualString: true }, ctx);
+		return stringifyString(item, ctx, onComment, onChompKeep);
+	}
+};
+//#endregion
+export { string };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/core/bool.js

@@ -0,0 +1,17 @@
+import { Scalar } from "../../nodes/Scalar.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/core/bool.js
+const boolTag = {
+	identify: (value) => typeof value === "boolean",
+	default: true,
+	tag: "tag:yaml.org,2002:bool",
+	test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
+	resolve: (str) => new Scalar(str[0] === "t" || str[0] === "T"),
+	stringify({ source, value }, ctx) {
+		if (source && boolTag.test.test(source)) {
+			if (value === (source[0] === "t" || source[0] === "T")) return source;
+		}
+		return value ? ctx.options.trueStr : ctx.options.falseStr;
+	}
+};
+//#endregion
+export { boolTag };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/core/float.js

@@ -0,0 +1,38 @@
+import { Scalar } from "../../nodes/Scalar.js";
+import { stringifyNumber } from "../../stringify/stringifyNumber.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/core/float.js
+const floatNaN = {
+	identify: (value) => typeof value === "number",
+	default: true,
+	tag: "tag:yaml.org,2002:float",
+	test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
+	resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
+	stringify: stringifyNumber
+};
+const floatExp = {
+	identify: (value) => typeof value === "number",
+	default: true,
+	tag: "tag:yaml.org,2002:float",
+	format: "EXP",
+	test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
+	resolve: (str) => parseFloat(str),
+	stringify(node) {
+		const num = Number(node.value);
+		return isFinite(num) ? num.toExponential() : stringifyNumber(node);
+	}
+};
+const float = {
+	identify: (value) => typeof value === "number",
+	default: true,
+	tag: "tag:yaml.org,2002:float",
+	test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
+	resolve(str) {
+		const node = new Scalar(parseFloat(str));
+		const dot = str.indexOf(".");
+		if (dot !== -1 && str[str.length - 1] === "0") node.minFractionDigits = str.length - dot - 1;
+		return node;
+	},
+	stringify: stringifyNumber
+};
+//#endregion
+export { float, floatExp, floatNaN };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/core/int.js

@@ -0,0 +1,37 @@
+import { stringifyNumber } from "../../stringify/stringifyNumber.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/core/int.js
+const intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
+const intResolve = (str, offset, radix, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix);
+function intStringify(node, radix, prefix) {
+	const { value } = node;
+	if (intIdentify(value) && value >= 0) return prefix + value.toString(radix);
+	return stringifyNumber(node);
+}
+const intOct = {
+	identify: (value) => intIdentify(value) && value >= 0,
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	format: "OCT",
+	test: /^0o[0-7]+$/,
+	resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt),
+	stringify: (node) => intStringify(node, 8, "0o")
+};
+const int = {
+	identify: intIdentify,
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	test: /^[-+]?[0-9]+$/,
+	resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
+	stringify: stringifyNumber
+};
+const intHex = {
+	identify: (value) => intIdentify(value) && value >= 0,
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	format: "HEX",
+	test: /^0x[0-9a-fA-F]+$/,
+	resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),
+	stringify: (node) => intStringify(node, 16, "0x")
+};
+//#endregion
+export { int, intHex, intOct };

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

@@ -0,0 +1,23 @@
+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 { boolTag } from "./bool.js";
+import { float, floatExp, floatNaN } from "./float.js";
+import { int, intHex, intOct } from "./int.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/core/schema.js
+const schema = [
+	map,
+	seq,
+	string,
+	nullTag,
+	boolTag,
+	intOct,
+	int,
+	intHex,
+	floatNaN,
+	floatExp,
+	float
+];
+//#endregion
+export { schema };

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

@@ -0,0 +1,61 @@
+import { Scalar } from "../../nodes/Scalar.js";
+import { map } from "../common/map.js";
+import { seq } from "../common/seq.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/json/schema.js
+function intIdentify(value) {
+	return typeof value === "bigint" || Number.isInteger(value);
+}
+const stringifyJSON = ({ value }) => JSON.stringify(value);
+const jsonScalars = [
+	{
+		identify: (value) => typeof value === "string",
+		default: true,
+		tag: "tag:yaml.org,2002:str",
+		resolve: (str) => str,
+		stringify: stringifyJSON
+	},
+	{
+		identify: (value) => value == null,
+		createNode: () => new Scalar(null),
+		default: true,
+		tag: "tag:yaml.org,2002:null",
+		test: /^null$/,
+		resolve: () => null,
+		stringify: stringifyJSON
+	},
+	{
+		identify: (value) => typeof value === "boolean",
+		default: true,
+		tag: "tag:yaml.org,2002:bool",
+		test: /^true$|^false$/,
+		resolve: (str) => str === "true",
+		stringify: stringifyJSON
+	},
+	{
+		identify: intIdentify,
+		default: true,
+		tag: "tag:yaml.org,2002:int",
+		test: /^-?(?:0|[1-9][0-9]*)$/,
+		resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10),
+		stringify: ({ value }) => intIdentify(value) ? value.toString() : JSON.stringify(value)
+	},
+	{
+		identify: (value) => typeof value === "number",
+		default: true,
+		tag: "tag:yaml.org,2002:float",
+		test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
+		resolve: (str) => parseFloat(str),
+		stringify: stringifyJSON
+	}
+];
+const schema = [map, seq].concat(jsonScalars, {
+	default: true,
+	tag: "",
+	test: /^/,
+	resolve(str, onError) {
+		onError(`Unresolved plain scalar ${JSON.stringify(str)}`);
+		return str;
+	}
+});
+//#endregion
+export { schema };

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

@@ -0,0 +1,81 @@
+import { merge } from "./yaml-1.1/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 { boolTag } from "./core/bool.js";
+import { float, floatExp, floatNaN } from "./core/float.js";
+import { int, intHex, intOct } from "./core/int.js";
+import { schema } from "./core/schema.js";
+import { schema as schema$1 } from "./json/schema.js";
+import { binary } from "./yaml-1.1/binary.js";
+import { pairs } from "./yaml-1.1/pairs.js";
+import { omap } from "./yaml-1.1/omap.js";
+import { set } from "./yaml-1.1/set.js";
+import { floatTime, intTime, timestamp } from "./yaml-1.1/timestamp.js";
+import { schema as schema$2 } from "./yaml-1.1/schema.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/tags.js
+const schemas = new Map([
+	["core", schema],
+	["failsafe", [
+		map,
+		seq,
+		string
+	]],
+	["json", schema$1],
+	["yaml11", schema$2],
+	["yaml-1.1", schema$2]
+]);
+const tagsByName = {
+	binary,
+	bool: boolTag,
+	float,
+	floatExp,
+	floatNaN,
+	floatTime,
+	int,
+	intHex,
+	intOct,
+	intTime,
+	map,
+	merge,
+	null: nullTag,
+	omap,
+	pairs,
+	seq,
+	set,
+	timestamp
+};
+const coreKnownTags = {
+	"tag:yaml.org,2002:binary": binary,
+	"tag:yaml.org,2002:merge": merge,
+	"tag:yaml.org,2002:omap": omap,
+	"tag:yaml.org,2002:pairs": pairs,
+	"tag:yaml.org,2002:set": set,
+	"tag:yaml.org,2002:timestamp": timestamp
+};
+function getTags(customTags, schemaName, addMergeTag) {
+	const schemaTags = schemas.get(schemaName);
+	if (schemaTags && !customTags) return addMergeTag && !schemaTags.includes(merge) ? schemaTags.concat(merge) : schemaTags.slice();
+	let tags = schemaTags;
+	if (!tags) if (Array.isArray(customTags)) tags = [];
+	else {
+		const keys = Array.from(schemas.keys()).filter((key) => key !== "yaml11").map((key) => JSON.stringify(key)).join(", ");
+		throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`);
+	}
+	if (Array.isArray(customTags)) for (const tag of customTags) tags = tags.concat(tag);
+	else if (typeof customTags === "function") tags = customTags(tags.slice());
+	if (addMergeTag) tags = tags.concat(merge);
+	return tags.reduce((tags, tag) => {
+		const tagObj = typeof tag === "string" ? tagsByName[tag] : tag;
+		if (!tagObj) {
+			const tagName = JSON.stringify(tag);
+			const keys = Object.keys(tagsByName).map((key) => JSON.stringify(key)).join(", ");
+			throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`);
+		}
+		if (!tags.includes(tagObj)) tags.push(tagObj);
+		return tags;
+	}, []);
+}
+//#endregion
+export { coreKnownTags, getTags };

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

@@ -0,0 +1,44 @@
+import { Scalar } from "../../nodes/Scalar.js";
+import { stringifyString } from "../../stringify/stringifyString.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/binary.js
+const binary = {
+	identify: (value) => value instanceof Uint8Array,
+	default: false,
+	tag: "tag:yaml.org,2002:binary",
+	resolve(src, onError) {
+		if (typeof atob === "function") {
+			const str = atob(src.replace(/[\n\r]/g, ""));
+			const buffer = new Uint8Array(str.length);
+			for (let i = 0; i < str.length; ++i) buffer[i] = str.charCodeAt(i);
+			return buffer;
+		} else {
+			onError("This environment does not support reading binary tags; either Buffer or atob is required");
+			return src;
+		}
+	},
+	stringify({ comment, type, value }, ctx, onComment, onChompKeep) {
+		if (!value) return "";
+		const buf = value;
+		let str;
+		if (typeof btoa === "function") {
+			let s = "";
+			for (let i = 0; i < buf.length; ++i) s += String.fromCharCode(buf[i]);
+			str = btoa(s);
+		} else throw new Error("This environment does not support writing binary tags; either Buffer or btoa is required");
+		type ?? (type = Scalar.BLOCK_LITERAL);
+		if (type !== Scalar.QUOTE_DOUBLE) {
+			const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);
+			const n = Math.ceil(str.length / lineWidth);
+			const lines = new Array(n);
+			for (let i = 0, o = 0; i < n; ++i, o += lineWidth) lines[i] = str.substr(o, lineWidth);
+			str = lines.join(type === Scalar.BLOCK_LITERAL ? "\n" : " ");
+		}
+		return stringifyString({
+			comment,
+			type,
+			value: str
+		}, ctx, onComment, onChompKeep);
+	}
+};
+//#endregion
+export { binary };

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

@@ -0,0 +1,24 @@
+import { Scalar } from "../../nodes/Scalar.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/bool.js
+function boolStringify({ value, source }, ctx) {
+	if (source && (value ? trueTag : falseTag).test.test(source)) return source;
+	return value ? ctx.options.trueStr : ctx.options.falseStr;
+}
+const trueTag = {
+	identify: (value) => value === true,
+	default: true,
+	tag: "tag:yaml.org,2002:bool",
+	test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
+	resolve: () => new Scalar(true),
+	stringify: boolStringify
+};
+const falseTag = {
+	identify: (value) => value === false,
+	default: true,
+	tag: "tag:yaml.org,2002:bool",
+	test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/,
+	resolve: () => new Scalar(false),
+	stringify: boolStringify
+};
+//#endregion
+export { falseTag, trueTag };

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

@@ -0,0 +1,41 @@
+import { Scalar } from "../../nodes/Scalar.js";
+import { stringifyNumber } from "../../stringify/stringifyNumber.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/float.js
+const floatNaN = {
+	identify: (value) => typeof value === "number",
+	default: true,
+	tag: "tag:yaml.org,2002:float",
+	test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
+	resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
+	stringify: stringifyNumber
+};
+const floatExp = {
+	identify: (value) => typeof value === "number",
+	default: true,
+	tag: "tag:yaml.org,2002:float",
+	format: "EXP",
+	test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/,
+	resolve: (str) => parseFloat(str.replace(/_/g, "")),
+	stringify(node) {
+		const num = Number(node.value);
+		return isFinite(num) ? num.toExponential() : stringifyNumber(node);
+	}
+};
+const float = {
+	identify: (value) => typeof value === "number",
+	default: true,
+	tag: "tag:yaml.org,2002:float",
+	test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/,
+	resolve(str) {
+		const node = new Scalar(parseFloat(str.replace(/_/g, "")));
+		const dot = str.indexOf(".");
+		if (dot !== -1) {
+			const f = str.substring(dot + 1).replace(/_/g, "");
+			if (f[f.length - 1] === "0") node.minFractionDigits = f.length;
+		}
+		return node;
+	},
+	stringify: stringifyNumber
+};
+//#endregion
+export { float, floatExp, floatNaN };

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

@@ -0,0 +1,70 @@
+import { stringifyNumber } from "../../stringify/stringifyNumber.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/int.js
+const intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
+function intResolve(str, offset, radix, { intAsBigInt }) {
+	const sign = str[0];
+	if (sign === "-" || sign === "+") offset += 1;
+	str = str.substring(offset).replace(/_/g, "");
+	if (intAsBigInt) {
+		switch (radix) {
+			case 2:
+				str = `0b${str}`;
+				break;
+			case 8:
+				str = `0o${str}`;
+				break;
+			case 16:
+				str = `0x${str}`;
+				break;
+		}
+		const n = BigInt(str);
+		return sign === "-" ? BigInt(-1) * n : n;
+	}
+	const n = parseInt(str, radix);
+	return sign === "-" ? -1 * n : n;
+}
+function intStringify(node, radix, prefix) {
+	const { value } = node;
+	if (intIdentify(value)) {
+		const str = value.toString(radix);
+		return value < 0 ? "-" + prefix + str.substr(1) : prefix + str;
+	}
+	return stringifyNumber(node);
+}
+const intBin = {
+	identify: intIdentify,
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	format: "BIN",
+	test: /^[-+]?0b[0-1_]+$/,
+	resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt),
+	stringify: (node) => intStringify(node, 2, "0b")
+};
+const intOct = {
+	identify: intIdentify,
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	format: "OCT",
+	test: /^[-+]?0[0-7_]+$/,
+	resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt),
+	stringify: (node) => intStringify(node, 8, "0")
+};
+const int = {
+	identify: intIdentify,
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	test: /^[-+]?[0-9][0-9_]*$/,
+	resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
+	stringify: stringifyNumber
+};
+const intHex = {
+	identify: intIdentify,
+	default: true,
+	tag: "tag:yaml.org,2002:int",
+	format: "HEX",
+	test: /^[-+]?0x[0-9a-fA-F_]+$/,
+	resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),
+	stringify: (node) => intStringify(node, 16, "0x")
+};
+//#endregion
+export { int, intBin, intHex, intOct };

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

@@ -0,0 +1,36 @@
+import { isAlias, isMap, isScalar, isSeq } from "../../nodes/identity.js";
+import { Scalar } from "../../nodes/Scalar.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/schema/yaml-1.1/merge.js
+const MERGE_KEY = "<<";
+const merge = {
+	identify: (value) => value === MERGE_KEY || typeof value === "symbol" && value.description === MERGE_KEY,
+	default: "key",
+	tag: "tag:yaml.org,2002:merge",
+	test: /^<<$/,
+	resolve: () => Object.assign(new Scalar(Symbol(MERGE_KEY)), { addToJSMap: addMergeToJSMap }),
+	stringify: () => MERGE_KEY
+};
+const isMergeKey = (ctx, key) => (merge.identify(key) || isScalar(key) && (!key.type || key.type === Scalar.PLAIN) && merge.identify(key.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default);
+function addMergeToJSMap(ctx, map, value) {
+	value = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;
+	if (isSeq(value)) for (const it of value.items) mergeValue(ctx, map, it);
+	else if (Array.isArray(value)) for (const it of value) mergeValue(ctx, map, it);
+	else mergeValue(ctx, map, value);
+}
+function mergeValue(ctx, map, value) {
+	const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;
+	if (!isMap(source)) throw new Error("Merge sources must be maps or map aliases");
+	const srcMap = source.toJSON(null, ctx, Map);
+	for (const [key, value] of srcMap) if (map instanceof Map) {
+		if (!map.has(key)) map.set(key, value);
+	} else if (map instanceof Set) map.add(key);
+	else if (!Object.prototype.hasOwnProperty.call(map, key)) Object.defineProperty(map, key, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+	return map;
+}
+//#endregion
+export { addMergeToJSMap, isMergeKey, merge };