@workos/oagen-emitters 0.16.1 → 0.17.0

package/dist/{plugin-CpO8rePT.mjs → plugin-BLnR-FMi.mjs}

@@ -292,1997 +292,2333 @@ function lowerFirstForDoc(s) {
 }
 //#endregion
 //#region node_modules/js-yaml/dist/js-yaml.mjs
-/*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT */
-function isNothing(subject) {
-	return typeof subject === "undefined" || subject === null;
-}
-function isObject(subject) {
-	return typeof subject === "object" && subject !== null;
-}
-function toArray(sequence) {
-	if (Array.isArray(sequence)) return sequence;
-	else if (isNothing(sequence)) return [];
-	return [sequence];
-}
-function extend(target, source) {
-	var index, length, key, sourceKeys;
-	if (source) {
-		sourceKeys = Object.keys(source);
-		for (index = 0, length = sourceKeys.length; index < length; index += 1) {
-			key = sourceKeys[index];
-			target[key] = source[key];
-		}
+/*! js-yaml 4.2.0 https://github.com/nodeca/js-yaml @license MIT */
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
 	}
-	return target;
-}
-function repeat(string, count) {
-	var result = "", cycle;
-	for (cycle = 0; cycle < count; cycle += 1) result += string;
-	return result;
-}
-function isNegativeZero(number) {
-	return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
-}
-var common = {
-	isNothing,
-	isObject,
-	toArray,
-	repeat,
-	isNegativeZero,
-	extend
+	return to;
 };
-function formatError(exception, compact) {
-	var where = "", message = exception.reason || "(unknown reason)";
-	if (!exception.mark) return message;
-	if (exception.mark.name) where += "in \"" + exception.mark.name + "\" ";
-	where += "(" + (exception.mark.line + 1) + ":" + (exception.mark.column + 1) + ")";
-	if (!compact && exception.mark.snippet) where += "\n\n" + exception.mark.snippet;
-	return message + " " + where;
-}
-function YAMLException$1(reason, mark) {
-	Error.call(this);
-	this.name = "YAMLException";
-	this.reason = reason;
-	this.mark = mark;
-	this.message = formatError(this, false);
-	if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-	else this.stack = (/* @__PURE__ */ new Error()).stack || "";
-}
-YAMLException$1.prototype = Object.create(Error.prototype);
-YAMLException$1.prototype.constructor = YAMLException$1;
-YAMLException$1.prototype.toString = function toString(compact) {
-	return this.name + ": " + formatError(this, compact);
-};
-var exception = YAMLException$1;
-function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
-	var head = "";
-	var tail = "";
-	var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
-	if (position - lineStart > maxHalfLength) {
-		head = " ... ";
-		lineStart = position - maxHalfLength + head.length;
-	}
-	if (lineEnd - position > maxHalfLength) {
-		tail = " ...";
-		lineEnd = position + maxHalfLength - tail.length;
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var require_common = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function isNothing(subject) {
+		return typeof subject === "undefined" || subject === null;
+	}
+	function isObject(subject) {
+		return typeof subject === "object" && subject !== null;
+	}
+	function toArray(sequence) {
+		if (Array.isArray(sequence)) return sequence;
+		else if (isNothing(sequence)) return [];
+		return [sequence];
+	}
+	function extend(target, source) {
+		if (source) {
+			const sourceKeys = Object.keys(source);
+			for (let index = 0, length = sourceKeys.length; index < length; index += 1) {
+				const key = sourceKeys[index];
+				target[key] = source[key];
+			}
+		}
+		return target;
+	}
+	function repeat(string, count) {
+		let result = "";
+		for (let cycle = 0; cycle < count; cycle += 1) result += string;
+		return result;
 	}
-	return {
-		str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "→") + tail,
-		pos: position - lineStart + head.length
+	function isNegativeZero(number) {
+		return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
+	}
+	module.exports.isNothing = isNothing;
+	module.exports.isObject = isObject;
+	module.exports.toArray = toArray;
+	module.exports.repeat = repeat;
+	module.exports.isNegativeZero = isNegativeZero;
+	module.exports.extend = extend;
+}));
+var require_exception = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function formatError(exception, compact) {
+		let where = "";
+		const message = exception.reason || "(unknown reason)";
+		if (!exception.mark) return message;
+		if (exception.mark.name) where += "in \"" + exception.mark.name + "\" ";
+		where += "(" + (exception.mark.line + 1) + ":" + (exception.mark.column + 1) + ")";
+		if (!compact && exception.mark.snippet) where += "\n\n" + exception.mark.snippet;
+		return message + " " + where;
+	}
+	function YAMLException(reason, mark) {
+		Error.call(this);
+		this.name = "YAMLException";
+		this.reason = reason;
+		this.mark = mark;
+		this.message = formatError(this, false);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+		else this.stack = (/* @__PURE__ */ new Error()).stack || "";
+	}
+	YAMLException.prototype = Object.create(Error.prototype);
+	YAMLException.prototype.constructor = YAMLException;
+	YAMLException.prototype.toString = function toString(compact) {
+		return this.name + ": " + formatError(this, compact);
 	};
-}
-function padStart(string, max) {
-	return common.repeat(" ", max - string.length) + string;
-}
-function makeSnippet(mark, options) {
-	options = Object.create(options || null);
-	if (!mark.buffer) return null;
-	if (!options.maxLength) options.maxLength = 79;
-	if (typeof options.indent !== "number") options.indent = 1;
-	if (typeof options.linesBefore !== "number") options.linesBefore = 3;
-	if (typeof options.linesAfter !== "number") options.linesAfter = 2;
-	var re = /\r?\n|\r|\0/g;
-	var lineStarts = [0];
-	var lineEnds = [];
-	var match;
-	var foundLineNo = -1;
-	while (match = re.exec(mark.buffer)) {
-		lineEnds.push(match.index);
-		lineStarts.push(match.index + match[0].length);
-		if (mark.position <= match.index && foundLineNo < 0) foundLineNo = lineStarts.length - 2;
-	}
-	if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
-	var result = "", i, line;
-	var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
-	var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
-	for (i = 1; i <= options.linesBefore; i++) {
-		if (foundLineNo - i < 0) break;
-		line = getLine(mark.buffer, lineStarts[foundLineNo - i], lineEnds[foundLineNo - i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), maxLineLength);
-		result = common.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line.str + "\n" + result;
-	}
-	line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
-	result += common.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + "\n";
-	result += common.repeat("-", options.indent + lineNoLength + 3 + line.pos) + "^\n";
-	for (i = 1; i <= options.linesAfter; i++) {
-		if (foundLineNo + i >= lineEnds.length) break;
-		line = getLine(mark.buffer, lineStarts[foundLineNo + i], lineEnds[foundLineNo + i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), maxLineLength);
-		result += common.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line.str + "\n";
-	}
-	return result.replace(/\n$/, "");
-}
-var snippet = makeSnippet;
-var TYPE_CONSTRUCTOR_OPTIONS = [
-	"kind",
-	"multi",
-	"resolve",
-	"construct",
-	"instanceOf",
-	"predicate",
-	"represent",
-	"representName",
-	"defaultStyle",
-	"styleAliases"
-];
-var YAML_NODE_KINDS = [
-	"scalar",
-	"sequence",
-	"mapping"
-];
-function compileStyleAliases(map) {
-	var result = {};
-	if (map !== null) Object.keys(map).forEach(function(style) {
-		map[style].forEach(function(alias) {
-			result[String(alias)] = style;
+	module.exports = YAMLException;
+}));
+var require_snippet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var common = require_common();
+	function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
+		let head = "";
+		let tail = "";
+		const maxHalfLength = Math.floor(maxLineLength / 2) - 1;
+		if (position - lineStart > maxHalfLength) {
+			head = " ... ";
+			lineStart = position - maxHalfLength + head.length;
+		}
+		if (lineEnd - position > maxHalfLength) {
+			tail = " ...";
+			lineEnd = position + maxHalfLength - tail.length;
+		}
+		return {
+			str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "→") + tail,
+			pos: position - lineStart + head.length
+		};
+	}
+	function padStart(string, max) {
+		return common.repeat(" ", max - string.length) + string;
+	}
+	function makeSnippet(mark, options) {
+		options = Object.create(options || null);
+		if (!mark.buffer) return null;
+		if (!options.maxLength) options.maxLength = 79;
+		if (typeof options.indent !== "number") options.indent = 1;
+		if (typeof options.linesBefore !== "number") options.linesBefore = 3;
+		if (typeof options.linesAfter !== "number") options.linesAfter = 2;
+		const re = /\r?\n|\r|\0/g;
+		const lineStarts = [0];
+		const lineEnds = [];
+		let match;
+		let foundLineNo = -1;
+		while (match = re.exec(mark.buffer)) {
+			lineEnds.push(match.index);
+			lineStarts.push(match.index + match[0].length);
+			if (mark.position <= match.index && foundLineNo < 0) foundLineNo = lineStarts.length - 2;
+		}
+		if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
+		let result = "";
+		const lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
+		const maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
+		for (let i = 1; i <= options.linesBefore; i++) {
+			if (foundLineNo - i < 0) break;
+			const line = getLine(mark.buffer, lineStarts[foundLineNo - i], lineEnds[foundLineNo - i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), maxLineLength);
+			result = common.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line.str + "\n" + result;
+		}
+		const line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
+		result += common.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + "\n";
+		result += common.repeat("-", options.indent + lineNoLength + 3 + line.pos) + "^\n";
+		for (let i = 1; i <= options.linesAfter; i++) {
+			if (foundLineNo + i >= lineEnds.length) break;
+			const line = getLine(mark.buffer, lineStarts[foundLineNo + i], lineEnds[foundLineNo + i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), maxLineLength);
+			result += common.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line.str + "\n";
+		}
+		return result.replace(/\n$/, "");
+	}
+	module.exports = makeSnippet;
+}));
+var require_type = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var YAMLException = require_exception();
+	var TYPE_CONSTRUCTOR_OPTIONS = [
+		"kind",
+		"multi",
+		"resolve",
+		"construct",
+		"instanceOf",
+		"predicate",
+		"represent",
+		"representName",
+		"defaultStyle",
+		"styleAliases"
+	];
+	var YAML_NODE_KINDS = [
+		"scalar",
+		"sequence",
+		"mapping"
+	];
+	function compileStyleAliases(map) {
+		const result = {};
+		if (map !== null) Object.keys(map).forEach(function(style) {
+			map[style].forEach(function(alias) {
+				result[String(alias)] = style;
+			});
 		});
-	});
-	return result;
-}
-function Type$1(tag, options) {
-	options = options || {};
-	Object.keys(options).forEach(function(name) {
-		if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) throw new exception("Unknown option \"" + name + "\" is met in definition of \"" + tag + "\" YAML type.");
-	});
-	this.options = options;
-	this.tag = tag;
-	this.kind = options["kind"] || null;
-	this.resolve = options["resolve"] || function() {
-		return true;
-	};
-	this.construct = options["construct"] || function(data) {
-		return data;
-	};
-	this.instanceOf = options["instanceOf"] || null;
-	this.predicate = options["predicate"] || null;
-	this.represent = options["represent"] || null;
-	this.representName = options["representName"] || null;
-	this.defaultStyle = options["defaultStyle"] || null;
-	this.multi = options["multi"] || false;
-	this.styleAliases = compileStyleAliases(options["styleAliases"] || null);
-	if (YAML_NODE_KINDS.indexOf(this.kind) === -1) throw new exception("Unknown kind \"" + this.kind + "\" is specified for \"" + tag + "\" YAML type.");
-}
-var type = Type$1;
-function compileList(schema, name) {
-	var result = [];
-	schema[name].forEach(function(currentType) {
-		var newIndex = result.length;
-		result.forEach(function(previousType, previousIndex) {
-			if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) newIndex = previousIndex;
+		return result;
+	}
+	function Type(tag, options) {
+		options = options || {};
+		Object.keys(options).forEach(function(name) {
+			if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) throw new YAMLException("Unknown option \"" + name + "\" is met in definition of \"" + tag + "\" YAML type.");
 		});
-		result[newIndex] = currentType;
-	});
-	return result;
-}
-function compileMap() {
-	var result = {
-		scalar: {},
-		sequence: {},
-		mapping: {},
-		fallback: {},
-		multi: {
-			scalar: [],
-			sequence: [],
-			mapping: [],
-			fallback: []
-		}
-	}, index, length;
-	function collectType(type) {
-		if (type.multi) {
-			result.multi[type.kind].push(type);
-			result.multi["fallback"].push(type);
-		} else result[type.kind][type.tag] = result["fallback"][type.tag] = type;
-	}
-	for (index = 0, length = arguments.length; index < length; index += 1) arguments[index].forEach(collectType);
-	return result;
-}
-function Schema$1(definition) {
-	return this.extend(definition);
-}
-Schema$1.prototype.extend = function extend(definition) {
-	var implicit = [];
-	var explicit = [];
-	if (definition instanceof type) explicit.push(definition);
-	else if (Array.isArray(definition)) explicit = explicit.concat(definition);
-	else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
-		if (definition.implicit) implicit = implicit.concat(definition.implicit);
-		if (definition.explicit) explicit = explicit.concat(definition.explicit);
-	} else throw new exception("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
-	implicit.forEach(function(type$1) {
-		if (!(type$1 instanceof type)) throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object.");
-		if (type$1.loadKind && type$1.loadKind !== "scalar") throw new exception("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
-		if (type$1.multi) throw new exception("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.");
-	});
-	explicit.forEach(function(type$1) {
-		if (!(type$1 instanceof type)) throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object.");
-	});
-	var result = Object.create(Schema$1.prototype);
-	result.implicit = (this.implicit || []).concat(implicit);
-	result.explicit = (this.explicit || []).concat(explicit);
-	result.compiledImplicit = compileList(result, "implicit");
-	result.compiledExplicit = compileList(result, "explicit");
-	result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit);
-	return result;
-};
-var failsafe = new Schema$1({ explicit: [
-	new type("tag:yaml.org,2002:str", {
+		this.options = options;
+		this.tag = tag;
+		this.kind = options["kind"] || null;
+		this.resolve = options["resolve"] || function() {
+			return true;
+		};
+		this.construct = options["construct"] || function(data) {
+			return data;
+		};
+		this.instanceOf = options["instanceOf"] || null;
+		this.predicate = options["predicate"] || null;
+		this.represent = options["represent"] || null;
+		this.representName = options["representName"] || null;
+		this.defaultStyle = options["defaultStyle"] || null;
+		this.multi = options["multi"] || false;
+		this.styleAliases = compileStyleAliases(options["styleAliases"] || null);
+		if (YAML_NODE_KINDS.indexOf(this.kind) === -1) throw new YAMLException("Unknown kind \"" + this.kind + "\" is specified for \"" + tag + "\" YAML type.");
+	}
+	module.exports = Type;
+}));
+var require_schema = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var YAMLException = require_exception();
+	var Type = require_type();
+	function compileList(schema, name) {
+		const result = [];
+		schema[name].forEach(function(currentType) {
+			let newIndex = result.length;
+			result.forEach(function(previousType, previousIndex) {
+				if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) newIndex = previousIndex;
+			});
+			result[newIndex] = currentType;
+		});
+		return result;
+	}
+	function compileMap() {
+		const result = {
+			scalar: {},
+			sequence: {},
+			mapping: {},
+			fallback: {},
+			multi: {
+				scalar: [],
+				sequence: [],
+				mapping: [],
+				fallback: []
+			}
+		};
+		function collectType(type) {
+			if (type.multi) {
+				result.multi[type.kind].push(type);
+				result.multi["fallback"].push(type);
+			} else result[type.kind][type.tag] = result["fallback"][type.tag] = type;
+		}
+		for (let index = 0, length = arguments.length; index < length; index += 1) arguments[index].forEach(collectType);
+		return result;
+	}
+	function Schema(definition) {
+		return this.extend(definition);
+	}
+	Schema.prototype.extend = function extend(definition) {
+		let implicit = [];
+		let explicit = [];
+		if (definition instanceof Type) explicit.push(definition);
+		else if (Array.isArray(definition)) explicit = explicit.concat(definition);
+		else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
+			if (definition.implicit) implicit = implicit.concat(definition.implicit);
+			if (definition.explicit) explicit = explicit.concat(definition.explicit);
+		} else throw new YAMLException("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
+		implicit.forEach(function(type) {
+			if (!(type instanceof Type)) throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+			if (type.loadKind && type.loadKind !== "scalar") throw new YAMLException("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
+			if (type.multi) throw new YAMLException("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.");
+		});
+		explicit.forEach(function(type) {
+			if (!(type instanceof Type)) throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+		});
+		const result = Object.create(Schema.prototype);
+		result.implicit = (this.implicit || []).concat(implicit);
+		result.explicit = (this.explicit || []).concat(explicit);
+		result.compiledImplicit = compileList(result, "implicit");
+		result.compiledExplicit = compileList(result, "explicit");
+		result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit);
+		return result;
+	};
+	module.exports = Schema;
+}));
+var require_str = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = new (require_type())("tag:yaml.org,2002:str", {
 		kind: "scalar",
 		construct: function(data) {
 			return data !== null ? data : "";
 		}
-	}),
-	new type("tag:yaml.org,2002:seq", {
+	});
+}));
+var require_seq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = new (require_type())("tag:yaml.org,2002:seq", {
 		kind: "sequence",
 		construct: function(data) {
 			return data !== null ? data : [];
 		}
-	}),
-	new type("tag:yaml.org,2002:map", {
+	});
+}));
+var require_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = new (require_type())("tag:yaml.org,2002:map", {
 		kind: "mapping",
 		construct: function(data) {
 			return data !== null ? data : {};
 		}
-	})
-] });
-function resolveYamlNull(data) {
-	if (data === null) return true;
-	var max = data.length;
-	return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL");
-}
-function constructYamlNull() {
-	return null;
-}
-function isNull(object) {
-	return object === null;
-}
-var _null = new type("tag:yaml.org,2002:null", {
-	kind: "scalar",
-	resolve: resolveYamlNull,
-	construct: constructYamlNull,
-	predicate: isNull,
-	represent: {
-		canonical: function() {
-			return "~";
-		},
-		lowercase: function() {
-			return "null";
-		},
-		uppercase: function() {
-			return "NULL";
+	});
+}));
+var require_failsafe = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = new (require_schema())({ explicit: [
+		require_str(),
+		require_seq(),
+		require_map()
+	] });
+}));
+var require_null = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	function resolveYamlNull(data) {
+		if (data === null) return true;
+		const max = data.length;
+		return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL");
+	}
+	function constructYamlNull() {
+		return null;
+	}
+	function isNull(object) {
+		return object === null;
+	}
+	module.exports = new Type("tag:yaml.org,2002:null", {
+		kind: "scalar",
+		resolve: resolveYamlNull,
+		construct: constructYamlNull,
+		predicate: isNull,
+		represent: {
+			canonical: function() {
+				return "~";
+			},
+			lowercase: function() {
+				return "null";
+			},
+			uppercase: function() {
+				return "NULL";
+			},
+			camelcase: function() {
+				return "Null";
+			},
+			empty: function() {
+				return "";
+			}
 		},
-		camelcase: function() {
-			return "Null";
+		defaultStyle: "lowercase"
+	});
+}));
+var require_bool = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	function resolveYamlBoolean(data) {
+		if (data === null) return false;
+		const max = data.length;
+		return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE");
+	}
+	function constructYamlBoolean(data) {
+		return data === "true" || data === "True" || data === "TRUE";
+	}
+	function isBoolean(object) {
+		return Object.prototype.toString.call(object) === "[object Boolean]";
+	}
+	module.exports = new Type("tag:yaml.org,2002:bool", {
+		kind: "scalar",
+		resolve: resolveYamlBoolean,
+		construct: constructYamlBoolean,
+		predicate: isBoolean,
+		represent: {
+			lowercase: function(object) {
+				return object ? "true" : "false";
+			},
+			uppercase: function(object) {
+				return object ? "TRUE" : "FALSE";
+			},
+			camelcase: function(object) {
+				return object ? "True" : "False";
+			}
 		},
-		empty: function() {
-			return "";
+		defaultStyle: "lowercase"
+	});
+}));
+var require_int = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var common = require_common();
+	var Type = require_type();
+	function isHexCode(c) {
+		return c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102;
+	}
+	function isOctCode(c) {
+		return c >= 48 && c <= 55;
+	}
+	function isDecCode(c) {
+		return c >= 48 && c <= 57;
+	}
+	function resolveYamlInteger(data) {
+		if (data === null) return false;
+		const max = data.length;
+		let index = 0;
+		let hasDigits = false;
+		if (!max) return false;
+		let ch = data[index];
+		if (ch === "-" || ch === "+") ch = data[++index];
+		if (ch === "0") {
+			if (index + 1 === max) return true;
+			ch = data[++index];
+			if (ch === "b") {
+				index++;
+				for (; index < max; index++) {
+					ch = data[index];
+					if (ch !== "0" && ch !== "1") return false;
+					hasDigits = true;
+				}
+				return hasDigits && Number.isFinite(parseYamlInteger(data));
+			}
+			if (ch === "x") {
+				index++;
+				for (; index < max; index++) {
+					if (!isHexCode(data.charCodeAt(index))) return false;
+					hasDigits = true;
+				}
+				return hasDigits && Number.isFinite(parseYamlInteger(data));
+			}
+			if (ch === "o") {
+				index++;
+				for (; index < max; index++) {
+					if (!isOctCode(data.charCodeAt(index))) return false;
+					hasDigits = true;
+				}
+				return hasDigits && Number.isFinite(parseYamlInteger(data));
+			}
 		}
-	},
-	defaultStyle: "lowercase"
-});
-function resolveYamlBoolean(data) {
-	if (data === null) return false;
-	var max = data.length;
-	return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE");
-}
-function constructYamlBoolean(data) {
-	return data === "true" || data === "True" || data === "TRUE";
-}
-function isBoolean(object) {
-	return Object.prototype.toString.call(object) === "[object Boolean]";
-}
-var bool = new type("tag:yaml.org,2002:bool", {
-	kind: "scalar",
-	resolve: resolveYamlBoolean,
-	construct: constructYamlBoolean,
-	predicate: isBoolean,
-	represent: {
-		lowercase: function(object) {
-			return object ? "true" : "false";
-		},
-		uppercase: function(object) {
-			return object ? "TRUE" : "FALSE";
-		},
-		camelcase: function(object) {
-			return object ? "True" : "False";
+		for (; index < max; index++) {
+			if (!isDecCode(data.charCodeAt(index))) return false;
+			hasDigits = true;
 		}
-	},
-	defaultStyle: "lowercase"
-});
-function isHexCode(c) {
-	return 48 <= c && c <= 57 || 65 <= c && c <= 70 || 97 <= c && c <= 102;
-}
-function isOctCode(c) {
-	return 48 <= c && c <= 55;
-}
-function isDecCode(c) {
-	return 48 <= c && c <= 57;
-}
-function resolveYamlInteger(data) {
-	if (data === null) return false;
-	var max = data.length, index = 0, hasDigits = false, ch;
-	if (!max) return false;
-	ch = data[index];
-	if (ch === "-" || ch === "+") ch = data[++index];
-	if (ch === "0") {
-		if (index + 1 === max) return true;
-		ch = data[++index];
-		if (ch === "b") {
-			index++;
-			for (; index < max; index++) {
-				ch = data[index];
-				if (ch === "_") continue;
-				if (ch !== "0" && ch !== "1") return false;
-				hasDigits = true;
-			}
-			return hasDigits && ch !== "_";
-		}
-		if (ch === "x") {
-			index++;
-			for (; index < max; index++) {
-				ch = data[index];
-				if (ch === "_") continue;
-				if (!isHexCode(data.charCodeAt(index))) return false;
-				hasDigits = true;
-			}
-			return hasDigits && ch !== "_";
-		}
-		if (ch === "o") {
-			index++;
-			for (; index < max; index++) {
-				ch = data[index];
-				if (ch === "_") continue;
-				if (!isOctCode(data.charCodeAt(index))) return false;
-				hasDigits = true;
-			}
-			return hasDigits && ch !== "_";
-		}
-	}
-	if (ch === "_") return false;
-	for (; index < max; index++) {
-		ch = data[index];
-		if (ch === "_") continue;
-		if (!isDecCode(data.charCodeAt(index))) return false;
-		hasDigits = true;
-	}
-	if (!hasDigits || ch === "_") return false;
-	return true;
-}
-function constructYamlInteger(data) {
-	var value = data, sign = 1, ch;
-	if (value.indexOf("_") !== -1) value = value.replace(/_/g, "");
-	ch = value[0];
-	if (ch === "-" || ch === "+") {
-		if (ch === "-") sign = -1;
-		value = value.slice(1);
-		ch = value[0];
-	}
-	if (value === "0") return 0;
-	if (ch === "0") {
-		if (value[1] === "b") return sign * parseInt(value.slice(2), 2);
-		if (value[1] === "x") return sign * parseInt(value.slice(2), 16);
-		if (value[1] === "o") return sign * parseInt(value.slice(2), 8);
-	}
-	return sign * parseInt(value, 10);
-}
-function isInteger(object) {
-	return Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !common.isNegativeZero(object);
-}
-var int = new type("tag:yaml.org,2002:int", {
-	kind: "scalar",
-	resolve: resolveYamlInteger,
-	construct: constructYamlInteger,
-	predicate: isInteger,
-	represent: {
-		binary: function(obj) {
-			return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
-		},
-		octal: function(obj) {
-			return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1);
-		},
-		decimal: function(obj) {
-			return obj.toString(10);
+		if (!hasDigits) return false;
+		return Number.isFinite(parseYamlInteger(data));
+	}
+	function parseYamlInteger(data) {
+		let value = data;
+		let sign = 1;
+		let ch = value[0];
+		if (ch === "-" || ch === "+") {
+			if (ch === "-") sign = -1;
+			value = value.slice(1);
+			ch = value[0];
+		}
+		if (value === "0") return 0;
+		if (ch === "0") {
+			if (value[1] === "b") return sign * parseInt(value.slice(2), 2);
+			if (value[1] === "x") return sign * parseInt(value.slice(2), 16);
+			if (value[1] === "o") return sign * parseInt(value.slice(2), 8);
+		}
+		return sign * parseInt(value, 10);
+	}
+	function constructYamlInteger(data) {
+		return parseYamlInteger(data);
+	}
+	function isInteger(object) {
+		return Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !common.isNegativeZero(object);
+	}
+	module.exports = new Type("tag:yaml.org,2002:int", {
+		kind: "scalar",
+		resolve: resolveYamlInteger,
+		construct: constructYamlInteger,
+		predicate: isInteger,
+		represent: {
+			binary: function(obj) {
+				return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
+			},
+			octal: function(obj) {
+				return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1);
+			},
+			decimal: function(obj) {
+				return obj.toString(10);
+			},
+			hexadecimal: function(obj) {
+				return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
+			}
 		},
-		hexadecimal: function(obj) {
-			return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
+		defaultStyle: "decimal",
+		styleAliases: {
+			binary: [2, "bin"],
+			octal: [8, "oct"],
+			decimal: [10, "dec"],
+			hexadecimal: [16, "hex"]
 		}
-	},
-	defaultStyle: "decimal",
-	styleAliases: {
-		binary: [2, "bin"],
-		octal: [8, "oct"],
-		decimal: [10, "dec"],
-		hexadecimal: [16, "hex"]
-	}
-});
-var YAML_FLOAT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
-function resolveYamlFloat(data) {
-	if (data === null) return false;
-	if (!YAML_FLOAT_PATTERN.test(data) || data[data.length - 1] === "_") return false;
-	return true;
-}
-function constructYamlFloat(data) {
-	var value = data.replace(/_/g, "").toLowerCase(), sign = value[0] === "-" ? -1 : 1;
-	if ("+-".indexOf(value[0]) >= 0) value = value.slice(1);
-	if (value === ".inf") return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
-	else if (value === ".nan") return NaN;
-	return sign * parseFloat(value, 10);
-}
-var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
-function representYamlFloat(object, style) {
-	var res;
-	if (isNaN(object)) switch (style) {
-		case "lowercase": return ".nan";
-		case "uppercase": return ".NAN";
-		case "camelcase": return ".NaN";
-	}
-	else if (Number.POSITIVE_INFINITY === object) switch (style) {
-		case "lowercase": return ".inf";
-		case "uppercase": return ".INF";
-		case "camelcase": return ".Inf";
-	}
-	else if (Number.NEGATIVE_INFINITY === object) switch (style) {
-		case "lowercase": return "-.inf";
-		case "uppercase": return "-.INF";
-		case "camelcase": return "-.Inf";
-	}
-	else if (common.isNegativeZero(object)) return "-0.0";
-	res = object.toString(10);
-	return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
-}
-function isFloat(object) {
-	return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object));
-}
-var float = new type("tag:yaml.org,2002:float", {
-	kind: "scalar",
-	resolve: resolveYamlFloat,
-	construct: constructYamlFloat,
-	predicate: isFloat,
-	represent: representYamlFloat,
-	defaultStyle: "lowercase"
-});
-var core = failsafe.extend({ implicit: [
-	_null,
-	bool,
-	int,
-	float
-] });
-var YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
-var YAML_TIMESTAMP_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
-function resolveYamlTimestamp(data) {
-	if (data === null) return false;
-	if (YAML_DATE_REGEXP.exec(data) !== null) return true;
-	if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
-	return false;
-}
-function constructYamlTimestamp(data) {
-	var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date;
-	match = YAML_DATE_REGEXP.exec(data);
-	if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
-	if (match === null) throw new Error("Date resolve error");
-	year = +match[1];
-	month = +match[2] - 1;
-	day = +match[3];
-	if (!match[4]) return new Date(Date.UTC(year, month, day));
-	hour = +match[4];
-	minute = +match[5];
-	second = +match[6];
-	if (match[7]) {
-		fraction = match[7].slice(0, 3);
-		while (fraction.length < 3) fraction += "0";
-		fraction = +fraction;
-	}
-	if (match[9]) {
-		tz_hour = +match[10];
-		tz_minute = +(match[11] || 0);
-		delta = (tz_hour * 60 + tz_minute) * 6e4;
-		if (match[9] === "-") delta = -delta;
-	}
-	date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
-	if (delta) date.setTime(date.getTime() - delta);
-	return date;
-}
-function representYamlTimestamp(object) {
-	return object.toISOString();
-}
-var timestamp = new type("tag:yaml.org,2002:timestamp", {
-	kind: "scalar",
-	resolve: resolveYamlTimestamp,
-	construct: constructYamlTimestamp,
-	instanceOf: Date,
-	represent: representYamlTimestamp
-});
-function resolveYamlMerge(data) {
-	return data === "<<" || data === null;
-}
-var merge = new type("tag:yaml.org,2002:merge", {
-	kind: "scalar",
-	resolve: resolveYamlMerge
-});
-var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
-function resolveYamlBinary(data) {
-	if (data === null) return false;
-	var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
-	for (idx = 0; idx < max; idx++) {
-		code = map.indexOf(data.charAt(idx));
-		if (code > 64) continue;
-		if (code < 0) return false;
-		bitlen += 6;
-	}
-	return bitlen % 8 === 0;
-}
-function constructYamlBinary(data) {
-	var idx, tailbits, input = data.replace(/[\r\n=]/g, ""), max = input.length, map = BASE64_MAP, bits = 0, result = [];
-	for (idx = 0; idx < max; idx++) {
-		if (idx % 4 === 0 && idx) {
+	});
+}));
+var require_float = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var common = require_common();
+	var Type = require_type();
+	var YAML_FLOAT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:[0-9]+)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+	var YAML_FLOAT_SPECIAL_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+	function resolveYamlFloat(data) {
+		if (data === null) return false;
+		if (!YAML_FLOAT_PATTERN.test(data)) return false;
+		if (Number.isFinite(parseFloat(data, 10))) return true;
+		return YAML_FLOAT_SPECIAL_PATTERN.test(data);
+	}
+	function constructYamlFloat(data) {
+		let value = data.toLowerCase();
+		const sign = value[0] === "-" ? -1 : 1;
+		if ("+-".indexOf(value[0]) >= 0) value = value.slice(1);
+		if (value === ".inf") return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+		else if (value === ".nan") return NaN;
+		return sign * parseFloat(value, 10);
+	}
+	var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+	function representYamlFloat(object, style) {
+		if (isNaN(object)) switch (style) {
+			case "lowercase": return ".nan";
+			case "uppercase": return ".NAN";
+			case "camelcase": return ".NaN";
+		}
+		else if (Number.POSITIVE_INFINITY === object) switch (style) {
+			case "lowercase": return ".inf";
+			case "uppercase": return ".INF";
+			case "camelcase": return ".Inf";
+		}
+		else if (Number.NEGATIVE_INFINITY === object) switch (style) {
+			case "lowercase": return "-.inf";
+			case "uppercase": return "-.INF";
+			case "camelcase": return "-.Inf";
+		}
+		else if (common.isNegativeZero(object)) return "-0.0";
+		const res = object.toString(10);
+		return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
+	}
+	function isFloat(object) {
+		return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object));
+	}
+	module.exports = new Type("tag:yaml.org,2002:float", {
+		kind: "scalar",
+		resolve: resolveYamlFloat,
+		construct: constructYamlFloat,
+		predicate: isFloat,
+		represent: representYamlFloat,
+		defaultStyle: "lowercase"
+	});
+}));
+var require_json = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_failsafe().extend({ implicit: [
+		require_null(),
+		require_bool(),
+		require_int(),
+		require_float()
+	] });
+}));
+var require_core = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_json();
+}));
+var require_timestamp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	var YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
+	var YAML_TIMESTAMP_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
+	function resolveYamlTimestamp(data) {
+		if (data === null) return false;
+		if (YAML_DATE_REGEXP.exec(data) !== null) return true;
+		if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
+		return false;
+	}
+	function constructYamlTimestamp(data) {
+		let fraction = 0;
+		let delta = null;
+		let match = YAML_DATE_REGEXP.exec(data);
+		if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
+		if (match === null) throw new Error("Date resolve error");
+		const year = +match[1];
+		const month = +match[2] - 1;
+		const day = +match[3];
+		if (!match[4]) return new Date(Date.UTC(year, month, day));
+		const hour = +match[4];
+		const minute = +match[5];
+		const second = +match[6];
+		if (match[7]) {
+			fraction = match[7].slice(0, 3);
+			while (fraction.length < 3) fraction += "0";
+			fraction = +fraction;
+		}
+		if (match[9]) {
+			const tzHour = +match[10];
+			const tzMinute = +(match[11] || 0);
+			delta = (tzHour * 60 + tzMinute) * 6e4;
+			if (match[9] === "-") delta = -delta;
+		}
+		const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+		if (delta) date.setTime(date.getTime() - delta);
+		return date;
+	}
+	function representYamlTimestamp(object) {
+		return object.toISOString();
+	}
+	module.exports = new Type("tag:yaml.org,2002:timestamp", {
+		kind: "scalar",
+		resolve: resolveYamlTimestamp,
+		construct: constructYamlTimestamp,
+		instanceOf: Date,
+		represent: representYamlTimestamp
+	});
+}));
+var require_merge = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	function resolveYamlMerge(data) {
+		return data === "<<" || data === null;
+	}
+	module.exports = new Type("tag:yaml.org,2002:merge", {
+		kind: "scalar",
+		resolve: resolveYamlMerge
+	});
+}));
+var require_binary = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
+	function resolveYamlBinary(data) {
+		if (data === null) return false;
+		let bitlen = 0;
+		const max = data.length;
+		const map = BASE64_MAP;
+		for (let idx = 0; idx < max; idx++) {
+			const code = map.indexOf(data.charAt(idx));
+			if (code > 64) continue;
+			if (code < 0) return false;
+			bitlen += 6;
+		}
+		return bitlen % 8 === 0;
+	}
+	function constructYamlBinary(data) {
+		const input = data.replace(/[\r\n=]/g, "");
+		const max = input.length;
+		const map = BASE64_MAP;
+		let bits = 0;
+		const result = [];
+		for (let idx = 0; idx < max; idx++) {
+			if (idx % 4 === 0 && idx) {
+				result.push(bits >> 16 & 255);
+				result.push(bits >> 8 & 255);
+				result.push(bits & 255);
+			}
+			bits = bits << 6 | map.indexOf(input.charAt(idx));
+		}
+		const tailbits = max % 4 * 6;
+		if (tailbits === 0) {
 			result.push(bits >> 16 & 255);
 			result.push(bits >> 8 & 255);
 			result.push(bits & 255);
-		}
-		bits = bits << 6 | map.indexOf(input.charAt(idx));
-	}
-	tailbits = max % 4 * 6;
-	if (tailbits === 0) {
-		result.push(bits >> 16 & 255);
-		result.push(bits >> 8 & 255);
-		result.push(bits & 255);
-	} else if (tailbits === 18) {
-		result.push(bits >> 10 & 255);
-		result.push(bits >> 2 & 255);
-	} else if (tailbits === 12) result.push(bits >> 4 & 255);
-	return new Uint8Array(result);
-}
-function representYamlBinary(object) {
-	var result = "", bits = 0, idx, tail, max = object.length, map = BASE64_MAP;
-	for (idx = 0; idx < max; idx++) {
-		if (idx % 3 === 0 && idx) {
+		} else if (tailbits === 18) {
+			result.push(bits >> 10 & 255);
+			result.push(bits >> 2 & 255);
+		} else if (tailbits === 12) result.push(bits >> 4 & 255);
+		return new Uint8Array(result);
+	}
+	function representYamlBinary(object) {
+		let result = "";
+		let bits = 0;
+		const max = object.length;
+		const map = BASE64_MAP;
+		for (let idx = 0; idx < max; idx++) {
+			if (idx % 3 === 0 && idx) {
+				result += map[bits >> 18 & 63];
+				result += map[bits >> 12 & 63];
+				result += map[bits >> 6 & 63];
+				result += map[bits & 63];
+			}
+			bits = (bits << 8) + object[idx];
+		}
+		const tail = max % 3;
+		if (tail === 0) {
 			result += map[bits >> 18 & 63];
 			result += map[bits >> 12 & 63];
 			result += map[bits >> 6 & 63];
 			result += map[bits & 63];
+		} else if (tail === 2) {
+			result += map[bits >> 10 & 63];
+			result += map[bits >> 4 & 63];
+			result += map[bits << 2 & 63];
+			result += map[64];
+		} else if (tail === 1) {
+			result += map[bits >> 2 & 63];
+			result += map[bits << 4 & 63];
+			result += map[64];
+			result += map[64];
 		}
-		bits = (bits << 8) + object[idx];
-	}
-	tail = max % 3;
-	if (tail === 0) {
-		result += map[bits >> 18 & 63];
-		result += map[bits >> 12 & 63];
-		result += map[bits >> 6 & 63];
-		result += map[bits & 63];
-	} else if (tail === 2) {
-		result += map[bits >> 10 & 63];
-		result += map[bits >> 4 & 63];
-		result += map[bits << 2 & 63];
-		result += map[64];
-	} else if (tail === 1) {
-		result += map[bits >> 2 & 63];
-		result += map[bits << 4 & 63];
-		result += map[64];
-		result += map[64];
+		return result;
 	}
-	return result;
-}
-function isBinary(obj) {
-	return Object.prototype.toString.call(obj) === "[object Uint8Array]";
-}
-var binary = new type("tag:yaml.org,2002:binary", {
-	kind: "scalar",
-	resolve: resolveYamlBinary,
-	construct: constructYamlBinary,
-	predicate: isBinary,
-	represent: representYamlBinary
-});
-var _hasOwnProperty$3 = Object.prototype.hasOwnProperty;
-var _toString$2 = Object.prototype.toString;
-function resolveYamlOmap(data) {
-	if (data === null) return true;
-	var objectKeys = [], index, length, pair, pairKey, pairHasKey, object = data;
-	for (index = 0, length = object.length; index < length; index += 1) {
-		pair = object[index];
-		pairHasKey = false;
-		if (_toString$2.call(pair) !== "[object Object]") return false;
-		for (pairKey in pair) if (_hasOwnProperty$3.call(pair, pairKey)) if (!pairHasKey) pairHasKey = true;
-		else return false;
-		if (!pairHasKey) return false;
-		if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
-		else return false;
+	function isBinary(obj) {
+		return Object.prototype.toString.call(obj) === "[object Uint8Array]";
 	}
-	return true;
-}
-function constructYamlOmap(data) {
-	return data !== null ? data : [];
-}
-var omap = new type("tag:yaml.org,2002:omap", {
-	kind: "sequence",
-	resolve: resolveYamlOmap,
-	construct: constructYamlOmap
-});
-var _toString$1 = Object.prototype.toString;
-function resolveYamlPairs(data) {
-	if (data === null) return true;
-	var index, length, pair, keys, result, object = data;
-	result = new Array(object.length);
-	for (index = 0, length = object.length; index < length; index += 1) {
-		pair = object[index];
-		if (_toString$1.call(pair) !== "[object Object]") return false;
-		keys = Object.keys(pair);
-		if (keys.length !== 1) return false;
-		result[index] = [keys[0], pair[keys[0]]];
+	module.exports = new Type("tag:yaml.org,2002:binary", {
+		kind: "scalar",
+		resolve: resolveYamlBinary,
+		construct: constructYamlBinary,
+		predicate: isBinary,
+		represent: representYamlBinary
+	});
+}));
+var require_omap = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	var _hasOwnProperty = Object.prototype.hasOwnProperty;
+	var _toString = Object.prototype.toString;
+	function resolveYamlOmap(data) {
+		if (data === null) return true;
+		const objectKeys = [];
+		const object = data;
+		for (let index = 0, length = object.length; index < length; index += 1) {
+			const pair = object[index];
+			let pairHasKey = false;
+			if (_toString.call(pair) !== "[object Object]") return false;
+			let pairKey;
+			for (pairKey in pair) if (_hasOwnProperty.call(pair, pairKey)) if (!pairHasKey) pairHasKey = true;
+			else return false;
+			if (!pairHasKey) return false;
+			if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
+			else return false;
+		}
+		return true;
 	}
-	return true;
-}
-function constructYamlPairs(data) {
-	if (data === null) return [];
-	var index, length, pair, keys, result, object = data;
-	result = new Array(object.length);
-	for (index = 0, length = object.length; index < length; index += 1) {
-		pair = object[index];
-		keys = Object.keys(pair);
-		result[index] = [keys[0], pair[keys[0]]];
+	function constructYamlOmap(data) {
+		return data !== null ? data : [];
 	}
-	return result;
-}
-var pairs = new type("tag:yaml.org,2002:pairs", {
-	kind: "sequence",
-	resolve: resolveYamlPairs,
-	construct: constructYamlPairs
-});
-var _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
-function resolveYamlSet(data) {
-	if (data === null) return true;
-	var key, object = data;
-	for (key in object) if (_hasOwnProperty$2.call(object, key)) {
-		if (object[key] !== null) return false;
+	module.exports = new Type("tag:yaml.org,2002:omap", {
+		kind: "sequence",
+		resolve: resolveYamlOmap,
+		construct: constructYamlOmap
+	});
+}));
+var require_pairs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	var _toString = Object.prototype.toString;
+	function resolveYamlPairs(data) {
+		if (data === null) return true;
+		const object = data;
+		const result = new Array(object.length);
+		for (let index = 0, length = object.length; index < length; index += 1) {
+			const pair = object[index];
+			if (_toString.call(pair) !== "[object Object]") return false;
+			const keys = Object.keys(pair);
+			if (keys.length !== 1) return false;
+			result[index] = [keys[0], pair[keys[0]]];
+		}
+		return true;
 	}
-	return true;
-}
-function constructYamlSet(data) {
-	return data !== null ? data : {};
-}
-var set = new type("tag:yaml.org,2002:set", {
-	kind: "mapping",
-	resolve: resolveYamlSet,
-	construct: constructYamlSet
-});
-var _default = core.extend({
-	implicit: [timestamp, merge],
-	explicit: [
-		binary,
-		omap,
-		pairs,
-		set
-	]
-});
-var _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
-var CONTEXT_FLOW_IN = 1;
-var CONTEXT_FLOW_OUT = 2;
-var CONTEXT_BLOCK_IN = 3;
-var CONTEXT_BLOCK_OUT = 4;
-var CHOMPING_CLIP = 1;
-var CHOMPING_STRIP = 2;
-var CHOMPING_KEEP = 3;
-var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
-var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
-var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
-var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
-function _class(obj) {
-	return Object.prototype.toString.call(obj);
-}
-function is_EOL(c) {
-	return c === 10 || c === 13;
-}
-function is_WHITE_SPACE(c) {
-	return c === 9 || c === 32;
-}
-function is_WS_OR_EOL(c) {
-	return c === 9 || c === 32 || c === 10 || c === 13;
-}
-function is_FLOW_INDICATOR(c) {
-	return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
-}
-function fromHexCode(c) {
-	var lc;
-	if (48 <= c && c <= 57) return c - 48;
-	lc = c | 32;
-	if (97 <= lc && lc <= 102) return lc - 97 + 10;
-	return -1;
-}
-function escapedHexLen(c) {
-	if (c === 120) return 2;
-	if (c === 117) return 4;
-	if (c === 85) return 8;
-	return 0;
-}
-function fromDecimalCode(c) {
-	if (48 <= c && c <= 57) return c - 48;
-	return -1;
-}
-function simpleEscapeSequence(c) {
-	return c === 48 ? "\0" : c === 97 ? "\x07" : c === 98 ? "\b" : c === 116 ? "	" : c === 9 ? "	" : c === 110 ? "\n" : c === 118 ? "\v" : c === 102 ? "\f" : c === 114 ? "\r" : c === 101 ? "\x1B" : c === 32 ? " " : c === 34 ? "\"" : c === 47 ? "/" : c === 92 ? "\\" : c === 78 ? "…" : c === 95 ? "\xA0" : c === 76 ? "\u2028" : c === 80 ? "\u2029" : "";
-}
-function charFromCodepoint(c) {
-	if (c <= 65535) return String.fromCharCode(c);
-	return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320);
-}
-function setProperty(object, key, value) {
-	if (key === "__proto__") Object.defineProperty(object, key, {
-		configurable: true,
-		enumerable: true,
-		writable: true,
-		value
+	function constructYamlPairs(data) {
+		if (data === null) return [];
+		const object = data;
+		const result = new Array(object.length);
+		for (let index = 0, length = object.length; index < length; index += 1) {
+			const pair = object[index];
+			const keys = Object.keys(pair);
+			result[index] = [keys[0], pair[keys[0]]];
+		}
+		return result;
+	}
+	module.exports = new Type("tag:yaml.org,2002:pairs", {
+		kind: "sequence",
+		resolve: resolveYamlPairs,
+		construct: constructYamlPairs
 	});
-	else object[key] = value;
-}
-var simpleEscapeCheck = new Array(256);
-var simpleEscapeMap = new Array(256);
-for (var i = 0; i < 256; i++) {
-	simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
-	simpleEscapeMap[i] = simpleEscapeSequence(i);
-}
-function State$1(input, options) {
-	this.input = input;
-	this.filename = options["filename"] || null;
-	this.schema = options["schema"] || _default;
-	this.onWarning = options["onWarning"] || null;
-	this.legacy = options["legacy"] || false;
-	this.json = options["json"] || false;
-	this.listener = options["listener"] || null;
-	this.implicitTypes = this.schema.compiledImplicit;
-	this.typeMap = this.schema.compiledTypeMap;
-	this.length = input.length;
-	this.position = 0;
-	this.line = 0;
-	this.lineStart = 0;
-	this.lineIndent = 0;
-	this.firstTabInLine = -1;
-	this.documents = [];
-}
-function generateError(state, message) {
-	var mark = {
-		name: state.filename,
-		buffer: state.input.slice(0, -1),
-		position: state.position,
-		line: state.line,
-		column: state.position - state.lineStart
-	};
-	mark.snippet = snippet(mark);
-	return new exception(message, mark);
-}
-function throwError(state, message) {
-	throw generateError(state, message);
-}
-function throwWarning(state, message) {
-	if (state.onWarning) state.onWarning.call(null, generateError(state, message));
-}
-var directiveHandlers = {
-	YAML: function handleYamlDirective(state, name, args) {
-		var match, major, minor;
-		if (state.version !== null) throwError(state, "duplication of %YAML directive");
-		if (args.length !== 1) throwError(state, "YAML directive accepts exactly one argument");
-		match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
-		if (match === null) throwError(state, "ill-formed argument of the YAML directive");
-		major = parseInt(match[1], 10);
-		minor = parseInt(match[2], 10);
-		if (major !== 1) throwError(state, "unacceptable YAML version of the document");
-		state.version = args[0];
-		state.checkLineBreaks = minor < 2;
-		if (minor !== 1 && minor !== 2) throwWarning(state, "unsupported YAML version of the document");
-	},
-	TAG: function handleTagDirective(state, name, args) {
-		var handle, prefix;
-		if (args.length !== 2) throwError(state, "TAG directive accepts exactly two arguments");
-		handle = args[0];
-		prefix = args[1];
-		if (!PATTERN_TAG_HANDLE.test(handle)) throwError(state, "ill-formed tag handle (first argument) of the TAG directive");
-		if (_hasOwnProperty$1.call(state.tagMap, handle)) throwError(state, "there is a previously declared suffix for \"" + handle + "\" tag handle");
-		if (!PATTERN_TAG_URI.test(prefix)) throwError(state, "ill-formed tag prefix (second argument) of the TAG directive");
-		try {
-			prefix = decodeURIComponent(prefix);
-		} catch (err) {
-			throwError(state, "tag prefix is malformed: " + prefix);
+}));
+var require_set = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	var _hasOwnProperty = Object.prototype.hasOwnProperty;
+	function resolveYamlSet(data) {
+		if (data === null) return true;
+		const object = data;
+		for (const key in object) if (_hasOwnProperty.call(object, key)) {
+			if (object[key] !== null) return false;
 		}
-		state.tagMap[handle] = prefix;
+		return true;
 	}
-};
-function captureSegment(state, start, end, checkJson) {
-	var _position, _length, _character, _result;
-	if (start < end) {
-		_result = state.input.slice(start, end);
-		if (checkJson) for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
-			_character = _result.charCodeAt(_position);
-			if (!(_character === 9 || 32 <= _character && _character <= 1114111)) throwError(state, "expected valid JSON character");
-		}
-		else if (PATTERN_NON_PRINTABLE.test(_result)) throwError(state, "the stream contains non-printable characters");
-		state.result += _result;
-	}
-}
-function mergeMappings(state, destination, source, overridableKeys) {
-	var sourceKeys, key, index, quantity;
-	if (!common.isObject(source)) throwError(state, "cannot merge mappings; the provided source object is unacceptable");
-	sourceKeys = Object.keys(source);
-	for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
-		key = sourceKeys[index];
-		if (!_hasOwnProperty$1.call(destination, key)) {
-			setProperty(destination, key, source[key]);
-			overridableKeys[key] = true;
-		}
-	}
-}
-function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) {
-	var index, quantity;
-	if (Array.isArray(keyNode)) {
-		keyNode = Array.prototype.slice.call(keyNode);
-		for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
-			if (Array.isArray(keyNode[index])) throwError(state, "nested arrays are not supported inside keys");
-			if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") keyNode[index] = "[object Object]";
-		}
-	}
-	if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") keyNode = "[object Object]";
-	keyNode = String(keyNode);
-	if (_result === null) _result = {};
-	if (keyTag === "tag:yaml.org,2002:merge") if (Array.isArray(valueNode)) for (index = 0, quantity = valueNode.length; index < quantity; index += 1) mergeMappings(state, _result, valueNode[index], overridableKeys);
-	else mergeMappings(state, _result, valueNode, overridableKeys);
-	else {
-		if (!state.json && !_hasOwnProperty$1.call(overridableKeys, keyNode) && _hasOwnProperty$1.call(_result, keyNode)) {
-			state.line = startLine || state.line;
-			state.lineStart = startLineStart || state.lineStart;
-			state.position = startPos || state.position;
-			throwError(state, "duplicated mapping key");
+	function constructYamlSet(data) {
+		return data !== null ? data : {};
+	}
+	module.exports = new Type("tag:yaml.org,2002:set", {
+		kind: "mapping",
+		resolve: resolveYamlSet,
+		construct: constructYamlSet
+	});
+}));
+var require_default = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_core().extend({
+		implicit: [require_timestamp(), require_merge()],
+		explicit: [
+			require_binary(),
+			require_omap(),
+			require_pairs(),
+			require_set()
+		]
+	});
+}));
+var require_loader = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var common = require_common();
+	var YAMLException = require_exception();
+	var makeSnippet = require_snippet();
+	var DEFAULT_SCHEMA = require_default();
+	var _hasOwnProperty = Object.prototype.hasOwnProperty;
+	var CONTEXT_FLOW_IN = 1;
+	var CONTEXT_FLOW_OUT = 2;
+	var CONTEXT_BLOCK_IN = 3;
+	var CONTEXT_BLOCK_OUT = 4;
+	var CHOMPING_CLIP = 1;
+	var CHOMPING_STRIP = 2;
+	var CHOMPING_KEEP = 3;
+	var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+	var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+	var PATTERN_FLOW_INDICATORS = /[,\[\]{}]/;
+	var PATTERN_TAG_HANDLE = /^(?:!|!!|![0-9A-Za-z-]+!)$/;
+	var PATTERN_TAG_URI = /^(?:!|[^,\[\]{}])(?:%[0-9a-f]{2}|[0-9a-z\-#;/?:@&=+$,_.!~*'()\[\]])*$/i;
+	function _class(obj) {
+		return Object.prototype.toString.call(obj);
+	}
+	function isEol(c) {
+		return c === 10 || c === 13;
+	}
+	function isWhiteSpace(c) {
+		return c === 9 || c === 32;
+	}
+	function isWsOrEol(c) {
+		return c === 9 || c === 32 || c === 10 || c === 13;
+	}
+	function isFlowIndicator(c) {
+		return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
+	}
+	function fromHexCode(c) {
+		if (c >= 48 && c <= 57) return c - 48;
+		const lc = c | 32;
+		if (lc >= 97 && lc <= 102) return lc - 97 + 10;
+		return -1;
+	}
+	function escapedHexLen(c) {
+		if (c === 120) return 2;
+		if (c === 117) return 4;
+		if (c === 85) return 8;
+		return 0;
+	}
+	function fromDecimalCode(c) {
+		if (c >= 48 && c <= 57) return c - 48;
+		return -1;
+	}
+	function simpleEscapeSequence(c) {
+		switch (c) {
+			case 48: return "\0";
+			case 97: return "\x07";
+			case 98: return "\b";
+			case 116: return "	";
+			case 9: return "	";
+			case 110: return "\n";
+			case 118: return "\v";
+			case 102: return "\f";
+			case 114: return "\r";
+			case 101: return "\x1B";
+			case 32: return " ";
+			case 34: return "\"";
+			case 47: return "/";
+			case 92: return "\\";
+			case 78: return "…";
+			case 95: return "\xA0";
+			case 76: return "\u2028";
+			case 80: return "\u2029";
+			default: return "";
+		}
+	}
+	function charFromCodepoint(c) {
+		if (c <= 65535) return String.fromCharCode(c);
+		return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320);
+	}
+	function setProperty(object, key, value) {
+		if (key === "__proto__") Object.defineProperty(object, key, {
+			configurable: true,
+			enumerable: true,
+			writable: true,
+			value
+		});
+		else object[key] = value;
+	}
+	var simpleEscapeCheck = new Array(256);
+	var simpleEscapeMap = new Array(256);
+	for (let i = 0; i < 256; i++) {
+		simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
+		simpleEscapeMap[i] = simpleEscapeSequence(i);
+	}
+	function State(input, options) {
+		this.input = input;
+		this.filename = options["filename"] || null;
+		this.schema = options["schema"] || DEFAULT_SCHEMA;
+		this.onWarning = options["onWarning"] || null;
+		this.legacy = options["legacy"] || false;
+		this.json = options["json"] || false;
+		this.listener = options["listener"] || null;
+		this.maxDepth = typeof options["maxDepth"] === "number" ? options["maxDepth"] : 100;
+		this.maxMergeSeqLength = typeof options["maxMergeSeqLength"] === "number" ? options["maxMergeSeqLength"] : 20;
+		this.implicitTypes = this.schema.compiledImplicit;
+		this.typeMap = this.schema.compiledTypeMap;
+		this.length = input.length;
+		this.position = 0;
+		this.line = 0;
+		this.lineStart = 0;
+		this.lineIndent = 0;
+		this.depth = 0;
+		this.firstTabInLine = -1;
+		this.documents = [];
+		this.anchorMapTransactions = [];
+	}
+	function generateError(state, message) {
+		const mark = {
+			name: state.filename,
+			buffer: state.input.slice(0, -1),
+			position: state.position,
+			line: state.line,
+			column: state.position - state.lineStart
+		};
+		mark.snippet = makeSnippet(mark);
+		return new YAMLException(message, mark);
+	}
+	function throwError(state, message) {
+		throw generateError(state, message);
+	}
+	function throwWarning(state, message) {
+		if (state.onWarning) state.onWarning.call(null, generateError(state, message));
+	}
+	function storeAnchor(state, name, value) {
+		const transactions = state.anchorMapTransactions;
+		if (transactions.length !== 0) {
+			const transaction = transactions[transactions.length - 1];
+			if (!_hasOwnProperty.call(transaction, name)) transaction[name] = {
+				existed: _hasOwnProperty.call(state.anchorMap, name),
+				value: state.anchorMap[name]
+			};
 		}
-		setProperty(_result, keyNode, valueNode);
-		delete overridableKeys[keyNode];
+		state.anchorMap[name] = value;
 	}
-	return _result;
-}
-function readLineBreak(state) {
-	var ch = state.input.charCodeAt(state.position);
-	if (ch === 10) state.position++;
-	else if (ch === 13) {
-		state.position++;
-		if (state.input.charCodeAt(state.position) === 10) state.position++;
-	} else throwError(state, "a line break is expected");
-	state.line += 1;
-	state.lineStart = state.position;
-	state.firstTabInLine = -1;
-}
-function skipSeparationSpace(state, allowComments, checkIndent) {
-	var lineBreaks = 0, ch = state.input.charCodeAt(state.position);
-	while (ch !== 0) {
-		while (is_WHITE_SPACE(ch)) {
-			if (ch === 9 && state.firstTabInLine === -1) state.firstTabInLine = state.position;
-			ch = state.input.charCodeAt(++state.position);
+	function beginAnchorTransaction(state) {
+		state.anchorMapTransactions.push(Object.create(null));
+	}
+	function commitAnchorTransaction(state) {
+		const transaction = state.anchorMapTransactions.pop();
+		const transactions = state.anchorMapTransactions;
+		if (transactions.length === 0) return;
+		const parent = transactions[transactions.length - 1];
+		const names = Object.keys(transaction);
+		for (let index = 0, length = names.length; index < length; index += 1) {
+			const name = names[index];
+			if (!_hasOwnProperty.call(parent, name)) parent[name] = transaction[name];
 		}
-		if (allowComments && ch === 35) do
-			ch = state.input.charCodeAt(++state.position);
-		while (ch !== 10 && ch !== 13 && ch !== 0);
-		if (is_EOL(ch)) {
-			readLineBreak(state);
-			ch = state.input.charCodeAt(state.position);
-			lineBreaks++;
-			state.lineIndent = 0;
-			while (ch === 32) {
-				state.lineIndent++;
-				ch = state.input.charCodeAt(++state.position);
+	}
+	function rollbackAnchorTransaction(state) {
+		const transaction = state.anchorMapTransactions.pop();
+		const names = Object.keys(transaction);
+		for (let index = names.length - 1; index >= 0; index -= 1) {
+			const entry = transaction[names[index]];
+			if (entry.existed) state.anchorMap[names[index]] = entry.value;
+			else delete state.anchorMap[names[index]];
+		}
+	}
+	function snapshotState(state) {
+		return {
+			position: state.position,
+			line: state.line,
+			lineStart: state.lineStart,
+			lineIndent: state.lineIndent,
+			firstTabInLine: state.firstTabInLine,
+			tag: state.tag,
+			anchor: state.anchor,
+			kind: state.kind,
+			result: state.result
+		};
+	}
+	function restoreState(state, snapshot) {
+		state.position = snapshot.position;
+		state.line = snapshot.line;
+		state.lineStart = snapshot.lineStart;
+		state.lineIndent = snapshot.lineIndent;
+		state.firstTabInLine = snapshot.firstTabInLine;
+		state.tag = snapshot.tag;
+		state.anchor = snapshot.anchor;
+		state.kind = snapshot.kind;
+		state.result = snapshot.result;
+	}
+	var directiveHandlers = {
+		YAML: function handleYamlDirective(state, name, args) {
+			if (state.version !== null) throwError(state, "duplication of %YAML directive");
+			if (args.length !== 1) throwError(state, "YAML directive accepts exactly one argument");
+			const match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+			if (match === null) throwError(state, "ill-formed argument of the YAML directive");
+			const major = parseInt(match[1], 10);
+			const minor = parseInt(match[2], 10);
+			if (major !== 1) throwError(state, "unacceptable YAML version of the document");
+			state.version = args[0];
+			state.checkLineBreaks = minor < 2;
+			if (minor !== 1 && minor !== 2) throwWarning(state, "unsupported YAML version of the document");
+		},
+		TAG: function handleTagDirective(state, name, args) {
+			let prefix;
+			if (args.length !== 2) throwError(state, "TAG directive accepts exactly two arguments");
+			const handle = args[0];
+			prefix = args[1];
+			if (!PATTERN_TAG_HANDLE.test(handle)) throwError(state, "ill-formed tag handle (first argument) of the TAG directive");
+			if (_hasOwnProperty.call(state.tagMap, handle)) throwError(state, "there is a previously declared suffix for \"" + handle + "\" tag handle");
+			if (!PATTERN_TAG_URI.test(prefix)) throwError(state, "ill-formed tag prefix (second argument) of the TAG directive");
+			try {
+				prefix = decodeURIComponent(prefix);
+			} catch (err) {
+				throwError(state, "tag prefix is malformed: " + prefix);
 			}
-		} else break;
+			state.tagMap[handle] = prefix;
+		}
+	};
+	function captureSegment(state, start, end, checkJson) {
+		if (start < end) {
+			const _result = state.input.slice(start, end);
+			if (checkJson) for (let _position = 0, _length = _result.length; _position < _length; _position += 1) {
+				const _character = _result.charCodeAt(_position);
+				if (!(_character === 9 || _character >= 32 && _character <= 1114111)) throwError(state, "expected valid JSON character");
+			}
+			else if (PATTERN_NON_PRINTABLE.test(_result)) throwError(state, "the stream contains non-printable characters");
+			state.result += _result;
+		}
 	}
-	if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) throwWarning(state, "deficient indentation");
-	return lineBreaks;
-}
-function testDocumentSeparator(state) {
-	var _position = state.position, ch = state.input.charCodeAt(_position);
-	if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
-		_position += 3;
-		ch = state.input.charCodeAt(_position);
-		if (ch === 0 || is_WS_OR_EOL(ch)) return true;
+	function mergeMappings(state, destination, source, overridableKeys) {
+		if (!common.isObject(source)) throwError(state, "cannot merge mappings; the provided source object is unacceptable");
+		const sourceKeys = Object.keys(source);
+		for (let index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
+			const key = sourceKeys[index];
+			if (!_hasOwnProperty.call(destination, key)) {
+				setProperty(destination, key, source[key]);
+				overridableKeys[key] = true;
+			}
+		}
 	}
-	return false;
-}
-function writeFoldedLines(state, count) {
-	if (count === 1) state.result += " ";
-	else if (count > 1) state.result += common.repeat("\n", count - 1);
-}
-function readPlainScalar(state, nodeIndent, withinFlowCollection) {
-	var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state.kind, _result = state.result, ch = state.input.charCodeAt(state.position);
-	if (is_WS_OR_EOL(ch) || is_FLOW_INDICATOR(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) return false;
-	if (ch === 63 || ch === 45) {
-		following = state.input.charCodeAt(state.position + 1);
-		if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) return false;
-	}
-	state.kind = "scalar";
-	state.result = "";
-	captureStart = captureEnd = state.position;
-	hasPendingContent = false;
-	while (ch !== 0) {
-		if (ch === 58) {
-			following = state.input.charCodeAt(state.position + 1);
-			if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) break;
-		} else if (ch === 35) {
-			preceding = state.input.charCodeAt(state.position - 1);
-			if (is_WS_OR_EOL(preceding)) break;
-		} else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && is_FLOW_INDICATOR(ch)) break;
-		else if (is_EOL(ch)) {
-			_line = state.line;
-			_lineStart = state.lineStart;
-			_lineIndent = state.lineIndent;
-			skipSeparationSpace(state, false, -1);
-			if (state.lineIndent >= nodeIndent) {
-				hasPendingContent = true;
-				ch = state.input.charCodeAt(state.position);
-				continue;
-			} else {
-				state.position = captureEnd;
-				state.line = _line;
-				state.lineStart = _lineStart;
-				state.lineIndent = _lineIndent;
-				break;
+	function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) {
+		if (Array.isArray(keyNode)) {
+			keyNode = Array.prototype.slice.call(keyNode);
+			for (let index = 0, quantity = keyNode.length; index < quantity; index += 1) {
+				if (Array.isArray(keyNode[index])) throwError(state, "nested arrays are not supported inside keys");
+				if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") keyNode[index] = "[object Object]";
 			}
 		}
-		if (hasPendingContent) {
-			captureSegment(state, captureStart, captureEnd, false);
-			writeFoldedLines(state, state.line - _line);
-			captureStart = captureEnd = state.position;
-			hasPendingContent = false;
+		if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") keyNode = "[object Object]";
+		keyNode = String(keyNode);
+		if (_result === null) _result = {};
+		if (keyTag === "tag:yaml.org,2002:merge") if (Array.isArray(valueNode)) {
+			if (valueNode.length > state.maxMergeSeqLength) throwError(state, "merge sequence length exceeded maxMergeSeqLength (" + state.maxMergeSeqLength + ")");
+			const seen = /* @__PURE__ */ new Set();
+			for (let index = 0, quantity = valueNode.length; index < quantity; index += 1) {
+				const src = valueNode[index];
+				if (seen.has(src)) continue;
+				seen.add(src);
+				mergeMappings(state, _result, src, overridableKeys);
+			}
+		} else mergeMappings(state, _result, valueNode, overridableKeys);
+		else {
+			if (!state.json && !_hasOwnProperty.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) {
+				state.line = startLine || state.line;
+				state.lineStart = startLineStart || state.lineStart;
+				state.position = startPos || state.position;
+				throwError(state, "duplicated mapping key");
+			}
+			setProperty(_result, keyNode, valueNode);
+			delete overridableKeys[keyNode];
 		}
-		if (!is_WHITE_SPACE(ch)) captureEnd = state.position + 1;
-		ch = state.input.charCodeAt(++state.position);
+		return _result;
 	}
-	captureSegment(state, captureStart, captureEnd, false);
-	if (state.result) return true;
-	state.kind = _kind;
-	state.result = _result;
-	return false;
-}
-function readSingleQuotedScalar(state, nodeIndent) {
-	var ch = state.input.charCodeAt(state.position), captureStart, captureEnd;
-	if (ch !== 39) return false;
-	state.kind = "scalar";
-	state.result = "";
-	state.position++;
-	captureStart = captureEnd = state.position;
-	while ((ch = state.input.charCodeAt(state.position)) !== 0) if (ch === 39) {
-		captureSegment(state, captureStart, state.position, true);
-		ch = state.input.charCodeAt(++state.position);
-		if (ch === 39) {
-			captureStart = state.position;
+	function readLineBreak(state) {
+		const ch = state.input.charCodeAt(state.position);
+		if (ch === 10) state.position++;
+		else if (ch === 13) {
 			state.position++;
-			captureEnd = state.position;
-		} else return true;
-	} else if (is_EOL(ch)) {
-		captureSegment(state, captureStart, captureEnd, true);
-		writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
-		captureStart = captureEnd = state.position;
-	} else if (state.position === state.lineStart && testDocumentSeparator(state)) throwError(state, "unexpected end of the document within a single quoted scalar");
-	else {
-		state.position++;
-		captureEnd = state.position;
-	}
-	throwError(state, "unexpected end of the stream within a single quoted scalar");
-}
-function readDoubleQuotedScalar(state, nodeIndent) {
-	var captureStart, captureEnd, hexLength, hexResult, tmp, ch = state.input.charCodeAt(state.position);
-	if (ch !== 34) return false;
-	state.kind = "scalar";
-	state.result = "";
-	state.position++;
-	captureStart = captureEnd = state.position;
-	while ((ch = state.input.charCodeAt(state.position)) !== 0) if (ch === 34) {
-		captureSegment(state, captureStart, state.position, true);
-		state.position++;
-		return true;
-	} else if (ch === 92) {
-		captureSegment(state, captureStart, state.position, true);
-		ch = state.input.charCodeAt(++state.position);
-		if (is_EOL(ch)) skipSeparationSpace(state, false, nodeIndent);
-		else if (ch < 256 && simpleEscapeCheck[ch]) {
-			state.result += simpleEscapeMap[ch];
-			state.position++;
-		} else if ((tmp = escapedHexLen(ch)) > 0) {
-			hexLength = tmp;
-			hexResult = 0;
-			for (; hexLength > 0; hexLength--) {
+			if (state.input.charCodeAt(state.position) === 10) state.position++;
+		} else throwError(state, "a line break is expected");
+		state.line += 1;
+		state.lineStart = state.position;
+		state.firstTabInLine = -1;
+	}
+	function skipSeparationSpace(state, allowComments, checkIndent) {
+		let lineBreaks = 0;
+		let ch = state.input.charCodeAt(state.position);
+		while (ch !== 0) {
+			while (isWhiteSpace(ch)) {
+				if (ch === 9 && state.firstTabInLine === -1) state.firstTabInLine = state.position;
 				ch = state.input.charCodeAt(++state.position);
-				if ((tmp = fromHexCode(ch)) >= 0) hexResult = (hexResult << 4) + tmp;
-				else throwError(state, "expected hexadecimal character");
 			}
-			state.result += charFromCodepoint(hexResult);
-			state.position++;
-		} else throwError(state, "unknown escape sequence");
+			if (allowComments && ch === 35) do
+				ch = state.input.charCodeAt(++state.position);
+			while (ch !== 10 && ch !== 13 && ch !== 0);
+			if (isEol(ch)) {
+				readLineBreak(state);
+				ch = state.input.charCodeAt(state.position);
+				lineBreaks++;
+				state.lineIndent = 0;
+				while (ch === 32) {
+					state.lineIndent++;
+					ch = state.input.charCodeAt(++state.position);
+				}
+			} else break;
+		}
+		if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) throwWarning(state, "deficient indentation");
+		return lineBreaks;
+	}
+	function testDocumentSeparator(state) {
+		let _position = state.position;
+		let ch = state.input.charCodeAt(_position);
+		if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
+			_position += 3;
+			ch = state.input.charCodeAt(_position);
+			if (ch === 0 || isWsOrEol(ch)) return true;
+		}
+		return false;
+	}
+	function writeFoldedLines(state, count) {
+		if (count === 1) state.result += " ";
+		else if (count > 1) state.result += common.repeat("\n", count - 1);
+	}
+	function readPlainScalar(state, nodeIndent, withinFlowCollection) {
+		let captureStart;
+		let captureEnd;
+		let hasPendingContent;
+		let _line;
+		let _lineStart;
+		let _lineIndent;
+		const _kind = state.kind;
+		const _result = state.result;
+		let ch = state.input.charCodeAt(state.position);
+		if (isWsOrEol(ch) || isFlowIndicator(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) return false;
+		if (ch === 63 || ch === 45) {
+			const following = state.input.charCodeAt(state.position + 1);
+			if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following)) return false;
+		}
+		state.kind = "scalar";
+		state.result = "";
 		captureStart = captureEnd = state.position;
-	} else if (is_EOL(ch)) {
-		captureSegment(state, captureStart, captureEnd, true);
-		writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+		hasPendingContent = false;
+		while (ch !== 0) {
+			if (ch === 58) {
+				const following = state.input.charCodeAt(state.position + 1);
+				if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following)) break;
+			} else if (ch === 35) {
+				if (isWsOrEol(state.input.charCodeAt(state.position - 1))) break;
+			} else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && isFlowIndicator(ch)) break;
+			else if (isEol(ch)) {
+				_line = state.line;
+				_lineStart = state.lineStart;
+				_lineIndent = state.lineIndent;
+				skipSeparationSpace(state, false, -1);
+				if (state.lineIndent >= nodeIndent) {
+					hasPendingContent = true;
+					ch = state.input.charCodeAt(state.position);
+					continue;
+				} else {
+					state.position = captureEnd;
+					state.line = _line;
+					state.lineStart = _lineStart;
+					state.lineIndent = _lineIndent;
+					break;
+				}
+			}
+			if (hasPendingContent) {
+				captureSegment(state, captureStart, captureEnd, false);
+				writeFoldedLines(state, state.line - _line);
+				captureStart = captureEnd = state.position;
+				hasPendingContent = false;
+			}
+			if (!isWhiteSpace(ch)) captureEnd = state.position + 1;
+			ch = state.input.charCodeAt(++state.position);
+		}
+		captureSegment(state, captureStart, captureEnd, false);
+		if (state.result) return true;
+		state.kind = _kind;
+		state.result = _result;
+		return false;
+	}
+	function readSingleQuotedScalar(state, nodeIndent) {
+		let captureStart;
+		let captureEnd;
+		let ch = state.input.charCodeAt(state.position);
+		if (ch !== 39) return false;
+		state.kind = "scalar";
+		state.result = "";
+		state.position++;
 		captureStart = captureEnd = state.position;
-	} else if (state.position === state.lineStart && testDocumentSeparator(state)) throwError(state, "unexpected end of the document within a double quoted scalar");
-	else {
+		while ((ch = state.input.charCodeAt(state.position)) !== 0) if (ch === 39) {
+			captureSegment(state, captureStart, state.position, true);
+			ch = state.input.charCodeAt(++state.position);
+			if (ch === 39) {
+				captureStart = state.position;
+				state.position++;
+				captureEnd = state.position;
+			} else return true;
+		} else if (isEol(ch)) {
+			captureSegment(state, captureStart, captureEnd, true);
+			writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+			captureStart = captureEnd = state.position;
+		} else if (state.position === state.lineStart && testDocumentSeparator(state)) throwError(state, "unexpected end of the document within a single quoted scalar");
+		else {
+			state.position++;
+			if (!isWhiteSpace(ch)) captureEnd = state.position;
+		}
+		throwError(state, "unexpected end of the stream within a single quoted scalar");
+	}
+	function readDoubleQuotedScalar(state, nodeIndent) {
+		let captureStart;
+		let captureEnd;
+		let tmp;
+		let ch = state.input.charCodeAt(state.position);
+		if (ch !== 34) return false;
+		state.kind = "scalar";
+		state.result = "";
 		state.position++;
-		captureEnd = state.position;
-	}
-	throwError(state, "unexpected end of the stream within a double quoted scalar");
-}
-function readFlowCollection(state, nodeIndent) {
-	var readNext = true, _line, _lineStart, _pos, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = Object.create(null), keyNode, keyTag, valueNode, ch = state.input.charCodeAt(state.position);
-	if (ch === 91) {
-		terminator = 93;
-		isMapping = false;
-		_result = [];
-	} else if (ch === 123) {
-		terminator = 125;
-		isMapping = true;
-		_result = {};
-	} else return false;
-	if (state.anchor !== null) state.anchorMap[state.anchor] = _result;
-	ch = state.input.charCodeAt(++state.position);
-	while (ch !== 0) {
-		skipSeparationSpace(state, true, nodeIndent);
-		ch = state.input.charCodeAt(state.position);
-		if (ch === terminator) {
+		captureStart = captureEnd = state.position;
+		while ((ch = state.input.charCodeAt(state.position)) !== 0) if (ch === 34) {
+			captureSegment(state, captureStart, state.position, true);
 			state.position++;
-			state.tag = _tag;
-			state.anchor = _anchor;
-			state.kind = isMapping ? "mapping" : "sequence";
-			state.result = _result;
 			return true;
-		} else if (!readNext) throwError(state, "missed comma between flow collection entries");
-		else if (ch === 44) throwError(state, "expected the node content, but found ','");
-		keyTag = keyNode = valueNode = null;
-		isPair = isExplicitPair = false;
-		if (ch === 63) {
-			following = state.input.charCodeAt(state.position + 1);
-			if (is_WS_OR_EOL(following)) {
-				isPair = isExplicitPair = true;
+		} else if (ch === 92) {
+			captureSegment(state, captureStart, state.position, true);
+			ch = state.input.charCodeAt(++state.position);
+			if (isEol(ch)) skipSeparationSpace(state, false, nodeIndent);
+			else if (ch < 256 && simpleEscapeCheck[ch]) {
+				state.result += simpleEscapeMap[ch];
+				state.position++;
+			} else if ((tmp = escapedHexLen(ch)) > 0) {
+				let hexLength = tmp;
+				let hexResult = 0;
+				for (; hexLength > 0; hexLength--) {
+					ch = state.input.charCodeAt(++state.position);
+					if ((tmp = fromHexCode(ch)) >= 0) hexResult = (hexResult << 4) + tmp;
+					else throwError(state, "expected hexadecimal character");
+				}
+				state.result += charFromCodepoint(hexResult);
 				state.position++;
+			} else throwError(state, "unknown escape sequence");
+			captureStart = captureEnd = state.position;
+		} else if (isEol(ch)) {
+			captureSegment(state, captureStart, captureEnd, true);
+			writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+			captureStart = captureEnd = state.position;
+		} else if (state.position === state.lineStart && testDocumentSeparator(state)) throwError(state, "unexpected end of the document within a double quoted scalar");
+		else {
+			state.position++;
+			if (!isWhiteSpace(ch)) captureEnd = state.position;
+		}
+		throwError(state, "unexpected end of the stream within a double quoted scalar");
+	}
+	function readFlowCollection(state, nodeIndent) {
+		let readNext = true;
+		let _line;
+		let _lineStart;
+		let _pos;
+		const _tag = state.tag;
+		let _result;
+		const _anchor = state.anchor;
+		let terminator;
+		let isPair;
+		let isExplicitPair;
+		let isMapping;
+		const overridableKeys = Object.create(null);
+		let keyNode;
+		let keyTag;
+		let valueNode;
+		let ch = state.input.charCodeAt(state.position);
+		if (ch === 91) {
+			terminator = 93;
+			isMapping = false;
+			_result = [];
+		} else if (ch === 123) {
+			terminator = 125;
+			isMapping = true;
+			_result = {};
+		} else return false;
+		if (state.anchor !== null) storeAnchor(state, state.anchor, _result);
+		ch = state.input.charCodeAt(++state.position);
+		while (ch !== 0) {
+			skipSeparationSpace(state, true, nodeIndent);
+			ch = state.input.charCodeAt(state.position);
+			if (ch === terminator) {
+				state.position++;
+				state.tag = _tag;
+				state.anchor = _anchor;
+				state.kind = isMapping ? "mapping" : "sequence";
+				state.result = _result;
+				return true;
+			} else if (!readNext) throwError(state, "missed comma between flow collection entries");
+			else if (ch === 44) throwError(state, "expected the node content, but found ','");
+			keyTag = keyNode = valueNode = null;
+			isPair = isExplicitPair = false;
+			if (ch === 63) {
+				if (isWsOrEol(state.input.charCodeAt(state.position + 1))) {
+					isPair = isExplicitPair = true;
+					state.position++;
+					skipSeparationSpace(state, true, nodeIndent);
+				}
+			}
+			_line = state.line;
+			_lineStart = state.lineStart;
+			_pos = state.position;
+			composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+			keyTag = state.tag;
+			keyNode = state.result;
+			skipSeparationSpace(state, true, nodeIndent);
+			ch = state.input.charCodeAt(state.position);
+			if ((isExplicitPair || state.line === _line) && ch === 58) {
+				isPair = true;
+				ch = state.input.charCodeAt(++state.position);
 				skipSeparationSpace(state, true, nodeIndent);
+				composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+				valueNode = state.result;
 			}
-		}
-		_line = state.line;
-		_lineStart = state.lineStart;
-		_pos = state.position;
-		composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
-		keyTag = state.tag;
-		keyNode = state.result;
-		skipSeparationSpace(state, true, nodeIndent);
-		ch = state.input.charCodeAt(state.position);
-		if ((isExplicitPair || state.line === _line) && ch === 58) {
-			isPair = true;
-			ch = state.input.charCodeAt(++state.position);
+			if (isMapping) storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
+			else if (isPair) _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
+			else _result.push(keyNode);
 			skipSeparationSpace(state, true, nodeIndent);
-			composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
-			valueNode = state.result;
-		}
-		if (isMapping) storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
-		else if (isPair) _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
-		else _result.push(keyNode);
-		skipSeparationSpace(state, true, nodeIndent);
-		ch = state.input.charCodeAt(state.position);
-		if (ch === 44) {
-			readNext = true;
-			ch = state.input.charCodeAt(++state.position);
-		} else readNext = false;
-	}
-	throwError(state, "unexpected end of the stream within a flow collection");
-}
-function readBlockScalar(state, nodeIndent) {
-	var captureStart, folding, chomping = CHOMPING_CLIP, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch = state.input.charCodeAt(state.position);
-	if (ch === 124) folding = false;
-	else if (ch === 62) folding = true;
-	else return false;
-	state.kind = "scalar";
-	state.result = "";
-	while (ch !== 0) {
-		ch = state.input.charCodeAt(++state.position);
-		if (ch === 43 || ch === 45) if (CHOMPING_CLIP === chomping) chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP;
-		else throwError(state, "repeat of a chomping mode identifier");
-		else if ((tmp = fromDecimalCode(ch)) >= 0) if (tmp === 0) throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
-		else if (!detectedIndent) {
-			textIndent = nodeIndent + tmp - 1;
-			detectedIndent = true;
-		} else throwError(state, "repeat of an indentation width identifier");
-		else break;
-	}
-	if (is_WHITE_SPACE(ch)) {
-		do
-			ch = state.input.charCodeAt(++state.position);
-		while (is_WHITE_SPACE(ch));
-		if (ch === 35) do
-			ch = state.input.charCodeAt(++state.position);
-		while (!is_EOL(ch) && ch !== 0);
-	}
-	while (ch !== 0) {
-		readLineBreak(state);
-		state.lineIndent = 0;
-		ch = state.input.charCodeAt(state.position);
-		while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) {
-			state.lineIndent++;
+			ch = state.input.charCodeAt(state.position);
+			if (ch === 44) {
+				readNext = true;
+				ch = state.input.charCodeAt(++state.position);
+			} else readNext = false;
+		}
+		throwError(state, "unexpected end of the stream within a flow collection");
+	}
+	function readBlockScalar(state, nodeIndent) {
+		let folding;
+		let chomping = CHOMPING_CLIP;
+		let didReadContent = false;
+		let detectedIndent = false;
+		let textIndent = nodeIndent;
+		let emptyLines = 0;
+		let atMoreIndented = false;
+		let tmp;
+		let ch = state.input.charCodeAt(state.position);
+		if (ch === 124) folding = false;
+		else if (ch === 62) folding = true;
+		else return false;
+		state.kind = "scalar";
+		state.result = "";
+		while (ch !== 0) {
 			ch = state.input.charCodeAt(++state.position);
+			if (ch === 43 || ch === 45) if (CHOMPING_CLIP === chomping) chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP;
+			else throwError(state, "repeat of a chomping mode identifier");
+			else if ((tmp = fromDecimalCode(ch)) >= 0) if (tmp === 0) throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
+			else if (!detectedIndent) {
+				textIndent = nodeIndent + tmp - 1;
+				detectedIndent = true;
+			} else throwError(state, "repeat of an indentation width identifier");
+			else break;
 		}
-		if (!detectedIndent && state.lineIndent > textIndent) textIndent = state.lineIndent;
-		if (is_EOL(ch)) {
-			emptyLines++;
-			continue;
+		if (isWhiteSpace(ch)) {
+			do
+				ch = state.input.charCodeAt(++state.position);
+			while (isWhiteSpace(ch));
+			if (ch === 35) do
+				ch = state.input.charCodeAt(++state.position);
+			while (!isEol(ch) && ch !== 0);
 		}
-		if (state.lineIndent < textIndent) {
-			if (chomping === CHOMPING_KEEP) state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
-			else if (chomping === CHOMPING_CLIP) {
-				if (didReadContent) state.result += "\n";
+		while (ch !== 0) {
+			readLineBreak(state);
+			state.lineIndent = 0;
+			ch = state.input.charCodeAt(state.position);
+			while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) {
+				state.lineIndent++;
+				ch = state.input.charCodeAt(++state.position);
 			}
-			break;
-		}
-		if (folding) if (is_WHITE_SPACE(ch)) {
-			atMoreIndented = true;
-			state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
-		} else if (atMoreIndented) {
-			atMoreIndented = false;
-			state.result += common.repeat("\n", emptyLines + 1);
-		} else if (emptyLines === 0) {
-			if (didReadContent) state.result += " ";
-		} else state.result += common.repeat("\n", emptyLines);
-		else state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
-		didReadContent = true;
-		detectedIndent = true;
-		emptyLines = 0;
-		captureStart = state.position;
-		while (!is_EOL(ch) && ch !== 0) ch = state.input.charCodeAt(++state.position);
-		captureSegment(state, captureStart, state.position, false);
-	}
-	return true;
-}
-function readBlockSequence(state, nodeIndent) {
-	var _line, _tag = state.tag, _anchor = state.anchor, _result = [], following, detected = false, ch;
-	if (state.firstTabInLine !== -1) return false;
-	if (state.anchor !== null) state.anchorMap[state.anchor] = _result;
-	ch = state.input.charCodeAt(state.position);
-	while (ch !== 0) {
-		if (state.firstTabInLine !== -1) {
-			state.position = state.firstTabInLine;
-			throwError(state, "tab characters must not be used in indentation");
-		}
-		if (ch !== 45) break;
-		following = state.input.charCodeAt(state.position + 1);
-		if (!is_WS_OR_EOL(following)) break;
-		detected = true;
-		state.position++;
-		if (skipSeparationSpace(state, true, -1)) {
-			if (state.lineIndent <= nodeIndent) {
-				_result.push(null);
-				ch = state.input.charCodeAt(state.position);
+			if (!detectedIndent && state.lineIndent > textIndent) textIndent = state.lineIndent;
+			if (isEol(ch)) {
+				emptyLines++;
 				continue;
 			}
+			if (!detectedIndent && textIndent === 0) throwError(state, "missing indentation for block scalar");
+			if (state.lineIndent < textIndent) {
+				if (chomping === CHOMPING_KEEP) state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+				else if (chomping === CHOMPING_CLIP) {
+					if (didReadContent) state.result += "\n";
+				}
+				break;
+			}
+			if (folding) if (isWhiteSpace(ch)) {
+				atMoreIndented = true;
+				state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+			} else if (atMoreIndented) {
+				atMoreIndented = false;
+				state.result += common.repeat("\n", emptyLines + 1);
+			} else if (emptyLines === 0) {
+				if (didReadContent) state.result += " ";
+			} else state.result += common.repeat("\n", emptyLines);
+			else state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+			didReadContent = true;
+			detectedIndent = true;
+			emptyLines = 0;
+			const captureStart = state.position;
+			while (!isEol(ch) && ch !== 0) ch = state.input.charCodeAt(++state.position);
+			captureSegment(state, captureStart, state.position, false);
 		}
-		_line = state.line;
-		composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
-		_result.push(state.result);
-		skipSeparationSpace(state, true, -1);
-		ch = state.input.charCodeAt(state.position);
-		if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) throwError(state, "bad indentation of a sequence entry");
-		else if (state.lineIndent < nodeIndent) break;
-	}
-	if (detected) {
-		state.tag = _tag;
-		state.anchor = _anchor;
-		state.kind = "sequence";
-		state.result = _result;
 		return true;
 	}
-	return false;
-}
-function readBlockMapping(state, nodeIndent, flowIndent) {
-	var following, allowCompact, _line, _keyLine, _keyLineStart, _keyPos, _tag = state.tag, _anchor = state.anchor, _result = {}, overridableKeys = Object.create(null), keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch;
-	if (state.firstTabInLine !== -1) return false;
-	if (state.anchor !== null) state.anchorMap[state.anchor] = _result;
-	ch = state.input.charCodeAt(state.position);
-	while (ch !== 0) {
-		if (!atExplicitKey && state.firstTabInLine !== -1) {
-			state.position = state.firstTabInLine;
-			throwError(state, "tab characters must not be used in indentation");
-		}
-		following = state.input.charCodeAt(state.position + 1);
-		_line = state.line;
-		if ((ch === 63 || ch === 58) && is_WS_OR_EOL(following)) {
-			if (ch === 63) {
-				if (atExplicitKey) {
-					storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
-					keyTag = keyNode = valueNode = null;
+	function readBlockSequence(state, nodeIndent) {
+		const _tag = state.tag;
+		const _anchor = state.anchor;
+		const _result = [];
+		let detected = false;
+		if (state.firstTabInLine !== -1) return false;
+		if (state.anchor !== null) storeAnchor(state, state.anchor, _result);
+		let ch = state.input.charCodeAt(state.position);
+		while (ch !== 0) {
+			if (state.firstTabInLine !== -1) {
+				state.position = state.firstTabInLine;
+				throwError(state, "tab characters must not be used in indentation");
+			}
+			if (ch !== 45) break;
+			if (!isWsOrEol(state.input.charCodeAt(state.position + 1))) break;
+			detected = true;
+			state.position++;
+			if (skipSeparationSpace(state, true, -1)) {
+				if (state.lineIndent <= nodeIndent) {
+					_result.push(null);
+					ch = state.input.charCodeAt(state.position);
+					continue;
 				}
-				detected = true;
-				atExplicitKey = true;
-				allowCompact = true;
-			} else if (atExplicitKey) {
-				atExplicitKey = false;
-				allowCompact = true;
-			} else throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
-			state.position += 1;
-			ch = following;
-		} else {
-			_keyLine = state.line;
-			_keyLineStart = state.lineStart;
-			_keyPos = state.position;
-			if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) break;
-			if (state.line === _line) {
-				ch = state.input.charCodeAt(state.position);
-				while (is_WHITE_SPACE(ch)) ch = state.input.charCodeAt(++state.position);
-				if (ch === 58) {
-					ch = state.input.charCodeAt(++state.position);
-					if (!is_WS_OR_EOL(ch)) throwError(state, "a whitespace character is expected after the key-value separator within a block mapping");
+			}
+			const _line = state.line;
+			composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
+			_result.push(state.result);
+			skipSeparationSpace(state, true, -1);
+			ch = state.input.charCodeAt(state.position);
+			if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) throwError(state, "bad indentation of a sequence entry");
+			else if (state.lineIndent < nodeIndent) break;
+		}
+		if (detected) {
+			state.tag = _tag;
+			state.anchor = _anchor;
+			state.kind = "sequence";
+			state.result = _result;
+			return true;
+		}
+		return false;
+	}
+	function readBlockMapping(state, nodeIndent, flowIndent) {
+		let allowCompact;
+		let _keyLine;
+		let _keyLineStart;
+		let _keyPos;
+		const _tag = state.tag;
+		const _anchor = state.anchor;
+		const _result = {};
+		const overridableKeys = Object.create(null);
+		let keyTag = null;
+		let keyNode = null;
+		let valueNode = null;
+		let atExplicitKey = false;
+		let detected = false;
+		if (state.firstTabInLine !== -1) return false;
+		if (state.anchor !== null) storeAnchor(state, state.anchor, _result);
+		let ch = state.input.charCodeAt(state.position);
+		while (ch !== 0) {
+			if (!atExplicitKey && state.firstTabInLine !== -1) {
+				state.position = state.firstTabInLine;
+				throwError(state, "tab characters must not be used in indentation");
+			}
+			const following = state.input.charCodeAt(state.position + 1);
+			const _line = state.line;
+			if ((ch === 63 || ch === 58) && isWsOrEol(following)) {
+				if (ch === 63) {
 					if (atExplicitKey) {
 						storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
 						keyTag = keyNode = valueNode = null;
 					}
-					detected = true;
-					atExplicitKey = false;
-					allowCompact = false;
-					keyTag = state.tag;
-					keyNode = state.result;
-				} else if (detected) throwError(state, "can not read an implicit mapping pair; a colon is missed");
+					detected = true;
+					atExplicitKey = true;
+					allowCompact = true;
+				} else if (atExplicitKey) {
+					atExplicitKey = false;
+					allowCompact = true;
+				} else throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
+				state.position += 1;
+				ch = following;
+			} else {
+				_keyLine = state.line;
+				_keyLineStart = state.lineStart;
+				_keyPos = state.position;
+				if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) break;
+				if (state.line === _line) {
+					ch = state.input.charCodeAt(state.position);
+					while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position);
+					if (ch === 58) {
+						ch = state.input.charCodeAt(++state.position);
+						if (!isWsOrEol(ch)) throwError(state, "a whitespace character is expected after the key-value separator within a block mapping");
+						if (atExplicitKey) {
+							storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+							keyTag = keyNode = valueNode = null;
+						}
+						detected = true;
+						atExplicitKey = false;
+						allowCompact = false;
+						keyTag = state.tag;
+						keyNode = state.result;
+					} else if (detected) throwError(state, "can not read an implicit mapping pair; a colon is missed");
+					else {
+						state.tag = _tag;
+						state.anchor = _anchor;
+						return true;
+					}
+				} else if (detected) throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
 				else {
 					state.tag = _tag;
 					state.anchor = _anchor;
 					return true;
 				}
-			} else if (detected) throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
-			else {
-				state.tag = _tag;
-				state.anchor = _anchor;
-				return true;
 			}
-		}
-		if (state.line === _line || state.lineIndent > nodeIndent) {
-			if (atExplicitKey) {
-				_keyLine = state.line;
-				_keyLineStart = state.lineStart;
-				_keyPos = state.position;
-			}
-			if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) if (atExplicitKey) keyNode = state.result;
-			else valueNode = state.result;
-			if (!atExplicitKey) {
-				storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
-				keyTag = keyNode = valueNode = null;
+			if (state.line === _line || state.lineIndent > nodeIndent) {
+				if (atExplicitKey) {
+					_keyLine = state.line;
+					_keyLineStart = state.lineStart;
+					_keyPos = state.position;
+				}
+				if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) if (atExplicitKey) keyNode = state.result;
+				else valueNode = state.result;
+				if (!atExplicitKey) {
+					storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
+					keyTag = keyNode = valueNode = null;
+				}
+				skipSeparationSpace(state, true, -1);
+				ch = state.input.charCodeAt(state.position);
 			}
-			skipSeparationSpace(state, true, -1);
-			ch = state.input.charCodeAt(state.position);
+			if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) throwError(state, "bad indentation of a mapping entry");
+			else if (state.lineIndent < nodeIndent) break;
 		}
-		if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) throwError(state, "bad indentation of a mapping entry");
-		else if (state.lineIndent < nodeIndent) break;
-	}
-	if (atExplicitKey) storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
-	if (detected) {
-		state.tag = _tag;
-		state.anchor = _anchor;
-		state.kind = "mapping";
-		state.result = _result;
+		if (atExplicitKey) storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+		if (detected) {
+			state.tag = _tag;
+			state.anchor = _anchor;
+			state.kind = "mapping";
+			state.result = _result;
+		}
+		return detected;
 	}
-	return detected;
-}
-function readTagProperty(state) {
-	var _position, isVerbatim = false, isNamed = false, tagHandle, tagName, ch = state.input.charCodeAt(state.position);
-	if (ch !== 33) return false;
-	if (state.tag !== null) throwError(state, "duplication of a tag property");
-	ch = state.input.charCodeAt(++state.position);
-	if (ch === 60) {
-		isVerbatim = true;
+	function readTagProperty(state) {
+		let isVerbatim = false;
+		let isNamed = false;
+		let tagHandle;
+		let tagName;
+		let ch = state.input.charCodeAt(state.position);
+		if (ch !== 33) return false;
+		if (state.tag !== null) throwError(state, "duplication of a tag property");
 		ch = state.input.charCodeAt(++state.position);
-	} else if (ch === 33) {
-		isNamed = true;
-		tagHandle = "!!";
-		ch = state.input.charCodeAt(++state.position);
-	} else tagHandle = "!";
-	_position = state.position;
-	if (isVerbatim) {
-		do
-			ch = state.input.charCodeAt(++state.position);
-		while (ch !== 0 && ch !== 62);
-		if (state.position < state.length) {
-			tagName = state.input.slice(_position, state.position);
+		if (ch === 60) {
+			isVerbatim = true;
 			ch = state.input.charCodeAt(++state.position);
-		} else throwError(state, "unexpected end of the stream within a verbatim tag");
-	} else {
-		while (ch !== 0 && !is_WS_OR_EOL(ch)) {
-			if (ch === 33) if (!isNamed) {
-				tagHandle = state.input.slice(_position - 1, state.position + 1);
-				if (!PATTERN_TAG_HANDLE.test(tagHandle)) throwError(state, "named tag handle cannot contain such characters");
-				isNamed = true;
-				_position = state.position + 1;
-			} else throwError(state, "tag suffix cannot contain exclamation marks");
+		} else if (ch === 33) {
+			isNamed = true;
+			tagHandle = "!!";
 			ch = state.input.charCodeAt(++state.position);
-		}
-		tagName = state.input.slice(_position, state.position);
-		if (PATTERN_FLOW_INDICATORS.test(tagName)) throwError(state, "tag suffix cannot contain flow indicator characters");
-	}
-	if (tagName && !PATTERN_TAG_URI.test(tagName)) throwError(state, "tag name cannot contain such characters: " + tagName);
-	try {
-		tagName = decodeURIComponent(tagName);
-	} catch (err) {
-		throwError(state, "tag name is malformed: " + tagName);
-	}
-	if (isVerbatim) state.tag = tagName;
-	else if (_hasOwnProperty$1.call(state.tagMap, tagHandle)) state.tag = state.tagMap[tagHandle] + tagName;
-	else if (tagHandle === "!") state.tag = "!" + tagName;
-	else if (tagHandle === "!!") state.tag = "tag:yaml.org,2002:" + tagName;
-	else throwError(state, "undeclared tag handle \"" + tagHandle + "\"");
-	return true;
-}
-function readAnchorProperty(state) {
-	var _position, ch = state.input.charCodeAt(state.position);
-	if (ch !== 38) return false;
-	if (state.anchor !== null) throwError(state, "duplication of an anchor property");
-	ch = state.input.charCodeAt(++state.position);
-	_position = state.position;
-	while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) ch = state.input.charCodeAt(++state.position);
-	if (state.position === _position) throwError(state, "name of an anchor node must contain at least one character");
-	state.anchor = state.input.slice(_position, state.position);
-	return true;
-}
-function readAlias(state) {
-	var _position, alias, ch = state.input.charCodeAt(state.position);
-	if (ch !== 42) return false;
-	ch = state.input.charCodeAt(++state.position);
-	_position = state.position;
-	while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) ch = state.input.charCodeAt(++state.position);
-	if (state.position === _position) throwError(state, "name of an alias node must contain at least one character");
-	alias = state.input.slice(_position, state.position);
-	if (!_hasOwnProperty$1.call(state.anchorMap, alias)) throwError(state, "unidentified alias \"" + alias + "\"");
-	state.result = state.anchorMap[alias];
-	skipSeparationSpace(state, true, -1);
-	return true;
-}
-function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
-	var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, atNewLine = false, hasContent = false, typeIndex, typeQuantity, typeList, type, flowIndent, blockIndent;
-	if (state.listener !== null) state.listener("open", state);
-	state.tag = null;
-	state.anchor = null;
-	state.kind = null;
-	state.result = null;
-	allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
-	if (allowToSeek) {
-		if (skipSeparationSpace(state, true, -1)) {
-			atNewLine = true;
-			if (state.lineIndent > parentIndent) indentStatus = 1;
-			else if (state.lineIndent === parentIndent) indentStatus = 0;
-			else if (state.lineIndent < parentIndent) indentStatus = -1;
-		}
-	}
-	if (indentStatus === 1) while (readTagProperty(state) || readAnchorProperty(state)) if (skipSeparationSpace(state, true, -1)) {
-		atNewLine = true;
-		allowBlockCollections = allowBlockStyles;
-		if (state.lineIndent > parentIndent) indentStatus = 1;
-		else if (state.lineIndent === parentIndent) indentStatus = 0;
-		else if (state.lineIndent < parentIndent) indentStatus = -1;
-	} else allowBlockCollections = false;
-	if (allowBlockCollections) allowBlockCollections = atNewLine || allowCompact;
-	if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
-		if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) flowIndent = parentIndent;
-		else flowIndent = parentIndent + 1;
-		blockIndent = state.position - state.lineStart;
-		if (indentStatus === 1) if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) hasContent = true;
-		else {
-			if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) hasContent = true;
-			else if (readAlias(state)) {
-				hasContent = true;
-				if (state.tag !== null || state.anchor !== null) throwError(state, "alias node should not have any properties");
-			} else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
-				hasContent = true;
-				if (state.tag === null) state.tag = "?";
-			}
-			if (state.anchor !== null) state.anchorMap[state.anchor] = state.result;
-		}
-		else if (indentStatus === 0) hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
-	}
-	if (state.tag === null) {
-		if (state.anchor !== null) state.anchorMap[state.anchor] = state.result;
-	} else if (state.tag === "?") {
-		if (state.result !== null && state.kind !== "scalar") throwError(state, "unacceptable node kind for !<?> tag; it should be \"scalar\", not \"" + state.kind + "\"");
-		for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
-			type = state.implicitTypes[typeIndex];
-			if (type.resolve(state.result)) {
-				state.result = type.construct(state.result);
-				state.tag = type.tag;
-				if (state.anchor !== null) state.anchorMap[state.anchor] = state.result;
-				break;
-			}
-		}
-	} else if (state.tag !== "!") {
-		if (_hasOwnProperty$1.call(state.typeMap[state.kind || "fallback"], state.tag)) type = state.typeMap[state.kind || "fallback"][state.tag];
-		else {
-			type = null;
-			typeList = state.typeMap.multi[state.kind || "fallback"];
-			for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
-				type = typeList[typeIndex];
-				break;
+		} else tagHandle = "!";
+		let _position = state.position;
+		if (isVerbatim) {
+			do
+				ch = state.input.charCodeAt(++state.position);
+			while (ch !== 0 && ch !== 62);
+			if (state.position < state.length) {
+				tagName = state.input.slice(_position, state.position);
+				ch = state.input.charCodeAt(++state.position);
+			} else throwError(state, "unexpected end of the stream within a verbatim tag");
+		} else {
+			while (ch !== 0 && !isWsOrEol(ch)) {
+				if (ch === 33) if (!isNamed) {
+					tagHandle = state.input.slice(_position - 1, state.position + 1);
+					if (!PATTERN_TAG_HANDLE.test(tagHandle)) throwError(state, "named tag handle cannot contain such characters");
+					isNamed = true;
+					_position = state.position + 1;
+				} else throwError(state, "tag suffix cannot contain exclamation marks");
+				ch = state.input.charCodeAt(++state.position);
 			}
+			tagName = state.input.slice(_position, state.position);
+			if (PATTERN_FLOW_INDICATORS.test(tagName)) throwError(state, "tag suffix cannot contain flow indicator characters");
 		}
-		if (!type) throwError(state, "unknown tag !<" + state.tag + ">");
-		if (state.result !== null && type.kind !== state.kind) throwError(state, "unacceptable node kind for !<" + state.tag + "> tag; it should be \"" + type.kind + "\", not \"" + state.kind + "\"");
-		if (!type.resolve(state.result, state.tag)) throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
-		else {
-			state.result = type.construct(state.result, state.tag);
-			if (state.anchor !== null) state.anchorMap[state.anchor] = state.result;
+		if (tagName && !PATTERN_TAG_URI.test(tagName)) throwError(state, "tag name cannot contain such characters: " + tagName);
+		try {
+			tagName = decodeURIComponent(tagName);
+		} catch (err) {
+			throwError(state, "tag name is malformed: " + tagName);
 		}
+		if (isVerbatim) state.tag = tagName;
+		else if (_hasOwnProperty.call(state.tagMap, tagHandle)) state.tag = state.tagMap[tagHandle] + tagName;
+		else if (tagHandle === "!") state.tag = "!" + tagName;
+		else if (tagHandle === "!!") state.tag = "tag:yaml.org,2002:" + tagName;
+		else throwError(state, "undeclared tag handle \"" + tagHandle + "\"");
+		return true;
 	}
-	if (state.listener !== null) state.listener("close", state);
-	return state.tag !== null || state.anchor !== null || hasContent;
-}
-function readDocument(state) {
-	var documentStart = state.position, _position, directiveName, directiveArgs, hasDirectives = false, ch;
-	state.version = null;
-	state.checkLineBreaks = state.legacy;
-	state.tagMap = Object.create(null);
-	state.anchorMap = Object.create(null);
-	while ((ch = state.input.charCodeAt(state.position)) !== 0) {
-		skipSeparationSpace(state, true, -1);
-		ch = state.input.charCodeAt(state.position);
-		if (state.lineIndent > 0 || ch !== 37) break;
-		hasDirectives = true;
+	function readAnchorProperty(state) {
+		let ch = state.input.charCodeAt(state.position);
+		if (ch !== 38) return false;
+		if (state.anchor !== null) throwError(state, "duplication of an anchor property");
 		ch = state.input.charCodeAt(++state.position);
-		_position = state.position;
-		while (ch !== 0 && !is_WS_OR_EOL(ch)) ch = state.input.charCodeAt(++state.position);
-		directiveName = state.input.slice(_position, state.position);
-		directiveArgs = [];
-		if (directiveName.length < 1) throwError(state, "directive name must not be less than one character in length");
-		while (ch !== 0) {
-			while (is_WHITE_SPACE(ch)) ch = state.input.charCodeAt(++state.position);
-			if (ch === 35) {
-				do
-					ch = state.input.charCodeAt(++state.position);
-				while (ch !== 0 && !is_EOL(ch));
-				break;
-			}
-			if (is_EOL(ch)) break;
-			_position = state.position;
-			while (ch !== 0 && !is_WS_OR_EOL(ch)) ch = state.input.charCodeAt(++state.position);
-			directiveArgs.push(state.input.slice(_position, state.position));
+		const _position = state.position;
+		while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch)) ch = state.input.charCodeAt(++state.position);
+		if (state.position === _position) throwError(state, "name of an anchor node must contain at least one character");
+		state.anchor = state.input.slice(_position, state.position);
+		return true;
+	}
+	function readAlias(state) {
+		let ch = state.input.charCodeAt(state.position);
+		if (ch !== 42) return false;
+		ch = state.input.charCodeAt(++state.position);
+		const _position = state.position;
+		while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch)) ch = state.input.charCodeAt(++state.position);
+		if (state.position === _position) throwError(state, "name of an alias node must contain at least one character");
+		const alias = state.input.slice(_position, state.position);
+		if (!_hasOwnProperty.call(state.anchorMap, alias)) throwError(state, "unidentified alias \"" + alias + "\"");
+		state.result = state.anchorMap[alias];
+		skipSeparationSpace(state, true, -1);
+		return true;
+	}
+	function tryReadBlockMappingFromProperty(state, propertyStart, nodeIndent, flowIndent) {
+		const fallbackState = snapshotState(state);
+		beginAnchorTransaction(state);
+		restoreState(state, propertyStart);
+		state.tag = null;
+		state.anchor = null;
+		state.kind = null;
+		state.result = null;
+		if (readBlockMapping(state, nodeIndent, flowIndent) && state.kind === "mapping") {
+			commitAnchorTransaction(state);
+			return true;
 		}
-		if (ch !== 0) readLineBreak(state);
-		if (_hasOwnProperty$1.call(directiveHandlers, directiveName)) directiveHandlers[directiveName](state, directiveName, directiveArgs);
-		else throwWarning(state, "unknown document directive \"" + directiveName + "\"");
+		rollbackAnchorTransaction(state);
+		restoreState(state, fallbackState);
+		return false;
 	}
-	skipSeparationSpace(state, true, -1);
-	if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) {
-		state.position += 3;
+	function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
+		let allowBlockScalars;
+		let allowBlockCollections;
+		let indentStatus = 1;
+		let atNewLine = false;
+		let hasContent = false;
+		let propertyStart = null;
+		let type;
+		let flowIndent;
+		let blockIndent;
+		if (state.depth >= state.maxDepth) throwError(state, "nesting exceeded maxDepth (" + state.maxDepth + ")");
+		state.depth += 1;
+		if (state.listener !== null) state.listener("open", state);
+		state.tag = null;
+		state.anchor = null;
+		state.kind = null;
+		state.result = null;
+		const allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
+		if (allowToSeek) {
+			if (skipSeparationSpace(state, true, -1)) {
+				atNewLine = true;
+				if (state.lineIndent > parentIndent) indentStatus = 1;
+				else if (state.lineIndent === parentIndent) indentStatus = 0;
+				else if (state.lineIndent < parentIndent) indentStatus = -1;
+			}
+		}
+		if (indentStatus === 1) while (true) {
+			const ch = state.input.charCodeAt(state.position);
+			const propertyState = snapshotState(state);
+			if (atNewLine && (ch === 33 && state.tag !== null || ch === 38 && state.anchor !== null)) break;
+			if (!readTagProperty(state) && !readAnchorProperty(state)) break;
+			if (propertyStart === null) propertyStart = propertyState;
+			if (skipSeparationSpace(state, true, -1)) {
+				atNewLine = true;
+				allowBlockCollections = allowBlockStyles;
+				if (state.lineIndent > parentIndent) indentStatus = 1;
+				else if (state.lineIndent === parentIndent) indentStatus = 0;
+				else if (state.lineIndent < parentIndent) indentStatus = -1;
+			} else allowBlockCollections = false;
+		}
+		if (allowBlockCollections) allowBlockCollections = atNewLine || allowCompact;
+		if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
+			if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) flowIndent = parentIndent;
+			else flowIndent = parentIndent + 1;
+			blockIndent = state.position - state.lineStart;
+			if (indentStatus === 1) if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) hasContent = true;
+			else {
+				const ch = state.input.charCodeAt(state.position);
+				if (propertyStart !== null && allowBlockStyles && !allowBlockCollections && ch !== 124 && ch !== 62 && tryReadBlockMappingFromProperty(state, propertyStart, propertyStart.position - propertyStart.lineStart, flowIndent)) hasContent = true;
+				else if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) hasContent = true;
+				else if (readAlias(state)) {
+					hasContent = true;
+					if (state.tag !== null || state.anchor !== null) throwError(state, "alias node should not have any properties");
+				} else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
+					hasContent = true;
+					if (state.tag === null) state.tag = "?";
+				}
+				if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
+			}
+			else if (indentStatus === 0) hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
+		}
+		if (state.tag === null) {
+			if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
+		} else if (state.tag === "?") {
+			if (state.result !== null && state.kind !== "scalar") throwError(state, "unacceptable node kind for !<?> tag; it should be \"scalar\", not \"" + state.kind + "\"");
+			for (let typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
+				type = state.implicitTypes[typeIndex];
+				if (type.resolve(state.result)) {
+					state.result = type.construct(state.result);
+					state.tag = type.tag;
+					if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
+					break;
+				}
+			}
+		} else if (state.tag !== "!") {
+			if (_hasOwnProperty.call(state.typeMap[state.kind || "fallback"], state.tag)) type = state.typeMap[state.kind || "fallback"][state.tag];
+			else {
+				type = null;
+				const typeList = state.typeMap.multi[state.kind || "fallback"];
+				for (let typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
+					type = typeList[typeIndex];
+					break;
+				}
+			}
+			if (!type) throwError(state, "unknown tag !<" + state.tag + ">");
+			if (state.result !== null && type.kind !== state.kind) throwError(state, "unacceptable node kind for !<" + state.tag + "> tag; it should be \"" + type.kind + "\", not \"" + state.kind + "\"");
+			if (!type.resolve(state.result, state.tag)) throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
+			else {
+				state.result = type.construct(state.result, state.tag);
+				if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
+			}
+		}
+		if (state.listener !== null) state.listener("close", state);
+		state.depth -= 1;
+		return state.tag !== null || state.anchor !== null || hasContent;
+	}
+	function readDocument(state) {
+		const documentStart = state.position;
+		let hasDirectives = false;
+		let ch;
+		state.version = null;
+		state.checkLineBreaks = state.legacy;
+		state.tagMap = Object.create(null);
+		state.anchorMap = Object.create(null);
+		while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+			skipSeparationSpace(state, true, -1);
+			ch = state.input.charCodeAt(state.position);
+			if (state.lineIndent > 0 || ch !== 37) break;
+			hasDirectives = true;
+			ch = state.input.charCodeAt(++state.position);
+			let _position = state.position;
+			while (ch !== 0 && !isWsOrEol(ch)) ch = state.input.charCodeAt(++state.position);
+			const directiveName = state.input.slice(_position, state.position);
+			const directiveArgs = [];
+			if (directiveName.length < 1) throwError(state, "directive name must not be less than one character in length");
+			while (ch !== 0) {
+				while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position);
+				if (ch === 35) {
+					do
+						ch = state.input.charCodeAt(++state.position);
+					while (ch !== 0 && !isEol(ch));
+					break;
+				}
+				if (isEol(ch)) break;
+				_position = state.position;
+				while (ch !== 0 && !isWsOrEol(ch)) ch = state.input.charCodeAt(++state.position);
+				directiveArgs.push(state.input.slice(_position, state.position));
+			}
+			if (ch !== 0) readLineBreak(state);
+			if (_hasOwnProperty.call(directiveHandlers, directiveName)) directiveHandlers[directiveName](state, directiveName, directiveArgs);
+			else throwWarning(state, "unknown document directive \"" + directiveName + "\"");
+		}
 		skipSeparationSpace(state, true, -1);
-	} else if (hasDirectives) throwError(state, "directives end mark is expected");
-	composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
-	skipSeparationSpace(state, true, -1);
-	if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) throwWarning(state, "non-ASCII line breaks are interpreted as content");
-	state.documents.push(state.result);
-	if (state.position === state.lineStart && testDocumentSeparator(state)) {
-		if (state.input.charCodeAt(state.position) === 46) {
+		if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) {
 			state.position += 3;
 			skipSeparationSpace(state, true, -1);
+		} else if (hasDirectives) throwError(state, "directives end mark is expected");
+		composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
+		skipSeparationSpace(state, true, -1);
+		if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) throwWarning(state, "non-ASCII line breaks are interpreted as content");
+		state.documents.push(state.result);
+		if (state.position === state.lineStart && testDocumentSeparator(state)) {
+			if (state.input.charCodeAt(state.position) === 46) {
+				state.position += 3;
+				skipSeparationSpace(state, true, -1);
+			}
+			return;
 		}
-		return;
-	}
-	if (state.position < state.length - 1) throwError(state, "end of the stream or a document separator is expected");
-	else return;
-}
-function loadDocuments(input, options) {
-	input = String(input);
-	options = options || {};
-	if (input.length !== 0) {
-		if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) input += "\n";
-		if (input.charCodeAt(0) === 65279) input = input.slice(1);
-	}
-	var state = new State$1(input, options);
-	var nullpos = input.indexOf("\0");
-	if (nullpos !== -1) {
-		state.position = nullpos;
-		throwError(state, "null byte is not allowed in input");
-	}
-	state.input += "\0";
-	while (state.input.charCodeAt(state.position) === 32) {
-		state.lineIndent += 1;
-		state.position += 1;
-	}
-	while (state.position < state.length - 1) readDocument(state);
-	return state.documents;
-}
-function loadAll$1(input, iterator, options) {
-	if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") {
-		options = iterator;
-		iterator = null;
-	}
-	var documents = loadDocuments(input, options);
-	if (typeof iterator !== "function") return documents;
-	for (var index = 0, length = documents.length; index < length; index += 1) iterator(documents[index]);
-}
-function load$1(input, options) {
-	var documents = loadDocuments(input, options);
-	if (documents.length === 0) return;
-	else if (documents.length === 1) return documents[0];
-	throw new exception("expected a single document in the stream, but found more");
-}
-var loader = {
-	loadAll: loadAll$1,
-	load: load$1
-};
-var _toString = Object.prototype.toString;
-var _hasOwnProperty = Object.prototype.hasOwnProperty;
-var CHAR_BOM = 65279;
-var CHAR_TAB = 9;
-var CHAR_LINE_FEED = 10;
-var CHAR_CARRIAGE_RETURN = 13;
-var CHAR_SPACE = 32;
-var CHAR_EXCLAMATION = 33;
-var CHAR_DOUBLE_QUOTE = 34;
-var CHAR_SHARP = 35;
-var CHAR_PERCENT = 37;
-var CHAR_AMPERSAND = 38;
-var CHAR_SINGLE_QUOTE = 39;
-var CHAR_ASTERISK = 42;
-var CHAR_COMMA = 44;
-var CHAR_MINUS = 45;
-var CHAR_COLON = 58;
-var CHAR_EQUALS = 61;
-var CHAR_GREATER_THAN = 62;
-var CHAR_QUESTION = 63;
-var CHAR_COMMERCIAL_AT = 64;
-var CHAR_LEFT_SQUARE_BRACKET = 91;
-var CHAR_RIGHT_SQUARE_BRACKET = 93;
-var CHAR_GRAVE_ACCENT = 96;
-var CHAR_LEFT_CURLY_BRACKET = 123;
-var CHAR_VERTICAL_LINE = 124;
-var CHAR_RIGHT_CURLY_BRACKET = 125;
-var ESCAPE_SEQUENCES = {};
-ESCAPE_SEQUENCES[0] = "\\0";
-ESCAPE_SEQUENCES[7] = "\\a";
-ESCAPE_SEQUENCES[8] = "\\b";
-ESCAPE_SEQUENCES[9] = "\\t";
-ESCAPE_SEQUENCES[10] = "\\n";
-ESCAPE_SEQUENCES[11] = "\\v";
-ESCAPE_SEQUENCES[12] = "\\f";
-ESCAPE_SEQUENCES[13] = "\\r";
-ESCAPE_SEQUENCES[27] = "\\e";
-ESCAPE_SEQUENCES[34] = "\\\"";
-ESCAPE_SEQUENCES[92] = "\\\\";
-ESCAPE_SEQUENCES[133] = "\\N";
-ESCAPE_SEQUENCES[160] = "\\_";
-ESCAPE_SEQUENCES[8232] = "\\L";
-ESCAPE_SEQUENCES[8233] = "\\P";
-var DEPRECATED_BOOLEANS_SYNTAX = [
-	"y",
-	"Y",
-	"yes",
-	"Yes",
-	"YES",
-	"on",
-	"On",
-	"ON",
-	"n",
-	"N",
-	"no",
-	"No",
-	"NO",
-	"off",
-	"Off",
-	"OFF"
-];
-var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-function compileStyleMap(schema, map) {
-	var result, keys, index, length, tag, style, type;
-	if (map === null) return {};
-	result = {};
-	keys = Object.keys(map);
-	for (index = 0, length = keys.length; index < length; index += 1) {
-		tag = keys[index];
-		style = String(map[tag]);
-		if (tag.slice(0, 2) === "!!") tag = "tag:yaml.org,2002:" + tag.slice(2);
-		type = schema.compiledTypeMap["fallback"][tag];
-		if (type && _hasOwnProperty.call(type.styleAliases, style)) style = type.styleAliases[style];
-		result[tag] = style;
+		if (state.position < state.length - 1) throwError(state, "end of the stream or a document separator is expected");
 	}
-	return result;
-}
-function encodeHex(character) {
-	var string = character.toString(16).toUpperCase(), handle, length;
-	if (character <= 255) {
-		handle = "x";
-		length = 2;
-	} else if (character <= 65535) {
-		handle = "u";
-		length = 4;
-	} else if (character <= 4294967295) {
-		handle = "U";
-		length = 8;
-	} else throw new exception("code point within a string may not be greater than 0xFFFFFFFF");
-	return "\\" + handle + common.repeat("0", length - string.length) + string;
-}
-var QUOTING_TYPE_SINGLE = 1, QUOTING_TYPE_DOUBLE = 2;
-function State(options) {
-	this.schema = options["schema"] || _default;
-	this.indent = Math.max(1, options["indent"] || 2);
-	this.noArrayIndent = options["noArrayIndent"] || false;
-	this.skipInvalid = options["skipInvalid"] || false;
-	this.flowLevel = common.isNothing(options["flowLevel"]) ? -1 : options["flowLevel"];
-	this.styleMap = compileStyleMap(this.schema, options["styles"] || null);
-	this.sortKeys = options["sortKeys"] || false;
-	this.lineWidth = options["lineWidth"] || 80;
-	this.noRefs = options["noRefs"] || false;
-	this.noCompatMode = options["noCompatMode"] || false;
-	this.condenseFlow = options["condenseFlow"] || false;
-	this.quotingType = options["quotingType"] === "\"" ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE;
-	this.forceQuotes = options["forceQuotes"] || false;
-	this.replacer = typeof options["replacer"] === "function" ? options["replacer"] : null;
-	this.implicitTypes = this.schema.compiledImplicit;
-	this.explicitTypes = this.schema.compiledExplicit;
-	this.tag = null;
-	this.result = "";
-	this.duplicates = [];
-	this.usedDuplicates = null;
-}
-function indentString(string, spaces) {
-	var ind = common.repeat(" ", spaces), position = 0, next = -1, result = "", line, length = string.length;
-	while (position < length) {
-		next = string.indexOf("\n", position);
-		if (next === -1) {
-			line = string.slice(position);
-			position = length;
-		} else {
-			line = string.slice(position, next + 1);
-			position = next + 1;
+	function loadDocuments(input, options) {
+		input = String(input);
+		options = options || {};
+		if (input.length !== 0) {
+			if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) input += "\n";
+			if (input.charCodeAt(0) === 65279) input = input.slice(1);
+		}
+		const state = new State(input, options);
+		const nullpos = input.indexOf("\0");
+		if (nullpos !== -1) {
+			state.position = nullpos;
+			throwError(state, "null byte is not allowed in input");
+		}
+		state.input += "\0";
+		while (state.input.charCodeAt(state.position) === 32) {
+			state.lineIndent += 1;
+			state.position += 1;
 		}
-		if (line.length && line !== "\n") result += ind;
-		result += line;
+		while (state.position < state.length - 1) readDocument(state);
+		return state.documents;
+	}
+	function loadAll(input, iterator, options) {
+		if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") {
+			options = iterator;
+			iterator = null;
+		}
+		const documents = loadDocuments(input, options);
+		if (typeof iterator !== "function") return documents;
+		for (let index = 0, length = documents.length; index < length; index += 1) iterator(documents[index]);
+	}
+	function load(input, options) {
+		const documents = loadDocuments(input, options);
+		if (documents.length === 0) return;
+		else if (documents.length === 1) return documents[0];
+		throw new YAMLException("expected a single document in the stream, but found more");
+	}
+	module.exports.loadAll = loadAll;
+	module.exports.load = load;
+}));
+var require_dumper = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var common = require_common();
+	var YAMLException = require_exception();
+	var DEFAULT_SCHEMA = require_default();
+	var _toString = Object.prototype.toString;
+	var _hasOwnProperty = Object.prototype.hasOwnProperty;
+	var CHAR_BOM = 65279;
+	var CHAR_TAB = 9;
+	var CHAR_LINE_FEED = 10;
+	var CHAR_CARRIAGE_RETURN = 13;
+	var CHAR_SPACE = 32;
+	var CHAR_EXCLAMATION = 33;
+	var CHAR_DOUBLE_QUOTE = 34;
+	var CHAR_SHARP = 35;
+	var CHAR_PERCENT = 37;
+	var CHAR_AMPERSAND = 38;
+	var CHAR_SINGLE_QUOTE = 39;
+	var CHAR_ASTERISK = 42;
+	var CHAR_COMMA = 44;
+	var CHAR_MINUS = 45;
+	var CHAR_COLON = 58;
+	var CHAR_EQUALS = 61;
+	var CHAR_GREATER_THAN = 62;
+	var CHAR_QUESTION = 63;
+	var CHAR_COMMERCIAL_AT = 64;
+	var CHAR_LEFT_SQUARE_BRACKET = 91;
+	var CHAR_RIGHT_SQUARE_BRACKET = 93;
+	var CHAR_GRAVE_ACCENT = 96;
+	var CHAR_LEFT_CURLY_BRACKET = 123;
+	var CHAR_VERTICAL_LINE = 124;
+	var CHAR_RIGHT_CURLY_BRACKET = 125;
+	var ESCAPE_SEQUENCES = {};
+	ESCAPE_SEQUENCES[0] = "\\0";
+	ESCAPE_SEQUENCES[7] = "\\a";
+	ESCAPE_SEQUENCES[8] = "\\b";
+	ESCAPE_SEQUENCES[9] = "\\t";
+	ESCAPE_SEQUENCES[10] = "\\n";
+	ESCAPE_SEQUENCES[11] = "\\v";
+	ESCAPE_SEQUENCES[12] = "\\f";
+	ESCAPE_SEQUENCES[13] = "\\r";
+	ESCAPE_SEQUENCES[27] = "\\e";
+	ESCAPE_SEQUENCES[34] = "\\\"";
+	ESCAPE_SEQUENCES[92] = "\\\\";
+	ESCAPE_SEQUENCES[133] = "\\N";
+	ESCAPE_SEQUENCES[160] = "\\_";
+	ESCAPE_SEQUENCES[8232] = "\\L";
+	ESCAPE_SEQUENCES[8233] = "\\P";
+	var DEPRECATED_BOOLEANS_SYNTAX = [
+		"y",
+		"Y",
+		"yes",
+		"Yes",
+		"YES",
+		"on",
+		"On",
+		"ON",
+		"n",
+		"N",
+		"no",
+		"No",
+		"NO",
+		"off",
+		"Off",
+		"OFF"
+	];
+	var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
+	function compileStyleMap(schema, map) {
+		if (map === null) return {};
+		const result = {};
+		const keys = Object.keys(map);
+		for (let index = 0, length = keys.length; index < length; index += 1) {
+			let tag = keys[index];
+			let style = String(map[tag]);
+			if (tag.slice(0, 2) === "!!") tag = "tag:yaml.org,2002:" + tag.slice(2);
+			const type = schema.compiledTypeMap["fallback"][tag];
+			if (type && _hasOwnProperty.call(type.styleAliases, style)) style = type.styleAliases[style];
+			result[tag] = style;
+		}
+		return result;
 	}
-	return result;
-}
-function generateNextLine(state, level) {
-	return "\n" + common.repeat(" ", state.indent * level);
-}
-function testImplicitResolving(state, str) {
-	var index, length, type;
-	for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
-		type = state.implicitTypes[index];
-		if (type.resolve(str)) return true;
+	function encodeHex(character) {
+		let handle;
+		let length;
+		const string = character.toString(16).toUpperCase();
+		if (character <= 255) {
+			handle = "x";
+			length = 2;
+		} else if (character <= 65535) {
+			handle = "u";
+			length = 4;
+		} else if (character <= 4294967295) {
+			handle = "U";
+			length = 8;
+		} else throw new YAMLException("code point within a string may not be greater than 0xFFFFFFFF");
+		return "\\" + handle + common.repeat("0", length - string.length) + string;
+	}
+	var QUOTING_TYPE_SINGLE = 1;
+	var QUOTING_TYPE_DOUBLE = 2;
+	function State(options) {
+		this.schema = options["schema"] || DEFAULT_SCHEMA;
+		this.indent = Math.max(1, options["indent"] || 2);
+		this.noArrayIndent = options["noArrayIndent"] || false;
+		this.skipInvalid = options["skipInvalid"] || false;
+		this.flowLevel = common.isNothing(options["flowLevel"]) ? -1 : options["flowLevel"];
+		this.styleMap = compileStyleMap(this.schema, options["styles"] || null);
+		this.sortKeys = options["sortKeys"] || false;
+		this.lineWidth = options["lineWidth"] || 80;
+		this.noRefs = options["noRefs"] || false;
+		this.noCompatMode = options["noCompatMode"] || false;
+		this.condenseFlow = options["condenseFlow"] || false;
+		this.quotingType = options["quotingType"] === "\"" ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE;
+		this.forceQuotes = options["forceQuotes"] || false;
+		this.replacer = typeof options["replacer"] === "function" ? options["replacer"] : null;
+		this.implicitTypes = this.schema.compiledImplicit;
+		this.explicitTypes = this.schema.compiledExplicit;
+		this.tag = null;
+		this.result = "";
+		this.duplicates = [];
+		this.usedDuplicates = null;
+	}
+	function indentString(string, spaces) {
+		const ind = common.repeat(" ", spaces);
+		let position = 0;
+		let result = "";
+		const length = string.length;
+		while (position < length) {
+			let line;
+			const next = string.indexOf("\n", position);
+			if (next === -1) {
+				line = string.slice(position);
+				position = length;
+			} else {
+				line = string.slice(position, next + 1);
+				position = next + 1;
+			}
+			if (line.length && line !== "\n") result += ind;
+			result += line;
+		}
+		return result;
 	}
-	return false;
-}
-function isWhitespace(c) {
-	return c === CHAR_SPACE || c === CHAR_TAB;
-}
-function isPrintable(c) {
-	return 32 <= c && c <= 126 || 161 <= c && c <= 55295 && c !== 8232 && c !== 8233 || 57344 <= c && c <= 65533 && c !== CHAR_BOM || 65536 <= c && c <= 1114111;
-}
-function isNsCharOrWhitespace(c) {
-	return isPrintable(c) && c !== CHAR_BOM && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
-}
-function isPlainSafe(c, prev, inblock) {
-	var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
-	var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
-	return (inblock ? cIsNsCharOrWhitespace : cIsNsCharOrWhitespace && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET) && c !== CHAR_SHARP && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar;
-}
-function isPlainSafeFirst(c) {
-	return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT;
-}
-function isPlainSafeLast(c) {
-	return !isWhitespace(c) && c !== CHAR_COLON;
-}
-function codePointAt(string, pos) {
-	var first = string.charCodeAt(pos), second;
-	if (first >= 55296 && first <= 56319 && pos + 1 < string.length) {
-		second = string.charCodeAt(pos + 1);
-		if (second >= 56320 && second <= 57343) return (first - 55296) * 1024 + second - 56320 + 65536;
+	function generateNextLine(state, level) {
+		return "\n" + common.repeat(" ", state.indent * level);
 	}
-	return first;
-}
-function needIndentIndicator(string) {
-	return /^\n* /.test(string);
-}
-var STYLE_PLAIN = 1, STYLE_SINGLE = 2, STYLE_LITERAL = 3, STYLE_FOLDED = 4, STYLE_DOUBLE = 5;
-function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) {
-	var i;
-	var char = 0;
-	var prevChar = null;
-	var hasLineBreak = false;
-	var hasFoldableLine = false;
-	var shouldTrackWidth = lineWidth !== -1;
-	var previousLineBreak = -1;
-	var plain = isPlainSafeFirst(codePointAt(string, 0)) && isPlainSafeLast(codePointAt(string, string.length - 1));
-	if (singleLineOnly || forceQuotes) for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
-		char = codePointAt(string, i);
-		if (!isPrintable(char)) return STYLE_DOUBLE;
-		plain = plain && isPlainSafe(char, prevChar, inblock);
-		prevChar = char;
+	function testImplicitResolving(state, str) {
+		for (let index = 0, length = state.implicitTypes.length; index < length; index += 1) if (state.implicitTypes[index].resolve(str)) return true;
+		return false;
 	}
-	else {
-		for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
+	function isWhitespace(c) {
+		return c === CHAR_SPACE || c === CHAR_TAB;
+	}
+	function isPrintable(c) {
+		return c >= 32 && c <= 126 || c >= 161 && c <= 55295 && c !== 8232 && c !== 8233 || c >= 57344 && c <= 65533 && c !== CHAR_BOM || c >= 65536 && c <= 1114111;
+	}
+	function isNsCharOrWhitespace(c) {
+		return isPrintable(c) && c !== CHAR_BOM && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
+	}
+	function isPlainSafe(c, prev, inblock) {
+		const cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
+		const cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
+		return (inblock ? cIsNsCharOrWhitespace : cIsNsCharOrWhitespace && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET) && c !== CHAR_SHARP && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar;
+	}
+	function isPlainSafeFirst(c) {
+		return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT;
+	}
+	function isPlainSafeLast(c) {
+		return !isWhitespace(c) && c !== CHAR_COLON;
+	}
+	function codePointAt(string, pos) {
+		const first = string.charCodeAt(pos);
+		let second;
+		if (first >= 55296 && first <= 56319 && pos + 1 < string.length) {
+			second = string.charCodeAt(pos + 1);
+			if (second >= 56320 && second <= 57343) return (first - 55296) * 1024 + second - 56320 + 65536;
+		}
+		return first;
+	}
+	function needIndentIndicator(string) {
+		return /^\n* /.test(string);
+	}
+	var STYLE_PLAIN = 1;
+	var STYLE_SINGLE = 2;
+	var STYLE_LITERAL = 3;
+	var STYLE_FOLDED = 4;
+	var STYLE_DOUBLE = 5;
+	function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) {
+		let i;
+		let char = 0;
+		let prevChar = null;
+		let hasLineBreak = false;
+		let hasFoldableLine = false;
+		const shouldTrackWidth = lineWidth !== -1;
+		let previousLineBreak = -1;
+		let plain = isPlainSafeFirst(codePointAt(string, 0)) && isPlainSafeLast(codePointAt(string, string.length - 1));
+		if (singleLineOnly || forceQuotes) for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
 			char = codePointAt(string, i);
-			if (char === CHAR_LINE_FEED) {
-				hasLineBreak = true;
-				if (shouldTrackWidth) {
-					hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
-					previousLineBreak = i;
-				}
-			} else if (!isPrintable(char)) return STYLE_DOUBLE;
+			if (!isPrintable(char)) return STYLE_DOUBLE;
 			plain = plain && isPlainSafe(char, prevChar, inblock);
 			prevChar = char;
 		}
-		hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
-	}
-	if (!hasLineBreak && !hasFoldableLine) {
-		if (plain && !forceQuotes && !testAmbiguousType(string)) return STYLE_PLAIN;
+		else {
+			for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
+				char = codePointAt(string, i);
+				if (char === CHAR_LINE_FEED) {
+					hasLineBreak = true;
+					if (shouldTrackWidth) {
+						hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
+						previousLineBreak = i;
+					}
+				} else if (!isPrintable(char)) return STYLE_DOUBLE;
+				plain = plain && isPlainSafe(char, prevChar, inblock);
+				prevChar = char;
+			}
+			hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
+		}
+		if (!hasLineBreak && !hasFoldableLine) {
+			if (plain && !forceQuotes && !testAmbiguousType(string)) return STYLE_PLAIN;
+			return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
+		}
+		if (indentPerLevel > 9 && needIndentIndicator(string)) return STYLE_DOUBLE;
+		if (!forceQuotes) return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
 		return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
 	}
-	if (indentPerLevel > 9 && needIndentIndicator(string)) return STYLE_DOUBLE;
-	if (!forceQuotes) return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
-	return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
-}
-function writeScalar(state, string, level, iskey, inblock) {
-	state.dump = function() {
-		if (string.length === 0) return state.quotingType === QUOTING_TYPE_DOUBLE ? "\"\"" : "''";
-		if (!state.noCompatMode) {
-			if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) return state.quotingType === QUOTING_TYPE_DOUBLE ? "\"" + string + "\"" : "'" + string + "'";
-		}
-		var indent = state.indent * Math.max(1, level);
-		var lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
-		var singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
-		function testAmbiguity(string) {
-			return testImplicitResolving(state, string);
-		}
-		switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
-			case STYLE_PLAIN: return string;
-			case STYLE_SINGLE: return "'" + string.replace(/'/g, "''") + "'";
-			case STYLE_LITERAL: return "|" + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent));
-			case STYLE_FOLDED: return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
-			case STYLE_DOUBLE: return "\"" + escapeString(string) + "\"";
-			default: throw new exception("impossible error: invalid scalar style");
-		}
-	}();
-}
-function blockHeader(string, indentPerLevel) {
-	var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : "";
-	var clip = string[string.length - 1] === "\n";
-	return indentIndicator + (clip && (string[string.length - 2] === "\n" || string === "\n") ? "+" : clip ? "" : "-") + "\n";
-}
-function dropEndingNewline(string) {
-	return string[string.length - 1] === "\n" ? string.slice(0, -1) : string;
-}
-function foldString(string, width) {
-	var lineRe = /(\n+)([^\n]*)/g;
-	var result = function() {
-		var nextLF = string.indexOf("\n");
-		nextLF = nextLF !== -1 ? nextLF : string.length;
-		lineRe.lastIndex = nextLF;
-		return foldLine(string.slice(0, nextLF), width);
-	}();
-	var prevMoreIndented = string[0] === "\n" || string[0] === " ";
-	var moreIndented;
-	var match;
-	while (match = lineRe.exec(string)) {
-		var prefix = match[1], line = match[2];
-		moreIndented = line[0] === " ";
-		result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
-		prevMoreIndented = moreIndented;
+	function writeScalar(state, string, level, iskey, inblock) {
+		state.dump = function() {
+			if (string.length === 0) return state.quotingType === QUOTING_TYPE_DOUBLE ? "\"\"" : "''";
+			if (!state.noCompatMode) {
+				if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) return state.quotingType === QUOTING_TYPE_DOUBLE ? "\"" + string + "\"" : "'" + string + "'";
+			}
+			const indent = state.indent * Math.max(1, level);
+			const lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
+			const singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
+			function testAmbiguity(string) {
+				return testImplicitResolving(state, string);
+			}
+			switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
+				case STYLE_PLAIN: return string;
+				case STYLE_SINGLE: return "'" + string.replace(/'/g, "''") + "'";
+				case STYLE_LITERAL: return "|" + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent));
+				case STYLE_FOLDED: return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
+				case STYLE_DOUBLE: return "\"" + escapeString(string, lineWidth) + "\"";
+				default: throw new YAMLException("impossible error: invalid scalar style");
+			}
+		}();
+	}
+	function blockHeader(string, indentPerLevel) {
+		const indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : "";
+		const clip = string[string.length - 1] === "\n";
+		return indentIndicator + (clip && (string[string.length - 2] === "\n" || string === "\n") ? "+" : clip ? "" : "-") + "\n";
+	}
+	function dropEndingNewline(string) {
+		return string[string.length - 1] === "\n" ? string.slice(0, -1) : string;
+	}
+	function foldString(string, width) {
+		const lineRe = /(\n+)([^\n]*)/g;
+		let result = function() {
+			let nextLF = string.indexOf("\n");
+			nextLF = nextLF !== -1 ? nextLF : string.length;
+			lineRe.lastIndex = nextLF;
+			return foldLine(string.slice(0, nextLF), width);
+		}();
+		let prevMoreIndented = string[0] === "\n" || string[0] === " ";
+		let moreIndented;
+		let match;
+		while (match = lineRe.exec(string)) {
+			const prefix = match[1];
+			const line = match[2];
+			moreIndented = line[0] === " ";
+			result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
+			prevMoreIndented = moreIndented;
+		}
+		return result;
 	}
-	return result;
-}
-function foldLine(line, width) {
-	if (line === "" || line[0] === " ") return line;
-	var breakRe = / [^ ]/g;
-	var match;
-	var start = 0, end, curr = 0, next = 0;
-	var result = "";
-	while (match = breakRe.exec(line)) {
-		next = match.index;
-		if (next - start > width) {
-			end = curr > start ? curr : next;
-			result += "\n" + line.slice(start, end);
-			start = end + 1;
-		}
-		curr = next;
-	}
-	result += "\n";
-	if (line.length - start > width && curr > start) result += line.slice(start, curr) + "\n" + line.slice(curr + 1);
-	else result += line.slice(start);
-	return result.slice(1);
-}
-function escapeString(string) {
-	var result = "";
-	var char = 0;
-	var escapeSeq;
-	for (var i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
-		char = codePointAt(string, i);
-		escapeSeq = ESCAPE_SEQUENCES[char];
-		if (!escapeSeq && isPrintable(char)) {
-			result += string[i];
-			if (char >= 65536) result += string[i + 1];
-		} else result += escapeSeq || encodeHex(char);
+	function foldLine(line, width) {
+		if (line === "" || line[0] === " ") return line;
+		const breakRe = / [^ ]/g;
+		let match;
+		let start = 0;
+		let end;
+		let curr = 0;
+		let next = 0;
+		let result = "";
+		while (match = breakRe.exec(line)) {
+			next = match.index;
+			if (next - start > width) {
+				end = curr > start ? curr : next;
+				result += "\n" + line.slice(start, end);
+				start = end + 1;
+			}
+			curr = next;
+		}
+		result += "\n";
+		if (line.length - start > width && curr > start) result += line.slice(start, curr) + "\n" + line.slice(curr + 1);
+		else result += line.slice(start);
+		return result.slice(1);
+	}
+	function escapeString(string) {
+		let result = "";
+		let char = 0;
+		for (let i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
+			char = codePointAt(string, i);
+			const escapeSeq = ESCAPE_SEQUENCES[char];
+			if (!escapeSeq && isPrintable(char)) {
+				result += string[i];
+				if (char >= 65536) result += string[i + 1];
+			} else result += escapeSeq || encodeHex(char);
+		}
+		return result;
 	}
-	return result;
-}
-function writeFlowSequence(state, level, object) {
-	var _result = "", _tag = state.tag, index, length, value;
-	for (index = 0, length = object.length; index < length; index += 1) {
-		value = object[index];
-		if (state.replacer) value = state.replacer.call(object, String(index), value);
-		if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) {
-			if (_result !== "") _result += "," + (!state.condenseFlow ? " " : "");
-			_result += state.dump;
-		}
-	}
-	state.tag = _tag;
-	state.dump = "[" + _result + "]";
-}
-function writeBlockSequence(state, level, object, compact) {
-	var _result = "", _tag = state.tag, index, length, value;
-	for (index = 0, length = object.length; index < length; index += 1) {
-		value = object[index];
-		if (state.replacer) value = state.replacer.call(object, String(index), value);
-		if (writeNode(state, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode(state, level + 1, null, true, true, false, true)) {
-			if (!compact || _result !== "") _result += generateNextLine(state, level);
-			if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) _result += "-";
-			else _result += "- ";
-			_result += state.dump;
-		}
-	}
-	state.tag = _tag;
-	state.dump = _result || "[]";
-}
-function writeFlowMapping(state, level, object) {
-	var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, pairBuffer;
-	for (index = 0, length = objectKeyList.length; index < length; index += 1) {
-		pairBuffer = "";
-		if (_result !== "") pairBuffer += ", ";
-		if (state.condenseFlow) pairBuffer += "\"";
-		objectKey = objectKeyList[index];
-		objectValue = object[objectKey];
-		if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
-		if (!writeNode(state, level, objectKey, false, false)) continue;
-		if (state.dump.length > 1024) pairBuffer += "? ";
-		pairBuffer += state.dump + (state.condenseFlow ? "\"" : "") + ":" + (state.condenseFlow ? "" : " ");
-		if (!writeNode(state, level, objectValue, false, false)) continue;
-		pairBuffer += state.dump;
-		_result += pairBuffer;
-	}
-	state.tag = _tag;
-	state.dump = "{" + _result + "}";
-}
-function writeBlockMapping(state, level, object, compact) {
-	var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, explicitPair, pairBuffer;
-	if (state.sortKeys === true) objectKeyList.sort();
-	else if (typeof state.sortKeys === "function") objectKeyList.sort(state.sortKeys);
-	else if (state.sortKeys) throw new exception("sortKeys must be a boolean or a function");
-	for (index = 0, length = objectKeyList.length; index < length; index += 1) {
-		pairBuffer = "";
-		if (!compact || _result !== "") pairBuffer += generateNextLine(state, level);
-		objectKey = objectKeyList[index];
-		objectValue = object[objectKey];
-		if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
-		if (!writeNode(state, level + 1, objectKey, true, true, true)) continue;
-		explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
-		if (explicitPair) if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += "?";
-		else pairBuffer += "? ";
-		pairBuffer += state.dump;
-		if (explicitPair) pairBuffer += generateNextLine(state, level);
-		if (!writeNode(state, level + 1, objectValue, true, explicitPair)) continue;
-		if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += ":";
-		else pairBuffer += ": ";
-		pairBuffer += state.dump;
-		_result += pairBuffer;
-	}
-	state.tag = _tag;
-	state.dump = _result || "{}";
-}
-function detectType(state, object, explicit) {
-	var _result, typeList = explicit ? state.explicitTypes : state.implicitTypes, index, length, type, style;
-	for (index = 0, length = typeList.length; index < length; index += 1) {
-		type = typeList[index];
-		if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === "object" && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) {
-			if (explicit) if (type.multi && type.representName) state.tag = type.representName(object);
-			else state.tag = type.tag;
-			else state.tag = "?";
-			if (type.represent) {
-				style = state.styleMap[type.tag] || type.defaultStyle;
-				if (_toString.call(type.represent) === "[object Function]") _result = type.represent(object, style);
-				else if (_hasOwnProperty.call(type.represent, style)) _result = type.represent[style](object, style);
-				else throw new exception("!<" + type.tag + "> tag resolver accepts not \"" + style + "\" style");
-				state.dump = _result;
+	function writeFlowSequence(state, level, object) {
+		let _result = "";
+		const _tag = state.tag;
+		for (let index = 0, length = object.length; index < length; index += 1) {
+			let value = object[index];
+			if (state.replacer) value = state.replacer.call(object, String(index), value);
+			if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) {
+				if (_result !== "") _result += "," + (!state.condenseFlow ? " " : "");
+				_result += state.dump;
 			}
-			return true;
 		}
+		state.tag = _tag;
+		state.dump = "[" + _result + "]";
 	}
-	return false;
-}
-function writeNode(state, level, object, block, compact, iskey, isblockseq) {
-	state.tag = null;
-	state.dump = object;
-	if (!detectType(state, object, false)) detectType(state, object, true);
-	var type = _toString.call(state.dump);
-	var inblock = block;
-	var tagStr;
-	if (block) block = state.flowLevel < 0 || state.flowLevel > level;
-	var objectOrArray = type === "[object Object]" || type === "[object Array]", duplicateIndex, duplicate;
-	if (objectOrArray) {
-		duplicateIndex = state.duplicates.indexOf(object);
-		duplicate = duplicateIndex !== -1;
-	}
-	if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) compact = false;
-	if (duplicate && state.usedDuplicates[duplicateIndex]) state.dump = "*ref_" + duplicateIndex;
-	else {
-		if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) state.usedDuplicates[duplicateIndex] = true;
-		if (type === "[object Object]") if (block && Object.keys(state.dump).length !== 0) {
-			writeBlockMapping(state, level, state.dump, compact);
-			if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
-		} else {
-			writeFlowMapping(state, level, state.dump);
-			if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+	function writeBlockSequence(state, level, object, compact) {
+		let _result = "";
+		const _tag = state.tag;
+		for (let index = 0, length = object.length; index < length; index += 1) {
+			let value = object[index];
+			if (state.replacer) value = state.replacer.call(object, String(index), value);
+			if (writeNode(state, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode(state, level + 1, null, true, true, false, true)) {
+				if (!compact || _result !== "") _result += generateNextLine(state, level);
+				if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) _result += "-";
+				else _result += "- ";
+				_result += state.dump;
+			}
 		}
-		else if (type === "[object Array]") if (block && state.dump.length !== 0) {
-			if (state.noArrayIndent && !isblockseq && level > 0) writeBlockSequence(state, level - 1, state.dump, compact);
-			else writeBlockSequence(state, level, state.dump, compact);
-			if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
-		} else {
-			writeFlowSequence(state, level, state.dump);
-			if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+		state.tag = _tag;
+		state.dump = _result || "[]";
+	}
+	function writeFlowMapping(state, level, object) {
+		let _result = "";
+		const _tag = state.tag;
+		const objectKeyList = Object.keys(object);
+		for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
+			let pairBuffer = "";
+			if (_result !== "") pairBuffer += ", ";
+			if (state.condenseFlow) pairBuffer += "\"";
+			const objectKey = objectKeyList[index];
+			let objectValue = object[objectKey];
+			if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
+			if (!writeNode(state, level, objectKey, false, false)) continue;
+			if (state.dump.length > 1024) pairBuffer += "? ";
+			pairBuffer += state.dump + (state.condenseFlow ? "\"" : "") + ":" + (state.condenseFlow ? "" : " ");
+			if (!writeNode(state, level, objectValue, false, false)) continue;
+			pairBuffer += state.dump;
+			_result += pairBuffer;
 		}
-		else if (type === "[object String]") {
-			if (state.tag !== "?") writeScalar(state, state.dump, level, iskey, inblock);
-		} else if (type === "[object Undefined]") return false;
-		else {
-			if (state.skipInvalid) return false;
-			throw new exception("unacceptable kind of an object to dump " + type);
+		state.tag = _tag;
+		state.dump = "{" + _result + "}";
+	}
+	function writeBlockMapping(state, level, object, compact) {
+		let _result = "";
+		const _tag = state.tag;
+		const objectKeyList = Object.keys(object);
+		if (state.sortKeys === true) objectKeyList.sort();
+		else if (typeof state.sortKeys === "function") objectKeyList.sort(state.sortKeys);
+		else if (state.sortKeys) throw new YAMLException("sortKeys must be a boolean or a function");
+		for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
+			let pairBuffer = "";
+			if (!compact || _result !== "") pairBuffer += generateNextLine(state, level);
+			const objectKey = objectKeyList[index];
+			let objectValue = object[objectKey];
+			if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
+			if (!writeNode(state, level + 1, objectKey, true, true, true)) continue;
+			const explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
+			if (explicitPair) if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += "?";
+			else pairBuffer += "? ";
+			pairBuffer += state.dump;
+			if (explicitPair) pairBuffer += generateNextLine(state, level);
+			if (!writeNode(state, level + 1, objectValue, true, explicitPair)) continue;
+			if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += ":";
+			else pairBuffer += ": ";
+			pairBuffer += state.dump;
+			_result += pairBuffer;
 		}
-		if (state.tag !== null && state.tag !== "?") {
-			tagStr = encodeURI(state.tag[0] === "!" ? state.tag.slice(1) : state.tag).replace(/!/g, "%21");
-			if (state.tag[0] === "!") tagStr = "!" + tagStr;
-			else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") tagStr = "!!" + tagStr.slice(18);
-			else tagStr = "!<" + tagStr + ">";
-			state.dump = tagStr + " " + state.dump;
+		state.tag = _tag;
+		state.dump = _result || "{}";
+	}
+	function detectType(state, object, explicit) {
+		const typeList = explicit ? state.explicitTypes : state.implicitTypes;
+		for (let index = 0, length = typeList.length; index < length; index += 1) {
+			const type = typeList[index];
+			if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === "object" && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) {
+				if (explicit) if (type.multi && type.representName) state.tag = type.representName(object);
+				else state.tag = type.tag;
+				else state.tag = "?";
+				if (type.represent) {
+					const style = state.styleMap[type.tag] || type.defaultStyle;
+					let _result;
+					if (_toString.call(type.represent) === "[object Function]") _result = type.represent(object, style);
+					else if (_hasOwnProperty.call(type.represent, style)) _result = type.represent[style](object, style);
+					else throw new YAMLException("!<" + type.tag + "> tag resolver accepts not \"" + style + "\" style");
+					state.dump = _result;
+				}
+				return true;
+			}
 		}
+		return false;
 	}
-	return true;
-}
-function getDuplicateReferences(object, state) {
-	var objects = [], duplicatesIndexes = [], index, length;
-	inspectNode(object, objects, duplicatesIndexes);
-	for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) state.duplicates.push(objects[duplicatesIndexes[index]]);
-	state.usedDuplicates = new Array(length);
-}
-function inspectNode(object, objects, duplicatesIndexes) {
-	var objectKeyList, index, length;
-	if (object !== null && typeof object === "object") {
-		index = objects.indexOf(object);
-		if (index !== -1) {
-			if (duplicatesIndexes.indexOf(index) === -1) duplicatesIndexes.push(index);
-		} else {
-			objects.push(object);
-			if (Array.isArray(object)) for (index = 0, length = object.length; index < length; index += 1) inspectNode(object[index], objects, duplicatesIndexes);
+	function writeNode(state, level, object, block, compact, iskey, isblockseq) {
+		state.tag = null;
+		state.dump = object;
+		if (!detectType(state, object, false)) detectType(state, object, true);
+		const type = _toString.call(state.dump);
+		const inblock = block;
+		if (block) block = state.flowLevel < 0 || state.flowLevel > level;
+		const objectOrArray = type === "[object Object]" || type === "[object Array]";
+		let duplicateIndex;
+		let duplicate;
+		if (objectOrArray) {
+			duplicateIndex = state.duplicates.indexOf(object);
+			duplicate = duplicateIndex !== -1;
+		}
+		if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) compact = false;
+		if (duplicate && state.usedDuplicates[duplicateIndex]) state.dump = "*ref_" + duplicateIndex;
+		else {
+			if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) state.usedDuplicates[duplicateIndex] = true;
+			if (type === "[object Object]") if (block && Object.keys(state.dump).length !== 0) {
+				writeBlockMapping(state, level, state.dump, compact);
+				if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
+			} else {
+				writeFlowMapping(state, level, state.dump);
+				if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+			}
+			else if (type === "[object Array]") if (block && state.dump.length !== 0) {
+				if (state.noArrayIndent && !isblockseq && level > 0) writeBlockSequence(state, level - 1, state.dump, compact);
+				else writeBlockSequence(state, level, state.dump, compact);
+				if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
+			} else {
+				writeFlowSequence(state, level, state.dump);
+				if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+			}
+			else if (type === "[object String]") {
+				if (state.tag !== "?") writeScalar(state, state.dump, level, iskey, inblock);
+			} else if (type === "[object Undefined]") return false;
 			else {
-				objectKeyList = Object.keys(object);
-				for (index = 0, length = objectKeyList.length; index < length; index += 1) inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
+				if (state.skipInvalid) return false;
+				throw new YAMLException("unacceptable kind of an object to dump " + type);
+			}
+			if (state.tag !== null && state.tag !== "?") {
+				let tagStr = encodeURI(state.tag[0] === "!" ? state.tag.slice(1) : state.tag).replace(/!/g, "%21");
+				if (state.tag[0] === "!") tagStr = "!" + tagStr;
+				else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") tagStr = "!!" + tagStr.slice(18);
+				else tagStr = "!<" + tagStr + ">";
+				state.dump = tagStr + " " + state.dump;
 			}
 		}
+		return true;
 	}
-}
-function dump$1(input, options) {
-	options = options || {};
-	var state = new State(options);
-	if (!state.noRefs) getDuplicateReferences(input, state);
-	var value = input;
-	if (state.replacer) value = state.replacer.call({ "": value }, "", value);
-	if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
-	return "";
-}
-var dumper = { dump: dump$1 };
-var load = loader.load;
-loader.loadAll;
-dumper.dump;
+	function getDuplicateReferences(object, state) {
+		const objects = [];
+		const duplicatesIndexes = [];
+		inspectNode(object, objects, duplicatesIndexes);
+		const length = duplicatesIndexes.length;
+		for (let index = 0; index < length; index += 1) state.duplicates.push(objects[duplicatesIndexes[index]]);
+		state.usedDuplicates = new Array(length);
+	}
+	function inspectNode(object, objects, duplicatesIndexes) {
+		if (object !== null && typeof object === "object") {
+			const index = objects.indexOf(object);
+			if (index !== -1) {
+				if (duplicatesIndexes.indexOf(index) === -1) duplicatesIndexes.push(index);
+			} else {
+				objects.push(object);
+				if (Array.isArray(object)) for (let i = 0, length = object.length; i < length; i += 1) inspectNode(object[i], objects, duplicatesIndexes);
+				else {
+					const objectKeyList = Object.keys(object);
+					for (let i = 0, length = objectKeyList.length; i < length; i += 1) inspectNode(object[objectKeyList[i]], objects, duplicatesIndexes);
+				}
+			}
+		}
+	}
+	function dump(input, options) {
+		options = options || {};
+		const state = new State(options);
+		if (!state.noRefs) getDuplicateReferences(input, state);
+		let value = input;
+		if (state.replacer) value = state.replacer.call({ "": value }, "", value);
+		if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
+		return "";
+	}
+	module.exports.dump = dump;
+}));
+var import_js_yaml = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var loader = require_loader();
+	var dumper = require_dumper();
+	function renamed(from, to) {
+		return function() {
+			throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default.");
+		};
+	}
+	module.exports.Type = require_type();
+	module.exports.Schema = require_schema();
+	module.exports.FAILSAFE_SCHEMA = require_failsafe();
+	module.exports.JSON_SCHEMA = require_json();
+	module.exports.CORE_SCHEMA = require_core();
+	module.exports.DEFAULT_SCHEMA = require_default();
+	module.exports.load = loader.load;
+	module.exports.loadAll = loader.loadAll;
+	module.exports.dump = dumper.dump;
+	module.exports.YAMLException = require_exception();
+	module.exports.types = {
+		binary: require_binary(),
+		float: require_float(),
+		map: require_map(),
+		null: require_null(),
+		pairs: require_pairs(),
+		set: require_set(),
+		timestamp: require_timestamp(),
+		bool: require_bool(),
+		int: require_int(),
+		merge: require_merge(),
+		omap: require_omap(),
+		seq: require_seq(),
+		str: require_str()
+	};
+	module.exports.safeLoad = renamed("safeLoad", "load");
+	module.exports.safeLoadAll = renamed("safeLoadAll", "loadAll");
+	module.exports.safeDump = renamed("safeDump", "dump");
+})))(), 1);
+var { Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump } = import_js_yaml.default;
+import_js_yaml.default;
 //#endregion
 //#region src/shared/model-utils.ts
 /**
@@ -5588,6 +5924,12 @@ function generateResourceClass(service, ctx) {
 		lines.push("import { AutoPaginatable } from '../common/utils/pagination';");
 		lines.push("import { fetchAndDeserialize } from '../common/utils/fetch-and-deserialize';");
 	}
+	if (plans.some((p) => {
+		const r = lookupResolved(p.op, resolvedLookup);
+		if (!r?.urlBuilder) return false;
+		const hidden = hiddenParamsFor(r);
+		return p.op.queryParams.some((qp) => !hidden.has(qp.name)) || Object.keys(getOpDefaults(r)).length > 0 || getOpInferFromClient(r).length > 0;
+	})) lines.push("import { toQueryString } from '../common/utils/query-string';");
 	const shouldEmitVaultCryptoHelpers = serviceClass === "Vault" && !ignoredMethodNames.has("encrypt") && !ignoredMethodNames.has("decrypt");
 	if (shouldEmitVaultCryptoHelpers) lines.push("import { base64ToUint8Array, uint8ArrayToBase64 } from '../common/utils/base64';");
 	const hasIdempotentPost = plans.some((p) => p.plan.isIdempotentPost);
@@ -5844,6 +6186,10 @@ function renderMethod$2(op, plan, method, service, ctx, modelMap, specEnumNames,
 	const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
 	const baselineClassMethod = baselineMethodFor$1(service, method, ctx);
 	const optionInfo = optionsObjectInfo(service, method, op, plan, ctx, baselineClassMethod, resolvedOp);
+	if (resolvedOp?.urlBuilder) {
+		renderUrlBuilderMethod$1(lines, op, method, pathStr, optionInfo, specEnumNames, resolvedOp);
+		return lines;
+	}
 	const overlayMethod = ctx.overlayLookup?.methodByOperation?.get(httpKey) ?? baselineClassMethod;
 	let validParamNames = null;
 	if (optionInfo) validParamNames = new Set(["options"]);
@@ -6359,6 +6705,66 @@ function clientFieldExpression$8(field) {
 		default: return `this.workos.${toCamelCase(field)}`;
 	}
 }
+/**
+* Compose a `` `${this.workos.baseURL}<path>[?${query}]` `` template literal from
+* a path expression produced by {@link buildPathStr}. The path expression is
+* either a single-quoted static literal (`'/sso/authorize'`) or a backtick
+* template with interpolated path params; either way its inner body is spliced
+* into the URL template.
+*/
+function urlTemplateLiteral(pathExpr, hasQuery) {
+	let inner;
+	if (pathExpr.startsWith("`") && pathExpr.endsWith("`") || pathExpr.startsWith("'") && pathExpr.endsWith("'")) inner = pathExpr.slice(1, -1);
+	else inner = "${" + pathExpr + "}";
+	return "`${this.workos.baseURL}" + inner + (hasQuery ? "?${query}" : "") + "`";
+}
+/**
+* Emit a URL-builder method for an operation marked with the `urlBuilder` hint
+* (OAuth-style redirect endpoints such as `/sso/authorize`). The method is
+* synchronous, returns the constructed URL as a string, and makes no HTTP call.
+* Visible query params, constant `defaults`, and `inferFromClient` fields are
+* serialized via `toQueryString` (wire-name keyed), matching the SDK's
+* hand-written URL builders.
+*/
+function renderUrlBuilderMethod$1(lines, op, method, pathStr, optionInfo, specEnumNames, resolvedOp) {
+	const hidden = hiddenParamsFor(resolvedOp);
+	const visibleQueryParams = op.queryParams.filter((p) => !hidden.has(p.name));
+	const hasQuery = visibleQueryParams.length > 0 || Object.keys(getOpDefaults(resolvedOp)).length > 0 || getOpInferFromClient(resolvedOp).length > 0;
+	{
+		const docParts = [];
+		if (op.description) docParts.push(op.description);
+		docParts.push("@returns {string} The constructed URL.");
+		if (op.deprecated) docParts.push("@deprecated");
+		const allLines = docParts.flatMap((p) => p.split("\n"));
+		if (allLines.length === 1) lines.push(`  /** ${allLines[0]} */`);
+		else {
+			lines.push("  /**");
+			for (const line of allLines) lines.push(line === "" ? "   *" : `   * ${line}`);
+			lines.push("   */");
+		}
+	}
+	if (optionInfo) {
+		lines.push(`  ${method}(${renderOptionsParam(optionInfo)}): string {`);
+		if (hasQuery) {
+			const queryExpr = renderQueryExprWithOptions(visibleQueryParams, optionInfo.optional, resolvedOp);
+			lines.push(`    const query = toQueryString(${queryExpr});`);
+			lines.push(`    return ${urlTemplateLiteral(pathStr, true)};`);
+		} else lines.push(`    return ${urlTemplateLiteral(pathStr, false)};`);
+		lines.push("  }");
+		return;
+	}
+	if (visibleQueryParams.length > 0) throw new Error(`renderUrlBuilderMethod: positional url builder "${method}" has visible query params (${visibleQueryParams.map((p) => p.name).join(", ")}) but no options object; they would be referenced without being declared. Expected the options-object convention.`);
+	const params = buildPathParams(op, specEnumNames);
+	lines.push(`  ${method}(${params}): string {`);
+	if (hasQuery) {
+		const queryParts = [];
+		for (const [key, value] of Object.entries(getOpDefaults(resolvedOp))) queryParts.push(`${key}: ${tsLiteral(value)}`);
+		for (const field of getOpInferFromClient(resolvedOp)) queryParts.push(`${field}: ${clientFieldExpression$8(field)}`);
+		lines.push(`    const query = toQueryString({ ${queryParts.join(", ")} });`);
+		lines.push(`    return ${urlTemplateLiteral(pathStr, true)};`);
+	} else lines.push(`    return ${urlTemplateLiteral(pathStr, false)};`);
+	lines.push("  }");
+}
 function renderVoidMethod(lines, op, plan, method, pathStr, ctx, specEnumNames, resolvedOp) {
 	const hiddenParams = new Set([...Object.keys(getOpDefaults(resolvedOp)), ...getOpInferFromClient(resolvedOp)]);
 	const params = buildPathParams(op, specEnumNames);
@@ -8789,6 +9195,182 @@ function generateSerializerTests(spec, ctx) {
 	return files;
 }
 //#endregion
+//#region src/shared/union-flatten.ts
+/**
+* Flatten field-level discriminated unions into a single superset model for
+* the flat-emit languages (Go, Kotlin, Node) that have no native sum type.
+*
+* Background: a property like `ApiKey.owner` is a discriminated `oneOf` whose
+* variants are inline objects — `{ type: 'organization', id }` and
+* `{ type: 'user', id, organization_id }`. The IR represents this as a `union`
+* TypeRef referencing two variant models (`ApiKeyOwner`, `UserApiKeyOwner`).
+* Languages that render such a union as "the first variant" — Go's
+* `unionResolverName`, Kotlin's `baseName` — silently drop every field that
+* only exists on a later variant, so `organization_id` disappears for
+* user-scoped keys. (See the SDK compat report's owner-field note.)
+*
+* This transform, applied only by the flat-emit emitters, merges every
+* variant's fields into the first variant (the union's canonical model),
+* marks any field not shared by all variants optional, widens the
+* discriminator property to the union of its per-variant literal values, and
+* rewrites the field to a plain model ref to that canonical model. The result
+* is one flat struct/data class/interface that carries every variant field,
+* with the discriminator property telling callers which variant they hold —
+* exactly how these emitters already flatten `allOf [base, oneOf]`
+* discriminated bases (see `enrichModelsFromSpec`).
+*
+* Returns a new models array; the input models are not mutated. Union-emitting
+* languages (Python, PHP, Rust, Ruby, .NET) must NOT call this — they emit a
+* real discriminated union and lose nothing.
+*/
+function flattenDiscriminatedUnionFields(models) {
+	const byName = new Map(models.map((m) => [m.name, m]));
+	const mergedFieldsByCanonical = /* @__PURE__ */ new Map();
+	/**
+	* Decide whether a union is a flat-flattenable discriminated union of inline
+	* object variants. When it is, record the merged field set for its canonical
+	* model and return that model's name; otherwise return null.
+	*/
+	function planUnion(union) {
+		if (!union.discriminator) return null;
+		const variantNames = union.variants.map((v) => v.kind === "model" ? v.name : null);
+		if (variantNames.length < 2 || variantNames.some((n) => n === null)) return null;
+		const variantModels = variantNames.map((n) => byName.get(n));
+		if (variantModels.some((m) => !m || m.discriminator || m.fields.length === 0)) return null;
+		const canonical = variantNames[0];
+		const merged = mergeVariantFields(variantModels, union.discriminator.property);
+		const existing = mergedFieldsByCanonical.get(canonical);
+		if (existing && fieldListSignature(existing) !== fieldListSignature(merged)) throw new Error(`flattenDiscriminatedUnionFields: model "${canonical}" is the first variant of two distinct discriminated unions that merge to different field sets. Flattening both onto one model would silently drop fields; disambiguate the variants in the spec (rename the leading variant of one union).`);
+		mergedFieldsByCanonical.set(canonical, merged);
+		return canonical;
+	}
+	/** Rewrite a TypeRef, collapsing flattenable unions to a canonical model ref. */
+	function rewriteRef(ref) {
+		switch (ref.kind) {
+			case "union": {
+				const canonical = planUnion(ref);
+				return canonical ? {
+					kind: "model",
+					name: canonical
+				} : ref;
+			}
+			case "nullable": {
+				const inner = rewriteRef(ref.inner);
+				return inner === ref.inner ? ref : {
+					kind: "nullable",
+					inner
+				};
+			}
+			case "array": {
+				const items = rewriteRef(ref.items);
+				return items === ref.items ? ref : {
+					kind: "array",
+					items
+				};
+			}
+			default: return ref;
+		}
+	}
+	const rewritten = models.map((model) => {
+		let changed = false;
+		const fields = model.fields.map((field) => {
+			const type = rewriteRef(field.type);
+			if (type === field.type) return field;
+			changed = true;
+			return {
+				...field,
+				type
+			};
+		});
+		return changed ? {
+			...model,
+			fields
+		} : model;
+	});
+	if (mergedFieldsByCanonical.size === 0) return models;
+	return rewritten.map((model) => {
+		const merged = mergedFieldsByCanonical.get(model.name);
+		return merged ? {
+			...model,
+			fields: merged
+		} : model;
+	});
+}
+/**
+* Build the merged field list for a discriminated union's variant models.
+*
+* - A field is required only when present-and-required in *every* variant; a
+*   field missing from some variant (e.g. the user variant's `organization_id`)
+*   becomes optional.
+* - The discriminator property is widened to the union of its per-variant
+*   literal values (`'organization' | 'user'`) so it isn't pinned to the first
+*   variant's constant. (Flat-emit type maps collapse a single-typed literal
+*   union to a plain string, so this is a no-op for Go/Kotlin and a precise
+*   `'organization' | 'user'` for Node.)
+* - Field order follows the first variant, then newly-seen fields from later
+*   variants.
+*/
+function mergeVariantFields(variants, discriminatorProp) {
+	const total = variants.length;
+	const order = [];
+	const defByName = /* @__PURE__ */ new Map();
+	const presence = /* @__PURE__ */ new Map();
+	const requiredCount = /* @__PURE__ */ new Map();
+	for (const variant of variants) for (const field of variant.fields) {
+		const seen = defByName.get(field.name);
+		if (!seen) {
+			defByName.set(field.name, field);
+			order.push(field.name);
+		} else if (field.name !== discriminatorProp && !sameTypeRef(seen.type, field.type)) throw new Error(`flattenDiscriminatedUnionFields: field "${field.name}" has conflicting types across variants of a discriminated union; a flat superset model cannot represent both. Align the field type across variants in the spec.`);
+		presence.set(field.name, (presence.get(field.name) ?? 0) + 1);
+		if (field.required) requiredCount.set(field.name, (requiredCount.get(field.name) ?? 0) + 1);
+	}
+	return order.map((name) => {
+		const def = defByName.get(name);
+		if (name === discriminatorProp) {
+			const literals = dedupeLiteralTypes(variants.map((v) => v.fields.find((f) => f.name === name)?.type).filter((t) => t != null));
+			const type = literals.length > 1 ? {
+				kind: "union",
+				variants: literals
+			} : literals[0] ?? def.type;
+			return {
+				...def,
+				type,
+				required: presence.get(name) === total
+			};
+		}
+		const required = presence.get(name) === total && requiredCount.get(name) === total;
+		return required === def.required ? def : {
+			...def,
+			required
+		};
+	});
+}
+/** Structural equality of two TypeRefs (IR refs have a stable, deterministic shape). */
+function sameTypeRef(a, b) {
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+/** Stable signature of a merged field list, used to detect canonical collisions. */
+function fieldListSignature(fields) {
+	return JSON.stringify(fields.map((f) => [
+		f.name,
+		f.required,
+		f.type
+	]));
+}
+/** Deduplicate literal TypeRefs by value, preserving first-seen order. */
+function dedupeLiteralTypes(types) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const t of types) {
+		const key = t.kind === "literal" ? `lit:${String(t.value)}` : JSON.stringify(t);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(t);
+	}
+	return out;
+}
+//#endregion
 //#region src/node/discriminated-models.ts
 function detectDiscriminatedShape(modelName, rawSchemas) {
 	const schema = rawSchemas[modelName];
@@ -9815,7 +10397,7 @@ function carryForwardManagedFiles(ctx, surface) {
 function enrichModelsForNode(models) {
 	const enriched = enrichModelsFromSpec(models);
 	const originalByName = new Map(models.map((m) => [m.name, m]));
-	return enriched.map((m) => {
+	return flattenDiscriminatedUnionFields(enriched.map((m) => {
 		if (m.discriminator && m.fields.length === 0) {
 			const original = originalByName.get(m.name);
 			if (original && original.fields.length > 0) return {
@@ -9824,7 +10406,7 @@ function enrichModelsForNode(models) {
 			};
 		}
 		return m;
-	});
+	}));
 }
 const nodeEmitter = {
 	language: "node",
@@ -18635,7 +19217,7 @@ const goEmitter = {
 	generateModels(models, ctx) {
 		const enriched = enrichModelsFromSpec(models);
 		const originalByName = new Map(models.map((m) => [m.name, m]));
-		return ensureTrailingNewlines$4(generateModels$4(enriched.map((m) => {
+		return ensureTrailingNewlines$4(generateModels$4(flattenDiscriminatedUnionFields(enriched.map((m) => {
 			if (m.discriminator && m.fields.length === 0) {
 				const original = originalByName.get(m.name);
 				if (original && original.fields.length > 0) return {
@@ -18644,7 +19226,7 @@ const goEmitter = {
 				};
 			}
 			return m;
-		}), ctx));
+		})), ctx));
 	},
 	generateEnums(enums, ctx) {
 		const syntheticEnums = getSyntheticEnums();
@@ -24272,7 +24854,7 @@ const kotlinEmitter = {
 	generateModels(models, ctx) {
 		const enriched = enrichModelsFromSpec(models);
 		const originalByName = new Map(models.map((m) => [m.name, m]));
-		return ensureTrailingNewlines$2(generateModels$2(enriched.map((m) => {
+		return ensureTrailingNewlines$2(generateModels$2(flattenDiscriminatedUnionFields(enriched.map((m) => {
 			if (m.discriminator && m.fields.length === 0) {
 				const original = originalByName.get(m.name);
 				if (original && original.fields.length > 0) return {
@@ -24281,7 +24863,7 @@ const kotlinEmitter = {
 				};
 			}
 			return m;
-		}), ctx));
+		})), ctx));
 	},
 	generateEnums(enums, ctx) {
 		const syntheticEnums = getSyntheticEnums();
@@ -24300,7 +24882,7 @@ const kotlinEmitter = {
 		return [];
 	},
 	generateTests(spec, ctx) {
-		const enrichedModels = enrichModelsFromSpec(spec.models);
+		const enrichedModels = flattenDiscriminatedUnionFields(enrichModelsFromSpec(spec.models));
 		const enrichedSpec = {
 			...spec,
 			models: enrichedModels
@@ -27964,19 +28546,24 @@ function renderAutoPagingMethod(op, resolved, paramsType, method, ctx) {
 	if (!op.pagination) return null;
 	if (op.pagination.strategy !== "cursor") return null;
 	if (resolved.urlBuilder) return null;
-	if (op.response.kind !== "model") return null;
-	const responseModel = ctx.spec.models.find((m) => m.name === op.response.name);
-	if (!responseModel) return null;
 	const cursorParam = op.pagination.param;
 	const dataPath = op.pagination.dataPath ?? "data";
-	const dataField = responseModel.fields.find((f) => f.name === dataPath);
-	if (!dataField || dataField.type.kind !== "array") return null;
-	const listMetadataField = responseModel.fields.find((f) => f.name === "list_metadata");
-	if (!listMetadataField || listMetadataField.type.kind !== "model") return null;
-	const metadataModel = ctx.spec.models.find((m) => m.name === listMetadataField.type.name);
-	if (!metadataModel) return null;
-	if (!metadataModel.fields.some((f) => f.name === cursorParam)) return null;
-	const itemType = mapTypeRef$1(dataField.type.items);
+	let itemType;
+	if (op.response.kind === "model") {
+		const responseModel = ctx.spec.models.find((m) => m.name === op.response.name);
+		if (!responseModel) return null;
+		const dataField = responseModel.fields.find((f) => f.name === dataPath);
+		if (!dataField || dataField.type.kind !== "array") return null;
+		const listMetadataField = responseModel.fields.find((f) => f.name === "list_metadata");
+		if (!listMetadataField || listMetadataField.type.kind !== "model") return null;
+		const metadataModel = ctx.spec.models.find((m) => m.name === listMetadataField.type.name);
+		if (!metadataModel) return null;
+		if (!metadataModel.fields.some((f) => f.name === cursorParam)) return null;
+		itemType = mapTypeRef$1(dataField.type.items);
+	} else if (isInlineEnvelopeList(op) && cursorParam === "after") {
+		if (!op.queryParams.some((p) => p.name === cursorParam)) return null;
+		itemType = mapTypeRef$1(op.response.items);
+	} else return null;
 	const cursorField = fieldName(cursorParam);
 	const dataAccessor = fieldName(dataPath);
 	const pathArgList = op.pathParams.map((p) => `${methodName(p.name)}: impl Into<String>`);
@@ -28155,11 +28742,17 @@ function renderWrapperMethod(op, wrapper, params, paramsType, method) {
 		sig.push(`        let path = format!(${JSON.stringify(pathFormat)});`);
 	} else sig.push(`        let path = ${JSON.stringify(pathFormat)}.to_string();`);
 	sig.push(`        let method = http::Method::${op.httpMethod.toUpperCase()};`);
-	sig.push("        let body = serde_json::json!({");
+	const inferredFields = wrapper.inferFromClient ?? [];
+	sig.push(`        let ${inferredFields.length > 0 ? "mut " : ""}body = serde_json::json!({`);
 	for (const [k, v] of Object.entries(wrapper.defaults ?? {})) sig.push(`            ${JSON.stringify(k)}: ${JSON.stringify(v)},`);
-	for (const k of wrapper.inferFromClient ?? []) sig.push(`            ${JSON.stringify(k)}: ${clientFieldExpression(k)},`);
 	for (const rp of params) sig.push(`            ${JSON.stringify(rp.paramName)}: params.${fieldName(rp.paramName)},`);
 	sig.push("        });");
+	for (const k of inferredFields) {
+		const expr = clientFieldExpression(k);
+		sig.push(`        if !${expr}.is_empty() {`);
+		sig.push(`            body[${JSON.stringify(k)}] = serde_json::Value::String(${expr}.to_string());`);
+		sig.push("        }");
+	}
 	sig.push("        #[derive(Serialize)]");
 	sig.push("        struct EmptyQuery {}");
 	sig.push("        self.client");
@@ -28170,14 +28763,17 @@ function renderWrapperMethod(op, wrapper, params, paramsType, method) {
 }
 /**
 * Rust expression for reading a client-config field at request time. Mirrors
-* the Go emitter's `clientFieldExpression`. Falls back to an empty literal
-* for unknown fields so the body still compiles.
+* the Go emitter's `clientFieldExpression`. Throws on unknown fields rather
+* than falling back to an empty literal: with the `if !expr.is_empty()` guard
+* in `renderWrapperMethod`, an empty literal would silently drop the field from
+* every request body (and emit dead `if !"".is_empty()` Rust). Failing loud at
+* generation time surfaces a missing case instead of shipping a broken SDK.
 */
 function clientFieldExpression(field) {
 	switch (field) {
 		case "client_id": return "self.client.client_id()";
 		case "client_secret": return "self.client.api_key()";
-		default: return "\"\"";
+		default: throw new Error(`Rust emitter: no client-config accessor for inferFromClient field "${field}". Add a case to clientFieldExpression.`);
 	}
 }
 /** Multi-line `///` doc comment from a free-form description. */
@@ -28237,9 +28833,30 @@ function methodDocLines(op) {
 }
 function renderResponseType(op) {
 	if (isEmptyResponse(op)) return "()";
+	if (isInlineEnvelopeList(op)) return `crate::pagination::Page<${mapTypeRef$1(op.response.items)}>`;
 	return mapTypeRef$1(op.response);
 }
 /**
+* True when the spec declared this response as an inline pagination envelope
+* (`{ object, data: [...], list_metadata }` without a named component). The IR
+* models these as a bare array plus `pagination.dataPath`, but the wire format
+* is still the envelope — decoding the body straight into `Vec<T>` fails, so
+* these ops decode into the hand-maintained `crate::pagination::Page<T>`
+* instead. Restricted to `data` because that's the field `Page<T>` declares.
+*
+* The `=== 'data'` is a strict equality on purpose — deliberately *not* the
+* `?? 'data'` fallback used elsewhere. `dataPath` is the only signal that
+* separates an inline envelope (decoded as `Page<T>`) from a genuine paginated
+* bare array (decoded as `Vec<T>`, see the `responseKind === 'array'` branch in
+* tests.ts). This therefore relies on the IR setting `dataPath: 'data'`
+* explicitly for envelope responses and leaving it unset for bare arrays. If
+* the IR ever omitted it for an envelope op, this would return `false` and the
+* op would decode into `Vec<T>` and fail — so that invariant must hold upstream.
+*/
+function isInlineEnvelopeList(op) {
+	return op.response?.kind === "array" && op.pagination?.dataPath === "data";
+}
+/**
 * True when the operation has no usable response schema. We treat the IR's
 * `primitive: unknown` and missing-response cases the same way: the spec
 * declared no JSON body, so the SDK promises nothing about the contents.
@@ -28586,7 +29203,7 @@ function renderRegularTest(op, resolved, accessor, crate, modelMap, enumMap) {
 	const m = methodName(resolved.methodName);
 	const literalPath = op.path.replace(/\{[^}]+\}/g, "test_id");
 	const httpMethod = op.httpMethod.toUpperCase();
-	const responseExpr = responseBodyExpr(op.response, modelMap, enumMap);
+	const responseExpr = isInlineEnvelopeList(op) ? JSON.stringify("{\"object\":\"list\",\"data\":[],\"list_metadata\":{\"before\":null,\"after\":null}}") : responseBodyExpr(op.response, modelMap, enumMap);
 	const isUrlBuilder = resolved.urlBuilder === true;
 	const callArgs = buildCallArgs(op, resolved, crate, accessor, modelMap, enumMap).join(", ");
 	const shape = {
@@ -28742,7 +29359,10 @@ function emptyPageTest(op, shape, accessor) {
 	const responseKind = op.response.kind;
 	let body;
 	let dataAccessor;
-	if (responseKind === "array") {
+	if (isInlineEnvelopeList(op)) {
+		body = "{\"object\":\"list\",\"data\":[],\"list_metadata\":{\"before\":null,\"after\":null}}";
+		dataAccessor = "resp.data";
+	} else if (responseKind === "array") {
 		body = "[]";
 		dataAccessor = "resp";
 	} else if (responseKind === "model") {
@@ -28825,7 +29445,7 @@ function encodesQueryParamsTest(op, resolved, accessor, crate, modelMap, enumMap
 /** Body expression for the encoding-test response (success, ignored). */
 function encodingResponseExpr(op, modelMap, enumMap) {
 	if (op.pagination) {
-		if (op.response.kind === "array") return JSON.stringify("[]");
+		if (op.response.kind === "array" && !isInlineEnvelopeList(op)) return JSON.stringify("[]");
 		return JSON.stringify("{\"object\":\"list\",\"data\":[],\"list_metadata\":{\"before\":null,\"after\":null}}");
 	}
 	return responseBodyExpr(op.response, modelMap, enumMap);
@@ -29144,4 +29764,4 @@ const workosEmittersPlugin = {
 //#endregion
 export { fieldName$2 as A, servicePropertyName$2 as B, apiClassName as C, dotnetEmitter as D, propertyName as E, fieldName$3 as F, fieldName$5 as H, methodName$3 as I, trimMountedResourceFromMethod$2 as L, trimMountedResourceFromMethod$1 as M, goEmitter as N, appendAsyncSuffix as O, className$3 as P, phpEmitter as R, kotlinEmitter as S, packageSegment as T, safeParamName$1 as U, pythonEmitter as V, nodeEmitter as W, rubyEmitter as _, rustExtractor as a, resolveServiceTarget as b, pythonExtractor as c, rustEmitter as d, fieldName as f, typeName as g, resourceAccessorName as h, kotlinExtractor as i, methodName$2 as j, className$2 as k, rubyExtractor as l, moduleName as m, elixirExtractor as n, goExtractor as o, methodName as p, dotnetExtractor as r, phpExtractor as s, workosEmittersPlugin as t, nodeExtractor as u, buildExportedClassNameSet as v, methodName$1 as w, safeParamName as x, fieldName$1 as y, fieldName$4 as z };
 
-//# sourceMappingURL=plugin-CpO8rePT.mjs.map
+//# sourceMappingURL=plugin-BLnR-FMi.mjs.map