@powerlines/plugin-content-collections 0.1.257 → 0.1.259

package/dist/node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/dumper.cjs

@@ -0,0 +1,452 @@
+'use strict';
+
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.cjs');
+const require_common$1 = require('./common.cjs');
+const require_exception$1 = require('./exception.cjs');
+const require_default_safe$1 = require('./schema/default_safe.cjs');
+const require_default_full$1 = require('./schema/default_full.cjs');
+
+//#region ../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/dumper.js
+var require_dumper = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	var common = require_common$1.default;
+	var YAMLException = require_exception$1.default;
+	var DEFAULT_FULL_SCHEMA = require_default_full$1.default;
+	var DEFAULT_SAFE_SCHEMA = require_default_safe$1.default;
+	var _toString = Object.prototype.toString;
+	var _hasOwnProperty = Object.prototype.hasOwnProperty;
+	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"
+	];
+	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;
+		}
+		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 YAMLException("code point within a string may not be greater than 0xFFFFFFFF");
+		return "\\" + handle + common.repeat("0", length - string.length) + string;
+	}
+	function State(options) {
+		this.schema = options["schema"] || DEFAULT_FULL_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.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;
+			}
+			if (line.length && line !== "\n") result += ind;
+			result += line;
+		}
+		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;
+		}
+		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 !== 65279 || 65536 <= c && c <= 1114111;
+	}
+	function isNsChar(c) {
+		return isPrintable(c) && !isWhitespace(c) && c !== 65279 && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
+	}
+	function isPlainSafe(c, prev) {
+		return isPrintable(c) && c !== 65279 && 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_COLON && (c !== CHAR_SHARP || prev && isNsChar(prev));
+	}
+	function isPlainSafeFirst(c) {
+		return isPrintable(c) && c !== 65279 && !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 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) {
+		var i;
+		var char, prev_char;
+		var hasLineBreak = false;
+		var hasFoldableLine = false;
+		var shouldTrackWidth = lineWidth !== -1;
+		var previousLineBreak = -1;
+		var plain = isPlainSafeFirst(string.charCodeAt(0)) && !isWhitespace(string.charCodeAt(string.length - 1));
+		if (singleLineOnly) for (i = 0; i < string.length; i++) {
+			char = string.charCodeAt(i);
+			if (!isPrintable(char)) return STYLE_DOUBLE;
+			prev_char = i > 0 ? string.charCodeAt(i - 1) : null;
+			plain = plain && isPlainSafe(char, prev_char);
+		}
+		else {
+			for (i = 0; i < string.length; i++) {
+				char = string.charCodeAt(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;
+				prev_char = i > 0 ? string.charCodeAt(i - 1) : null;
+				plain = plain && isPlainSafe(char, prev_char);
+			}
+			hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
+		}
+		if (!hasLineBreak && !hasFoldableLine) return plain && !testAmbiguousType(string) ? STYLE_PLAIN : STYLE_SINGLE;
+		if (indentPerLevel > 9 && needIndentIndicator(string)) return STYLE_DOUBLE;
+		return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
+	}
+	function writeScalar(state, string, level, iskey) {
+		state.dump = function() {
+			if (string.length === 0) return "''";
+			if (!state.noCompatMode && DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) return "'" + 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$1) {
+				return testImplicitResolving(state, string$1);
+			}
+			switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) {
+				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) {
+		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;
+		}
+		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, nextChar;
+		var escapeSeq;
+		for (var i = 0; i < string.length; i++) {
+			char = string.charCodeAt(i);
+			if (char >= 55296 && char <= 56319) {
+				nextChar = string.charCodeAt(i + 1);
+				if (nextChar >= 56320 && nextChar <= 57343) {
+					result += encodeHex((char - 55296) * 1024 + nextChar - 56320 + 65536);
+					i++;
+					continue;
+				}
+			}
+			escapeSeq = ESCAPE_SEQUENCES[char];
+			result += !escapeSeq && isPrintable(char) ? string[i] : escapeSeq || encodeHex(char);
+		}
+		return result;
+	}
+	function writeFlowSequence(state, level, object) {
+		var _result = "", _tag = state.tag, index, length;
+		for (index = 0, length = object.length; index < length; index += 1) if (writeNode(state, level, object[index], false, false)) {
+			if (index !== 0) _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;
+		for (index = 0, length = object.length; index < length; index += 1) if (writeNode(state, level + 1, object[index], true, true)) {
+			if (!compact || index !== 0) _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 (index !== 0) pairBuffer += ", ";
+			if (state.condenseFlow) pairBuffer += "\"";
+			objectKey = objectKeyList[index];
+			objectValue = object[objectKey];
+			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 YAMLException("sortKeys must be a boolean or a function");
+		for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+			pairBuffer = "";
+			if (!compact || index !== 0) pairBuffer += generateNextLine(state, level);
+			objectKey = objectKeyList[index];
+			objectValue = object[objectKey];
+			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))) {
+				state.tag = explicit ? type.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 YAMLException("!<" + type.tag + "> tag resolver accepts not \"" + style + "\" style");
+					state.dump = _result;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+	function writeNode(state, level, object, block, compact, iskey) {
+		state.tag = null;
+		state.dump = object;
+		if (!detectType(state, object, false)) detectType(state, object, true);
+		var type = _toString.call(state.dump);
+		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;
+			}
+			else if (type === "[object Array]") {
+				var arrayLevel = state.noArrayIndent && level > 0 ? level - 1 : level;
+				if (block && state.dump.length !== 0) {
+					writeBlockSequence(state, arrayLevel, state.dump, compact);
+					if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
+				} else {
+					writeFlowSequence(state, arrayLevel, state.dump);
+					if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+				}
+			} else if (type === "[object String]") {
+				if (state.tag !== "?") writeScalar(state, state.dump, level, iskey);
+			} else {
+				if (state.skipInvalid) return false;
+				throw new YAMLException("unacceptable kind of an object to dump " + type);
+			}
+			if (state.tag !== null && state.tag !== "?") state.dump = "!<" + state.tag + "> " + state.dump;
+		}
+		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);
+				else {
+					objectKeyList = Object.keys(object);
+					for (index = 0, length = objectKeyList.length; index < length; index += 1) inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
+				}
+			}
+		}
+	}
+	function dump(input, options) {
+		options = options || {};
+		var state = new State(options);
+		if (!state.noRefs) getDuplicateReferences(input, state);
+		if (writeNode(state, 0, input, true, true)) return state.dump + "\n";
+		return "";
+	}
+	function safeDump(input, options) {
+		return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
+	}
+	module.exports.dump = dump;
+	module.exports.safeDump = safeDump;
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_dumper();
+  }
+});