@rspress/shared 2.0.7 → 2.0.9

package/dist/gray-matter.js

@@ -0,0 +1,2772 @@
+/*! LICENSE: gray-matter.js.LICENSE.txt */
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { createRequire as __rspack_createRequire } from "node:module";
+const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+__webpack_require__.add({
+    "../../node_modules/.pnpm/extend-shallow@2.0.1/node_modules/extend-shallow/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var isObject = __webpack_require__("../../node_modules/.pnpm/is-extendable@0.1.1/node_modules/is-extendable/index.js");
+        module.exports = function(o) {
+            if (!isObject(o)) o = {};
+            var len = arguments.length;
+            for(var i = 1; i < len; i++){
+                var obj = arguments[i];
+                if (isObject(obj)) assign(o, obj);
+            }
+            return o;
+        };
+        function assign(a, b) {
+            for(var key in b)if (hasOwn(b, key)) a[key] = b[key];
+        }
+        function hasOwn(obj, key) {
+            return Object.prototype.hasOwnProperty.call(obj, key);
+        }
+    },
+    "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const fs = __webpack_require__("fs");
+        const sections = __webpack_require__("../../node_modules/.pnpm/section-matter@1.0.0/node_modules/section-matter/index.js");
+        const defaults = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/defaults.js");
+        const stringify = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/stringify.js");
+        const excerpt = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/excerpt.js");
+        const engines = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engines.js");
+        const toFile = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/to-file.js");
+        const parse = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/parse.js");
+        const utils = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/utils.js");
+        function matter(input, options) {
+            if ('' === input) return {
+                data: {},
+                content: input,
+                excerpt: '',
+                orig: input
+            };
+            let file = toFile(input);
+            const cached = matter.cache[file.content];
+            if (!options) {
+                if (cached) {
+                    file = Object.assign({}, cached);
+                    file.orig = cached.orig;
+                    return file;
+                }
+                matter.cache[file.content] = file;
+            }
+            return parseMatter(file, options);
+        }
+        function parseMatter(file, options) {
+            const opts = defaults(options);
+            const open = opts.delimiters[0];
+            const close = '\n' + opts.delimiters[1];
+            let str = file.content;
+            if (opts.language) file.language = opts.language;
+            const openLen = open.length;
+            if (!utils.startsWith(str, open, openLen)) {
+                excerpt(file, opts);
+                return file;
+            }
+            if (str.charAt(openLen) === open.slice(-1)) return file;
+            str = str.slice(openLen);
+            const len = str.length;
+            const language = matter.language(str, opts);
+            if (language.name) {
+                file.language = language.name;
+                str = str.slice(language.raw.length);
+            }
+            let closeIndex = str.indexOf(close);
+            if (-1 === closeIndex) closeIndex = len;
+            file.matter = str.slice(0, closeIndex);
+            const block = file.matter.replace(/^\s*#[^\n]+/gm, '').trim();
+            if ('' === block) {
+                file.isEmpty = true;
+                file.empty = file.content;
+                file.data = {};
+            } else file.data = parse(file.language, file.matter, opts);
+            if (closeIndex === len) file.content = '';
+            else {
+                file.content = str.slice(closeIndex + close.length);
+                if ('\r' === file.content[0]) file.content = file.content.slice(1);
+                if ('\n' === file.content[0]) file.content = file.content.slice(1);
+            }
+            excerpt(file, opts);
+            if (true === opts.sections || 'function' == typeof opts.section) sections(file, opts.section);
+            return file;
+        }
+        matter.engines = engines;
+        matter.stringify = function(file, data, options) {
+            if ('string' == typeof file) file = matter(file, options);
+            return stringify(file, data, options);
+        };
+        matter.read = function(filepath, options) {
+            const str = fs.readFileSync(filepath, 'utf8');
+            const file = matter(str, options);
+            file.path = filepath;
+            return file;
+        };
+        matter.test = function(str, options) {
+            return utils.startsWith(str, defaults(options).delimiters[0]);
+        };
+        matter.language = function(str, options) {
+            const opts = defaults(options);
+            const open = opts.delimiters[0];
+            if (matter.test(str)) str = str.slice(open.length);
+            const language = str.slice(0, str.search(/\r?\n/));
+            return {
+                raw: language,
+                name: language ? language.trim() : ''
+            };
+        };
+        matter.cache = {};
+        matter.clearCache = function() {
+            matter.cache = {};
+        };
+        module.exports = matter;
+    },
+    "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/defaults.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const engines = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engines.js");
+        const utils = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/utils.js");
+        module.exports = function(options) {
+            const opts = Object.assign({}, options);
+            opts.delimiters = utils.arrayify(opts.delims || opts.delimiters || '---');
+            if (1 === opts.delimiters.length) opts.delimiters.push(opts.delimiters[0]);
+            opts.language = (opts.language || opts.lang || 'yaml').toLowerCase();
+            opts.engines = Object.assign({}, engines, opts.parsers, opts.engines);
+            return opts;
+        };
+    },
+    "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engine.js" (module) {
+        module.exports = function(name, options) {
+            let engine = options.engines[name] || options.engines[aliase(name)];
+            if (void 0 === engine) throw new Error('gray-matter engine "' + name + '" is not registered');
+            if ('function' == typeof engine) engine = {
+                parse: engine
+            };
+            return engine;
+        };
+        function aliase(name) {
+            switch(name.toLowerCase()){
+                case 'js':
+                case "javascript":
+                    return "javascript";
+                case 'coffee':
+                case "coffeescript":
+                case 'cson':
+                    return 'coffee';
+                case 'yaml':
+                case 'yml':
+                    return 'yaml';
+                default:
+                    return name;
+            }
+        }
+    },
+    "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engines.js" (module, exports, __webpack_require__) {
+        const yaml = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/index.js");
+        const engines = exports = module.exports;
+        engines.yaml = {
+            parse: yaml.safeLoad.bind(yaml),
+            stringify: yaml.safeDump.bind(yaml)
+        };
+        engines.json = {
+            parse: JSON.parse.bind(JSON),
+            stringify: function(obj, options) {
+                const opts = Object.assign({
+                    replacer: null,
+                    space: 2
+                }, options);
+                return JSON.stringify(obj, opts.replacer, opts.space);
+            }
+        };
+        engines.javascript = {
+            parse: function parse(str, options, wrap) {
+                try {
+                    if (false !== wrap) str = '(function() {\nreturn ' + str.trim() + ';\n}());';
+                    return eval(str) || {};
+                } catch (err) {
+                    if (false !== wrap && /(unexpected|identifier)/i.test(err.message)) return parse(str, options, false);
+                    throw new SyntaxError(err);
+                }
+            },
+            stringify: function() {
+                throw new Error('stringifying JavaScript is not supported');
+            }
+        };
+    },
+    "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/excerpt.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const defaults = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/defaults.js");
+        module.exports = function(file, options) {
+            const opts = defaults(options);
+            if (null == file.data) file.data = {};
+            if ('function' == typeof opts.excerpt) return opts.excerpt(file, opts);
+            const sep = file.data.excerpt_separator || opts.excerpt_separator;
+            if (null == sep && (false === opts.excerpt || null == opts.excerpt)) return file;
+            const delimiter = 'string' == typeof opts.excerpt ? opts.excerpt : sep || opts.delimiters[0];
+            const idx = file.content.indexOf(delimiter);
+            if (-1 !== idx) file.excerpt = file.content.slice(0, idx);
+            return file;
+        };
+    },
+    "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/parse.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const getEngine = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engine.js");
+        const defaults = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/defaults.js");
+        module.exports = function(language, str, options) {
+            const opts = defaults(options);
+            const engine = getEngine(language, opts);
+            if ('function' != typeof engine.parse) throw new TypeError('expected "' + language + '.parse" to be a function');
+            return engine.parse(str, opts);
+        };
+    },
+    "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/stringify.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const typeOf = __webpack_require__("../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js");
+        const getEngine = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engine.js");
+        const defaults = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/defaults.js");
+        module.exports = function(file, data, options) {
+            if (null == data && null == options) switch(typeOf(file)){
+                case 'object':
+                    data = file.data;
+                    options = {};
+                    break;
+                case 'string':
+                    return file;
+                default:
+                    throw new TypeError('expected file to be a string or object');
+            }
+            const str = file.content;
+            const opts = defaults(options);
+            if (null == data) {
+                if (!opts.data) return file;
+                data = opts.data;
+            }
+            const language = file.language || opts.language;
+            const engine = getEngine(language, opts);
+            if ('function' != typeof engine.stringify) throw new TypeError('expected "' + language + '.stringify" to be a function');
+            data = Object.assign({}, file.data, data);
+            const open = opts.delimiters[0];
+            const close = opts.delimiters[1];
+            const matter = engine.stringify(data, options).trim();
+            let buf = '';
+            if ('{}' !== matter) buf = newline(open) + newline(matter) + newline(close);
+            if ('string' == typeof file.excerpt && '' !== file.excerpt) {
+                if (-1 === str.indexOf(file.excerpt.trim())) buf += newline(file.excerpt) + newline(close);
+            }
+            return buf + newline(str);
+        };
+        function newline(str) {
+            return '\n' !== str.slice(-1) ? str + '\n' : str;
+        }
+    },
+    "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/to-file.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const typeOf = __webpack_require__("../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js");
+        const stringify = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/stringify.js");
+        const utils = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/utils.js");
+        module.exports = function(file) {
+            if ('object' !== typeOf(file)) file = {
+                content: file
+            };
+            if ('object' !== typeOf(file.data)) file.data = {};
+            if (file.contents && null == file.content) file.content = file.contents;
+            utils.define(file, 'orig', utils.toBuffer(file.content));
+            utils.define(file, 'language', file.language || '');
+            utils.define(file, 'matter', file.matter || '');
+            utils.define(file, 'stringify', function(data, options) {
+                if (options && options.language) file.language = options.language;
+                return stringify(file, data, options);
+            });
+            file.content = utils.toString(file.content);
+            file.isEmpty = false;
+            file.excerpt = '';
+            return file;
+        };
+    },
+    "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/utils.js" (__unused_rspack_module, exports, __webpack_require__) {
+        const stripBom = __webpack_require__("../../node_modules/.pnpm/strip-bom-string@1.0.0/node_modules/strip-bom-string/index.js");
+        const typeOf = __webpack_require__("../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js");
+        exports.define = function(obj, key, val) {
+            Reflect.defineProperty(obj, key, {
+                enumerable: false,
+                configurable: true,
+                writable: true,
+                value: val
+            });
+        };
+        exports.isBuffer = function(val) {
+            return 'buffer' === typeOf(val);
+        };
+        exports.isObject = function(val) {
+            return 'object' === typeOf(val);
+        };
+        exports.toBuffer = function(input) {
+            return 'string' == typeof input ? Buffer.from(input) : input;
+        };
+        exports.toString = function(input) {
+            if (exports.isBuffer(input)) return stripBom(String(input));
+            if ('string' != typeof input) throw new TypeError('expected input to be a string or buffer');
+            return stripBom(input);
+        };
+        exports.arrayify = function(val) {
+            return val ? Array.isArray(val) ? val : [
+                val
+            ] : [];
+        };
+        exports.startsWith = function(str, substr, len) {
+            if ('number' != typeof len) len = substr.length;
+            return str.slice(0, len) === substr;
+        };
+    },
+    "../../node_modules/.pnpm/is-extendable@0.1.1/node_modules/is-extendable/index.js" (module) {
+        /*!
+ * is-extendable <https://github.com/jonschlinkert/is-extendable>
+ *
+ * Copyright (c) 2015, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */ module.exports = function(val) {
+            return null != val && ('object' == typeof val || 'function' == typeof val);
+        };
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var yaml = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml.js");
+        module.exports = yaml;
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var loader = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/loader.js");
+        var dumper = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/dumper.js");
+        function deprecated(name) {
+            return function() {
+                throw new Error('Function ' + name + ' is deprecated and cannot be used.');
+            };
+        }
+        module.exports.Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        module.exports.Schema = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema.js");
+        module.exports.FAILSAFE_SCHEMA = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/failsafe.js");
+        module.exports.JSON_SCHEMA = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/json.js");
+        module.exports.CORE_SCHEMA = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/core.js");
+        module.exports.DEFAULT_SAFE_SCHEMA = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_safe.js");
+        module.exports.DEFAULT_FULL_SCHEMA = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_full.js");
+        module.exports.load = loader.load;
+        module.exports.loadAll = loader.loadAll;
+        module.exports.safeLoad = loader.safeLoad;
+        module.exports.safeLoadAll = loader.safeLoadAll;
+        module.exports.dump = dumper.dump;
+        module.exports.safeDump = dumper.safeDump;
+        module.exports.YAMLException = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/exception.js");
+        module.exports.MINIMAL_SCHEMA = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/failsafe.js");
+        module.exports.SAFE_SCHEMA = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_safe.js");
+        module.exports.DEFAULT_SCHEMA = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_full.js");
+        module.exports.scan = deprecated('scan');
+        module.exports.parse = deprecated('parse');
+        module.exports.compose = deprecated('compose');
+        module.exports.addConstructor = deprecated('addConstructor');
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/common.js" (module) {
+        function isNothing(subject) {
+            return null == subject;
+        }
+        function isObject(subject) {
+            return 'object' == typeof subject && null !== subject;
+        }
+        function toArray(sequence) {
+            if (Array.isArray(sequence)) return sequence;
+            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];
+                }
+            }
+            return target;
+        }
+        function repeat(string, count) {
+            var result = '', cycle;
+            for(cycle = 0; cycle < count; cycle += 1)result += string;
+            return result;
+        }
+        function isNegativeZero(number) {
+            return 0 === number && -1 / 0 === 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;
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/dumper.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var common = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/common.js");
+        var YAMLException = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/exception.js");
+        var DEFAULT_FULL_SCHEMA = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_full.js");
+        var DEFAULT_SAFE_SCHEMA = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_safe.js");
+        var _toString = Object.prototype.toString;
+        var _hasOwnProperty = Object.prototype.hasOwnProperty;
+        var CHAR_TAB = 0x09;
+        var CHAR_LINE_FEED = 0x0A;
+        var CHAR_CARRIAGE_RETURN = 0x0D;
+        var CHAR_SPACE = 0x20;
+        var CHAR_EXCLAMATION = 0x21;
+        var CHAR_DOUBLE_QUOTE = 0x22;
+        var CHAR_SHARP = 0x23;
+        var CHAR_PERCENT = 0x25;
+        var CHAR_AMPERSAND = 0x26;
+        var CHAR_SINGLE_QUOTE = 0x27;
+        var CHAR_ASTERISK = 0x2A;
+        var CHAR_COMMA = 0x2C;
+        var CHAR_MINUS = 0x2D;
+        var CHAR_COLON = 0x3A;
+        var CHAR_EQUALS = 0x3D;
+        var CHAR_GREATER_THAN = 0x3E;
+        var CHAR_QUESTION = 0x3F;
+        var CHAR_COMMERCIAL_AT = 0x40;
+        var CHAR_LEFT_SQUARE_BRACKET = 0x5B;
+        var CHAR_RIGHT_SQUARE_BRACKET = 0x5D;
+        var CHAR_GRAVE_ACCENT = 0x60;
+        var CHAR_LEFT_CURLY_BRACKET = 0x7B;
+        var CHAR_VERTICAL_LINE = 0x7C;
+        var CHAR_RIGHT_CURLY_BRACKET = 0x7D;
+        var ESCAPE_SEQUENCES = {};
+        ESCAPE_SEQUENCES[0x00] = '\\0';
+        ESCAPE_SEQUENCES[0x07] = '\\a';
+        ESCAPE_SEQUENCES[0x08] = '\\b';
+        ESCAPE_SEQUENCES[0x09] = '\\t';
+        ESCAPE_SEQUENCES[0x0A] = '\\n';
+        ESCAPE_SEQUENCES[0x0B] = '\\v';
+        ESCAPE_SEQUENCES[0x0C] = '\\f';
+        ESCAPE_SEQUENCES[0x0D] = '\\r';
+        ESCAPE_SEQUENCES[0x1B] = '\\e';
+        ESCAPE_SEQUENCES[0x22] = '\\"';
+        ESCAPE_SEQUENCES[0x5C] = '\\\\';
+        ESCAPE_SEQUENCES[0x85] = '\\N';
+        ESCAPE_SEQUENCES[0xA0] = '\\_';
+        ESCAPE_SEQUENCES[0x2028] = '\\L';
+        ESCAPE_SEQUENCES[0x2029] = '\\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 (null === map) 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, handle, length;
+            string = character.toString(16).toUpperCase();
+            if (character <= 0xFF) {
+                handle = 'x';
+                length = 2;
+            } else if (character <= 0xFFFF) {
+                handle = 'u';
+                length = 4;
+            } else if (character <= 0xFFFFFFFF) {
+                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 (-1 === next) {
+                    line = string.slice(position);
+                    position = length;
+                } else {
+                    line = string.slice(position, next + 1);
+                    position = next + 1;
+                }
+                if (line.length && '\n' !== line) 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 0x00020 <= c && c <= 0x00007E || 0x000A1 <= c && c <= 0x00D7FF && 0x2028 !== c && 0x2029 !== c || 0x0E000 <= c && c <= 0x00FFFD && 0xFEFF !== c || 0x10000 <= c && c <= 0x10FFFF;
+        }
+        function isNsChar(c) {
+            return isPrintable(c) && !isWhitespace(c) && 0xFEFF !== c && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
+        }
+        function isPlainSafe(c, prev) {
+            return isPrintable(c) && 0xFEFF !== c && 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) && 0xFEFF !== c && !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) {
+            var leadingSpaceRe = /^\n* /;
+            return leadingSpaceRe.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 = -1 !== lineWidth;
+            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 (0 === string.length) return "''";
+                if (!state.noCompatMode && -1 !== DEPRECATED_BOOLEANS_SYNTAX.indexOf(string)) return "'" + string + "'";
+                var indent = state.indent * Math.max(1, level);
+                var lineWidth = -1 === state.lineWidth ? -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)){
+                    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 YAMLException('impossible error: invalid scalar style');
+                }
+            }();
+        }
+        function blockHeader(string, indentPerLevel) {
+            var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';
+            var clip = '\n' === string[string.length - 1];
+            var keep = clip && ('\n' === string[string.length - 2] || '\n' === string);
+            var chomp = keep ? '+' : clip ? '' : '-';
+            return indentIndicator + chomp + '\n';
+        }
+        function dropEndingNewline(string) {
+            return '\n' === string[string.length - 1] ? string.slice(0, -1) : string;
+        }
+        function foldString(string, width) {
+            var lineRe = /(\n+)([^\n]*)/g;
+            var result = function() {
+                var nextLF = string.indexOf('\n');
+                nextLF = -1 !== nextLF ? nextLF : string.length;
+                lineRe.lastIndex = nextLF;
+                return foldLine(string.slice(0, nextLF), width);
+            }();
+            var prevMoreIndented = '\n' === string[0] || ' ' === 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 >= 0xD800 && char <= 0xDBFF) {
+                    nextChar = string.charCodeAt(i + 1);
+                    if (nextChar >= 0xDC00 && nextChar <= 0xDFFF) {
+                        result += encodeHex((char - 0xD800) * 0x400 + nextChar - 0xDC00 + 0x10000);
+                        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 (0 !== index) _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 || 0 !== index) _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 (0 !== index) pairBuffer += ', ';
+                if (state.condenseFlow) pairBuffer += '"';
+                objectKey = objectKeyList[index];
+                objectValue = object[objectKey];
+                if (writeNode(state, level, objectKey, false, false)) {
+                    if (state.dump.length > 1024) pairBuffer += '? ';
+                    pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ');
+                    if (writeNode(state, level, objectValue, false, false)) {
+                        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 (true === state.sortKeys) objectKeyList.sort();
+            else if ('function' == typeof state.sortKeys) 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 || 0 !== index) pairBuffer += generateNextLine(state, level);
+                objectKey = objectKeyList[index];
+                objectValue = object[objectKey];
+                if (writeNode(state, level + 1, objectKey, true, true, true)) {
+                    explicitPair = null !== state.tag && '?' !== 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)) {
+                        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, index, length, type, style;
+            typeList = explicit ? state.explicitTypes : state.implicitTypes;
+            for(index = 0, length = typeList.length; index < length; index += 1){
+                type = typeList[index];
+                if ((type.instanceOf || type.predicate) && (!type.instanceOf || 'object' == typeof 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 ('[object Function]' === _toString.call(type.represent)) _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 = '[object Object]' === type || '[object Array]' === type, duplicateIndex, duplicate;
+            if (objectOrArray) {
+                duplicateIndex = state.duplicates.indexOf(object);
+                duplicate = -1 !== duplicateIndex;
+            }
+            if (null !== state.tag && '?' !== state.tag || duplicate || 2 !== state.indent && 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 ('[object Object]' === type) if (block && 0 !== Object.keys(state.dump).length) {
+                    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 ('[object Array]' === type) {
+                    var arrayLevel = state.noArrayIndent && level > 0 ? level - 1 : level;
+                    if (block && 0 !== state.dump.length) {
+                        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 ('[object String]' === type) {
+                    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 (null !== state.tag && '?' !== 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 (null !== object && 'object' == typeof object) {
+                index = objects.indexOf(object);
+                if (-1 !== index) {
+                    if (-1 === duplicatesIndexes.indexOf(index)) 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;
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/exception.js" (module) {
+        function YAMLException(reason, mark) {
+            Error.call(this);
+            this.name = 'YAMLException';
+            this.reason = reason;
+            this.mark = mark;
+            this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : '');
+            if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+            else this.stack = new Error().stack || '';
+        }
+        YAMLException.prototype = Object.create(Error.prototype);
+        YAMLException.prototype.constructor = YAMLException;
+        YAMLException.prototype.toString = function(compact) {
+            var result = this.name + ': ';
+            result += this.reason || '(unknown reason)';
+            if (!compact && this.mark) result += ' ' + this.mark.toString();
+            return result;
+        };
+        module.exports = YAMLException;
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/loader.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var common = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/common.js");
+        var YAMLException = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/exception.js");
+        var Mark = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/mark.js");
+        var DEFAULT_SAFE_SCHEMA = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_safe.js");
+        var DEFAULT_FULL_SCHEMA = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_full.js");
+        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 = /^(?:!|!!|![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 0x0A === c || 0x0D === c;
+        }
+        function is_WHITE_SPACE(c) {
+            return 0x09 === c || 0x20 === c;
+        }
+        function is_WS_OR_EOL(c) {
+            return 0x09 === c || 0x20 === c || 0x0A === c || 0x0D === c;
+        }
+        function is_FLOW_INDICATOR(c) {
+            return 0x2C === c || 0x5B === c || 0x5D === c || 0x7B === c || 0x7D === c;
+        }
+        function fromHexCode(c) {
+            var lc;
+            if (0x30 <= c && c <= 0x39) return c - 0x30;
+            lc = 0x20 | c;
+            if (0x61 <= lc && lc <= 0x66) return lc - 0x61 + 10;
+            return -1;
+        }
+        function escapedHexLen(c) {
+            if (0x78 === c) return 2;
+            if (0x75 === c) return 4;
+            if (0x55 === c) return 8;
+            return 0;
+        }
+        function fromDecimalCode(c) {
+            if (0x30 <= c && c <= 0x39) return c - 0x30;
+            return -1;
+        }
+        function simpleEscapeSequence(c) {
+            return 0x30 === c ? '\x00' : 0x61 === c ? '\x07' : 0x62 === c ? '\x08' : 0x74 === c ? '\x09' : 0x09 === c ? '\x09' : 0x6E === c ? '\x0A' : 0x76 === c ? '\x0B' : 0x66 === c ? '\x0C' : 0x72 === c ? '\x0D' : 0x65 === c ? '\x1B' : 0x20 === c ? ' ' : 0x22 === c ? '\x22' : 0x2F === c ? '/' : 0x5C === c ? '\x5C' : 0x4E === c ? '\x85' : 0x5F === c ? '\xA0' : 0x4C === c ? '\u2028' : 0x50 === c ? '\u2029' : '';
+        }
+        function charFromCodepoint(c) {
+            if (c <= 0xFFFF) return String.fromCharCode(c);
+            return String.fromCharCode((c - 0x010000 >> 10) + 0xD800, (c - 0x010000 & 0x03FF) + 0xDC00);
+        }
+        function setProperty(object, key, value) {
+            if ('__proto__' === key) Object.defineProperty(object, key, {
+                configurable: true,
+                enumerable: true,
+                writable: true,
+                value: value
+            });
+            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(input, options) {
+            this.input = input;
+            this.filename = options['filename'] || null;
+            this.schema = options['schema'] || DEFAULT_FULL_SCHEMA;
+            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.documents = [];
+        }
+        function generateError(state, message) {
+            return new YAMLException(message, new Mark(state.filename, state.input, state.position, state.line, state.position - state.lineStart));
+        }
+        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(state, name, args) {
+                var match, major, minor;
+                if (null !== state.version) throwError(state, 'duplication of %YAML directive');
+                if (1 !== args.length) throwError(state, 'YAML directive accepts exactly one argument');
+                match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+                if (null === match) throwError(state, 'ill-formed argument of the YAML directive');
+                major = parseInt(match[1], 10);
+                minor = parseInt(match[2], 10);
+                if (1 !== major) throwError(state, 'unacceptable YAML version of the document');
+                state.version = args[0];
+                state.checkLineBreaks = minor < 2;
+                if (1 !== minor && 2 !== minor) throwWarning(state, 'unsupported YAML version of the document');
+            },
+            TAG: function(state, name, args) {
+                var handle, prefix;
+                if (2 !== args.length) 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.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');
+                state.tagMap[handle] = prefix;
+            }
+        };
+        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 (!(0x09 === _character || 0x20 <= _character && _character <= 0x10FFFF)) 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.call(destination, key)) {
+                    setProperty(destination, key, source[key]);
+                    overridableKeys[key] = true;
+                }
+            }
+        }
+        function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, 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 ('object' == typeof keyNode && '[object Object]' === _class(keyNode[index])) keyNode[index] = '[object Object]';
+                }
+            }
+            if ('object' == typeof keyNode && '[object Object]' === _class(keyNode)) keyNode = '[object Object]';
+            keyNode = String(keyNode);
+            if (null === _result) _result = {};
+            if ('tag:yaml.org,2002:merge' === keyTag) 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.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) {
+                    state.line = startLine || state.line;
+                    state.position = startPos || state.position;
+                    throwError(state, 'duplicated mapping key');
+                }
+                setProperty(_result, keyNode, valueNode);
+                delete overridableKeys[keyNode];
+            }
+            return _result;
+        }
+        function readLineBreak(state) {
+            var ch;
+            ch = state.input.charCodeAt(state.position);
+            if (0x0A === ch) state.position++;
+            else if (0x0D === ch) {
+                state.position++;
+                if (0x0A === state.input.charCodeAt(state.position)) state.position++;
+            } else throwError(state, 'a line break is expected');
+            state.line += 1;
+            state.lineStart = state.position;
+        }
+        function skipSeparationSpace(state, allowComments, checkIndent) {
+            var lineBreaks = 0, ch = state.input.charCodeAt(state.position);
+            while(0 !== ch){
+                while(is_WHITE_SPACE(ch))ch = state.input.charCodeAt(++state.position);
+                if (allowComments && 0x23 === ch) do ch = state.input.charCodeAt(++state.position);
+                while (0x0A !== ch && 0x0D !== ch && 0 !== ch);
+                if (is_EOL(ch)) {
+                    readLineBreak(state);
+                    ch = state.input.charCodeAt(state.position);
+                    lineBreaks++;
+                    state.lineIndent = 0;
+                    while(0x20 === ch){
+                        state.lineIndent++;
+                        ch = state.input.charCodeAt(++state.position);
+                    }
+                } else break;
+            }
+            if (-1 !== checkIndent && 0 !== lineBreaks && state.lineIndent < checkIndent) throwWarning(state, 'deficient indentation');
+            return lineBreaks;
+        }
+        function testDocumentSeparator(state) {
+            var _position = state.position, ch;
+            ch = state.input.charCodeAt(_position);
+            if ((0x2D === ch || 0x2E === ch) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
+                _position += 3;
+                ch = state.input.charCodeAt(_position);
+                if (0 === ch || is_WS_OR_EOL(ch)) return true;
+            }
+            return false;
+        }
+        function writeFoldedLines(state, count) {
+            if (1 === count) 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;
+            ch = state.input.charCodeAt(state.position);
+            if (is_WS_OR_EOL(ch) || is_FLOW_INDICATOR(ch) || 0x23 === ch || 0x26 === ch || 0x2A === ch || 0x21 === ch || 0x7C === ch || 0x3E === ch || 0x27 === ch || 0x22 === ch || 0x25 === ch || 0x40 === ch || 0x60 === ch) return false;
+            if (0x3F === ch || 0x2D === ch) {
+                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(0 !== ch){
+                if (0x3A === ch) {
+                    following = state.input.charCodeAt(state.position + 1);
+                    if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) break;
+                } else if (0x23 === ch) {
+                    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;
+                    }
+                    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 (!is_WHITE_SPACE(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) {
+            var ch, captureStart, captureEnd;
+            ch = state.input.charCodeAt(state.position);
+            if (0x27 !== ch) return false;
+            state.kind = 'scalar';
+            state.result = '';
+            state.position++;
+            captureStart = captureEnd = state.position;
+            while(0 !== (ch = state.input.charCodeAt(state.position)))if (0x27 === ch) {
+                captureSegment(state, captureStart, state.position, true);
+                ch = state.input.charCodeAt(++state.position);
+                if (0x27 !== ch) return true;
+                captureStart = state.position;
+                state.position++;
+                captureEnd = state.position;
+            } 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;
+            ch = state.input.charCodeAt(state.position);
+            if (0x22 !== ch) return false;
+            state.kind = 'scalar';
+            state.result = '';
+            state.position++;
+            captureStart = captureEnd = state.position;
+            while(0 !== (ch = state.input.charCodeAt(state.position)))if (0x22 === ch) {
+                captureSegment(state, captureStart, state.position, true);
+                state.position++;
+                return true;
+            } else if (0x5C === ch) {
+                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--){
+                        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 (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 double quoted scalar');
+            else {
+                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, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = {}, keyNode, keyTag, valueNode, ch;
+            ch = state.input.charCodeAt(state.position);
+            if (0x5B === ch) {
+                terminator = 0x5D;
+                isMapping = false;
+                _result = [];
+            } else {
+                if (0x7B !== ch) return false;
+                terminator = 0x7D;
+                isMapping = true;
+                _result = {};
+            }
+            if (null !== state.anchor) state.anchorMap[state.anchor] = _result;
+            ch = state.input.charCodeAt(++state.position);
+            while(0 !== ch){
+                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;
+                }
+                if (!readNext) throwError(state, 'missed comma between flow collection entries');
+                keyTag = keyNode = valueNode = null;
+                isPair = isExplicitPair = false;
+                if (0x3F === ch) {
+                    following = state.input.charCodeAt(state.position + 1);
+                    if (is_WS_OR_EOL(following)) {
+                        isPair = isExplicitPair = true;
+                        state.position++;
+                        skipSeparationSpace(state, true, nodeIndent);
+                    }
+                }
+                _line = state.line;
+                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) && 0x3A === ch) {
+                    isPair = true;
+                    ch = state.input.charCodeAt(++state.position);
+                    skipSeparationSpace(state, true, nodeIndent);
+                    composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+                    valueNode = state.result;
+                }
+                if (isMapping) storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode);
+                else if (isPair) _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode));
+                else _result.push(keyNode);
+                skipSeparationSpace(state, true, nodeIndent);
+                ch = state.input.charCodeAt(state.position);
+                if (0x2C === ch) {
+                    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;
+            ch = state.input.charCodeAt(state.position);
+            if (0x7C === ch) folding = false;
+            else {
+                if (0x3E !== ch) return false;
+                folding = true;
+            }
+            state.kind = 'scalar';
+            state.result = '';
+            while(0 !== ch){
+                ch = state.input.charCodeAt(++state.position);
+                if (0x2B === ch || 0x2D === ch) if (CHOMPING_CLIP === chomping) chomping = 0x2B === ch ? CHOMPING_KEEP : CHOMPING_STRIP;
+                else throwError(state, 'repeat of a chomping mode identifier');
+                else if ((tmp = fromDecimalCode(ch)) >= 0) if (0 === tmp) throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
+                else if (detectedIndent) throwError(state, 'repeat of an indentation width identifier');
+                else {
+                    textIndent = nodeIndent + tmp - 1;
+                    detectedIndent = true;
+                }
+                else break;
+            }
+            if (is_WHITE_SPACE(ch)) {
+                do ch = state.input.charCodeAt(++state.position);
+                while (is_WHITE_SPACE(ch));
+                if (0x23 === ch) do ch = state.input.charCodeAt(++state.position);
+                while (!is_EOL(ch) && 0 !== ch);
+            }
+            while(0 !== ch){
+                readLineBreak(state);
+                state.lineIndent = 0;
+                ch = state.input.charCodeAt(state.position);
+                while((!detectedIndent || state.lineIndent < textIndent) && 0x20 === ch){
+                    state.lineIndent++;
+                    ch = state.input.charCodeAt(++state.position);
+                }
+                if (!detectedIndent && state.lineIndent > textIndent) textIndent = state.lineIndent;
+                if (is_EOL(ch)) {
+                    emptyLines++;
+                    continue;
+                }
+                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 (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 (0 === emptyLines) {
+                    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) && 0 !== ch)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 (null !== state.anchor) state.anchorMap[state.anchor] = _result;
+            ch = state.input.charCodeAt(state.position);
+            while(0 !== ch){
+                if (0x2D !== ch) 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);
+                        continue;
+                    }
+                }
+                _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) && 0 !== ch) 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, _pos, _tag = state.tag, _anchor = state.anchor, _result = {}, overridableKeys = {}, keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch;
+            if (null !== state.anchor) state.anchorMap[state.anchor] = _result;
+            ch = state.input.charCodeAt(state.position);
+            while(0 !== ch){
+                following = state.input.charCodeAt(state.position + 1);
+                _line = state.line;
+                _pos = state.position;
+                if ((0x3F === ch || 0x3A === ch) && is_WS_OR_EOL(following)) {
+                    if (0x3F === ch) {
+                        if (atExplicitKey) {
+                            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
+                            keyTag = keyNode = valueNode = null;
+                        }
+                        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 if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) if (state.line === _line) {
+                    ch = state.input.charCodeAt(state.position);
+                    while(is_WHITE_SPACE(ch))ch = state.input.charCodeAt(++state.position);
+                    if (0x3A === ch) {
+                        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');
+                        if (atExplicitKey) {
+                            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
+                            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 break;
+                if (state.line === _line || state.lineIndent > nodeIndent) {
+                    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, _line, _pos);
+                        keyTag = keyNode = valueNode = null;
+                    }
+                    skipSeparationSpace(state, true, -1);
+                    ch = state.input.charCodeAt(state.position);
+                }
+                if (state.lineIndent > nodeIndent && 0 !== ch) throwError(state, 'bad indentation of a mapping entry');
+                else if (state.lineIndent < nodeIndent) break;
+            }
+            if (atExplicitKey) storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
+            if (detected) {
+                state.tag = _tag;
+                state.anchor = _anchor;
+                state.kind = 'mapping';
+                state.result = _result;
+            }
+            return detected;
+        }
+        function readTagProperty(state) {
+            var _position, isVerbatim = false, isNamed = false, tagHandle, tagName, ch;
+            ch = state.input.charCodeAt(state.position);
+            if (0x21 !== ch) return false;
+            if (null !== state.tag) throwError(state, 'duplication of a tag property');
+            ch = state.input.charCodeAt(++state.position);
+            if (0x3C === ch) {
+                isVerbatim = true;
+                ch = state.input.charCodeAt(++state.position);
+            } else if (0x21 === ch) {
+                isNamed = true;
+                tagHandle = '!!';
+                ch = state.input.charCodeAt(++state.position);
+            } else tagHandle = '!';
+            _position = state.position;
+            if (isVerbatim) {
+                do ch = state.input.charCodeAt(++state.position);
+                while (0 !== ch && 0x3E !== ch);
+                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(0 !== ch && !is_WS_OR_EOL(ch)){
+                    if (0x21 === ch) if (isNamed) throwError(state, 'tag suffix cannot contain exclamation marks');
+                    else {
+                        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;
+                    }
+                    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);
+            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;
+        }
+        function readAnchorProperty(state) {
+            var _position, ch;
+            ch = state.input.charCodeAt(state.position);
+            if (0x26 !== ch) return false;
+            if (null !== state.anchor) throwError(state, 'duplication of an anchor property');
+            ch = state.input.charCodeAt(++state.position);
+            _position = state.position;
+            while(0 !== ch && !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;
+            ch = state.input.charCodeAt(state.position);
+            if (0x2A !== ch) return false;
+            ch = state.input.charCodeAt(++state.position);
+            _position = state.position;
+            while(0 !== ch && !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.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, type, flowIndent, blockIndent;
+            if (null !== state.listener) 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 (1 === indentStatus) 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 (1 === indentStatus || CONTEXT_BLOCK_OUT === nodeContext) {
+                flowIndent = CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext ? parentIndent : parentIndent + 1;
+                blockIndent = state.position - state.lineStart;
+                if (1 === indentStatus) 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 (null !== state.tag || null !== state.anchor) throwError(state, 'alias node should not have any properties');
+                    } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
+                        hasContent = true;
+                        if (null === state.tag) state.tag = '?';
+                    }
+                    if (null !== state.anchor) state.anchorMap[state.anchor] = state.result;
+                }
+                else if (0 === indentStatus) hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
+            }
+            if (null !== state.tag && '!' !== state.tag) if ('?' === state.tag) {
+                if (null !== state.result && 'scalar' !== state.kind) 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 (null !== state.anchor) state.anchorMap[state.anchor] = state.result;
+                        break;
+                    }
+                }
+            } else if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
+                type = state.typeMap[state.kind || 'fallback'][state.tag];
+                if (null !== state.result && 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.result = type.construct(state.result);
+                    if (null !== state.anchor) state.anchorMap[state.anchor] = state.result;
+                } else throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
+            } else throwError(state, 'unknown tag !<' + state.tag + '>');
+            if (null !== state.listener) state.listener('close', state);
+            return null !== state.tag || null !== state.anchor || hasContent;
+        }
+        function readDocument(state) {
+            var documentStart = state.position, _position, directiveName, directiveArgs, hasDirectives = false, ch;
+            state.version = null;
+            state.checkLineBreaks = state.legacy;
+            state.tagMap = {};
+            state.anchorMap = {};
+            while(0 !== (ch = state.input.charCodeAt(state.position))){
+                skipSeparationSpace(state, true, -1);
+                ch = state.input.charCodeAt(state.position);
+                if (state.lineIndent > 0 || 0x25 !== ch) break;
+                hasDirectives = true;
+                ch = state.input.charCodeAt(++state.position);
+                _position = state.position;
+                while(0 !== ch && !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(0 !== ch){
+                    while(is_WHITE_SPACE(ch))ch = state.input.charCodeAt(++state.position);
+                    if (0x23 === ch) {
+                        do ch = state.input.charCodeAt(++state.position);
+                        while (0 !== ch && !is_EOL(ch));
+                        break;
+                    }
+                    if (is_EOL(ch)) break;
+                    _position = state.position;
+                    while(0 !== ch && !is_WS_OR_EOL(ch))ch = state.input.charCodeAt(++state.position);
+                    directiveArgs.push(state.input.slice(_position, state.position));
+                }
+                if (0 !== ch) readLineBreak(state);
+                if (_hasOwnProperty.call(directiveHandlers, directiveName)) directiveHandlers[directiveName](state, directiveName, directiveArgs);
+                else throwWarning(state, 'unknown document directive "' + directiveName + '"');
+            }
+            skipSeparationSpace(state, true, -1);
+            if (0 === state.lineIndent && 0x2D === state.input.charCodeAt(state.position) && 0x2D === state.input.charCodeAt(state.position + 1) && 0x2D === state.input.charCodeAt(state.position + 2)) {
+                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 (0x2E === state.input.charCodeAt(state.position)) {
+                    state.position += 3;
+                    skipSeparationSpace(state, true, -1);
+                }
+                return;
+            }
+            if (!(state.position < state.length - 1)) return;
+            throwError(state, 'end of the stream or a document separator is expected');
+        }
+        function loadDocuments(input, options) {
+            input = String(input);
+            options = options || {};
+            if (0 !== input.length) {
+                if (0x0A !== input.charCodeAt(input.length - 1) && 0x0D !== input.charCodeAt(input.length - 1)) input += '\n';
+                if (0xFEFF === input.charCodeAt(0)) input = input.slice(1);
+            }
+            var state = new State(input, options);
+            var nullpos = input.indexOf('\0');
+            if (-1 !== nullpos) {
+                state.position = nullpos;
+                throwError(state, 'null byte is not allowed in input');
+            }
+            state.input += '\0';
+            while(0x20 === state.input.charCodeAt(state.position)){
+                state.lineIndent += 1;
+                state.position += 1;
+            }
+            while(state.position < state.length - 1)readDocument(state);
+            return state.documents;
+        }
+        function loadAll(input, iterator, options) {
+            if (null !== iterator && 'object' == typeof iterator && void 0 === options) {
+                options = iterator;
+                iterator = null;
+            }
+            var documents = loadDocuments(input, options);
+            if ('function' != typeof iterator) return documents;
+            for(var index = 0, length = documents.length; index < length; index += 1)iterator(documents[index]);
+        }
+        function load(input, options) {
+            var documents = loadDocuments(input, options);
+            if (0 === documents.length) return;
+            if (1 === documents.length) return documents[0];
+            throw new YAMLException('expected a single document in the stream, but found more');
+        }
+        function safeLoadAll(input, iterator, options) {
+            if ('object' == typeof iterator && null !== iterator && void 0 === options) {
+                options = iterator;
+                iterator = null;
+            }
+            return loadAll(input, iterator, common.extend({
+                schema: DEFAULT_SAFE_SCHEMA
+            }, options));
+        }
+        function safeLoad(input, options) {
+            return load(input, common.extend({
+                schema: DEFAULT_SAFE_SCHEMA
+            }, options));
+        }
+        module.exports.loadAll = loadAll;
+        module.exports.load = load;
+        module.exports.safeLoadAll = safeLoadAll;
+        module.exports.safeLoad = safeLoad;
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/mark.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var common = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/common.js");
+        function Mark(name, buffer, position, line, column) {
+            this.name = name;
+            this.buffer = buffer;
+            this.position = position;
+            this.line = line;
+            this.column = column;
+        }
+        Mark.prototype.getSnippet = function(indent, maxLength) {
+            var head, start, tail, end, snippet;
+            if (!this.buffer) return null;
+            indent = indent || 4;
+            maxLength = maxLength || 75;
+            head = '';
+            start = this.position;
+            while(start > 0 && -1 === '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1))){
+                start -= 1;
+                if (this.position - start > maxLength / 2 - 1) {
+                    head = ' ... ';
+                    start += 5;
+                    break;
+                }
+            }
+            tail = '';
+            end = this.position;
+            while(end < this.buffer.length && -1 === '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end))){
+                end += 1;
+                if (end - this.position > maxLength / 2 - 1) {
+                    tail = ' ... ';
+                    end -= 5;
+                    break;
+                }
+            }
+            snippet = this.buffer.slice(start, end);
+            return common.repeat(' ', indent) + head + snippet + tail + '\n' + common.repeat(' ', indent + this.position - start + head.length) + '^';
+        };
+        Mark.prototype.toString = function(compact) {
+            var snippet, where = '';
+            if (this.name) where += 'in "' + this.name + '" ';
+            where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1);
+            if (!compact) {
+                snippet = this.getSnippet();
+                if (snippet) where += ':\n' + snippet;
+            }
+            return where;
+        };
+        module.exports = Mark;
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var common = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/common.js");
+        var YAMLException = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/exception.js");
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        function compileList(schema, name, result) {
+            var exclude = [];
+            schema.include.forEach(function(includedSchema) {
+                result = compileList(includedSchema, name, result);
+            });
+            schema[name].forEach(function(currentType) {
+                result.forEach(function(previousType, previousIndex) {
+                    if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) exclude.push(previousIndex);
+                });
+                result.push(currentType);
+            });
+            return result.filter(function(type, index) {
+                return -1 === exclude.indexOf(index);
+            });
+        }
+        function compileMap() {
+            var result = {
+                scalar: {},
+                sequence: {},
+                mapping: {},
+                fallback: {}
+            }, index, length;
+            function collectType(type) {
+                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(definition) {
+            this.include = definition.include || [];
+            this.implicit = definition.implicit || [];
+            this.explicit = definition.explicit || [];
+            this.implicit.forEach(function(type) {
+                if (type.loadKind && 'scalar' !== type.loadKind) throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
+            });
+            this.compiledImplicit = compileList(this, 'implicit', []);
+            this.compiledExplicit = compileList(this, 'explicit', []);
+            this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit);
+        }
+        Schema.DEFAULT = null;
+        Schema.create = function() {
+            var schemas, types;
+            switch(arguments.length){
+                case 1:
+                    schemas = Schema.DEFAULT;
+                    types = arguments[0];
+                    break;
+                case 2:
+                    schemas = arguments[0];
+                    types = arguments[1];
+                    break;
+                default:
+                    throw new YAMLException('Wrong number of arguments for Schema.create function');
+            }
+            schemas = common.toArray(schemas);
+            types = common.toArray(types);
+            if (!schemas.every(function(schema) {
+                return schema instanceof Schema;
+            })) throw new YAMLException('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');
+            if (!types.every(function(type) {
+                return type instanceof Type;
+            })) throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');
+            return new Schema({
+                include: schemas,
+                explicit: types
+            });
+        };
+        module.exports = Schema;
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/core.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Schema = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema.js");
+        module.exports = new Schema({
+            include: [
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/json.js")
+            ]
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_full.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Schema = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema.js");
+        module.exports = Schema.DEFAULT = new Schema({
+            include: [
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_safe.js")
+            ],
+            explicit: [
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/js/undefined.js"),
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/js/regexp.js"),
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/js/function.js")
+            ]
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_safe.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Schema = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema.js");
+        module.exports = new Schema({
+            include: [
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/core.js")
+            ],
+            implicit: [
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/timestamp.js"),
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/merge.js")
+            ],
+            explicit: [
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/binary.js"),
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/omap.js"),
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/pairs.js"),
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/set.js")
+            ]
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/failsafe.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Schema = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema.js");
+        module.exports = new Schema({
+            explicit: [
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/str.js"),
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/seq.js"),
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/map.js")
+            ]
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/json.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Schema = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema.js");
+        module.exports = new Schema({
+            include: [
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/failsafe.js")
+            ],
+            implicit: [
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/null.js"),
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/bool.js"),
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/int.js"),
+                __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/float.js")
+            ]
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var YAMLException = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/exception.js");
+        var TYPE_CONSTRUCTOR_OPTIONS = [
+            'kind',
+            'resolve',
+            'construct',
+            'instanceOf',
+            'predicate',
+            'represent',
+            'defaultStyle',
+            'styleAliases'
+        ];
+        var YAML_NODE_KINDS = [
+            'scalar',
+            'sequence',
+            'mapping'
+        ];
+        function compileStyleAliases(map) {
+            var result = {};
+            if (null !== map) Object.keys(map).forEach(function(style) {
+                map[style].forEach(function(alias) {
+                    result[String(alias)] = style;
+                });
+            });
+            return result;
+        }
+        function Type(tag, options) {
+            options = options || {};
+            Object.keys(options).forEach(function(name) {
+                if (-1 === TYPE_CONSTRUCTOR_OPTIONS.indexOf(name)) throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
+            });
+            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.defaultStyle = options['defaultStyle'] || null;
+            this.styleAliases = compileStyleAliases(options['styleAliases'] || null);
+            if (-1 === YAML_NODE_KINDS.indexOf(this.kind)) throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
+        }
+        module.exports = Type;
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/binary.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var NodeBuffer;
+        try {
+            var _require = require;
+            NodeBuffer = _require('buffer').Buffer;
+        } catch (__) {}
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';
+        function resolveYamlBinary(data) {
+            if (null === data) 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)) {
+                    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) {
+                    result.push(bits >> 16 & 0xFF);
+                    result.push(bits >> 8 & 0xFF);
+                    result.push(0xFF & bits);
+                }
+                bits = bits << 6 | map.indexOf(input.charAt(idx));
+            }
+            tailbits = max % 4 * 6;
+            if (0 === tailbits) {
+                result.push(bits >> 16 & 0xFF);
+                result.push(bits >> 8 & 0xFF);
+                result.push(0xFF & bits);
+            } else if (18 === tailbits) {
+                result.push(bits >> 10 & 0xFF);
+                result.push(bits >> 2 & 0xFF);
+            } else if (12 === tailbits) result.push(bits >> 4 & 0xFF);
+            if (NodeBuffer) return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result);
+            return 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) {
+                    result += map[bits >> 18 & 0x3F];
+                    result += map[bits >> 12 & 0x3F];
+                    result += map[bits >> 6 & 0x3F];
+                    result += map[0x3F & bits];
+                }
+                bits = (bits << 8) + object[idx];
+            }
+            tail = max % 3;
+            if (0 === tail) {
+                result += map[bits >> 18 & 0x3F];
+                result += map[bits >> 12 & 0x3F];
+                result += map[bits >> 6 & 0x3F];
+                result += map[0x3F & bits];
+            } else if (2 === tail) {
+                result += map[bits >> 10 & 0x3F];
+                result += map[bits >> 4 & 0x3F];
+                result += map[bits << 2 & 0x3F];
+                result += map[64];
+            } else if (1 === tail) {
+                result += map[bits >> 2 & 0x3F];
+                result += map[bits << 4 & 0x3F];
+                result += map[64];
+                result += map[64];
+            }
+            return result;
+        }
+        function isBinary(object) {
+            return NodeBuffer && NodeBuffer.isBuffer(object);
+        }
+        module.exports = new Type('tag:yaml.org,2002:binary', {
+            kind: 'scalar',
+            resolve: resolveYamlBinary,
+            construct: constructYamlBinary,
+            predicate: isBinary,
+            represent: representYamlBinary
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/bool.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        function resolveYamlBoolean(data) {
+            if (null === data) return false;
+            var max = data.length;
+            return 4 === max && ('true' === data || 'True' === data || 'TRUE' === data) || 5 === max && ('false' === data || 'False' === data || 'FALSE' === data);
+        }
+        function constructYamlBoolean(data) {
+            return 'true' === data || 'True' === data || 'TRUE' === data;
+        }
+        function isBoolean(object) {
+            return '[object Boolean]' === Object.prototype.toString.call(object);
+        }
+        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';
+                }
+            },
+            defaultStyle: 'lowercase'
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/float.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var common = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/common.js");
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        var YAML_FLOAT_PATTERN = new RegExp("^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+        function resolveYamlFloat(data) {
+            if (null === data) return false;
+            if (!YAML_FLOAT_PATTERN.test(data) || '_' === data[data.length - 1]) return false;
+            return true;
+        }
+        function constructYamlFloat(data) {
+            var value, sign, base, digits;
+            value = data.replace(/_/g, '').toLowerCase();
+            sign = '-' === value[0] ? -1 : 1;
+            digits = [];
+            if ('+-'.indexOf(value[0]) >= 0) value = value.slice(1);
+            if ('.inf' === value) return 1 === sign ? 1 / 0 : -1 / 0;
+            if ('.nan' === value) return NaN;
+            if (value.indexOf(':') >= 0) {
+                value.split(':').forEach(function(v) {
+                    digits.unshift(parseFloat(v, 10));
+                });
+                value = 0.0;
+                base = 1;
+                digits.forEach(function(d) {
+                    value += d * base;
+                    base *= 60;
+                });
+                return sign * value;
+            }
+            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 (1 / 0 === object) switch(style){
+                case 'lowercase':
+                    return '.inf';
+                case 'uppercase':
+                    return '.INF';
+                case 'camelcase':
+                    return '.Inf';
+            }
+            else if (-1 / 0 === 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 Number]' === Object.prototype.toString.call(object) && (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'
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/int.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var common = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/common.js");
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        function isHexCode(c) {
+            return 0x30 <= c && c <= 0x39 || 0x41 <= c && c <= 0x46 || 0x61 <= c && c <= 0x66;
+        }
+        function isOctCode(c) {
+            return 0x30 <= c && c <= 0x37;
+        }
+        function isDecCode(c) {
+            return 0x30 <= c && c <= 0x39;
+        }
+        function resolveYamlInteger(data) {
+            if (null === data) 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 ('0' === ch) {
+                if (index + 1 === max) return true;
+                ch = data[++index];
+                if ('b' === ch) {
+                    index++;
+                    for(; index < max; index++){
+                        ch = data[index];
+                        if ('_' !== ch) {
+                            if ('0' !== ch && '1' !== ch) return false;
+                            hasDigits = true;
+                        }
+                    }
+                    return hasDigits && '_' !== ch;
+                }
+                if ('x' === ch) {
+                    index++;
+                    for(; index < max; index++){
+                        ch = data[index];
+                        if ('_' !== ch) {
+                            if (!isHexCode(data.charCodeAt(index))) return false;
+                            hasDigits = true;
+                        }
+                    }
+                    return hasDigits && '_' !== ch;
+                }
+                for(; index < max; index++){
+                    ch = data[index];
+                    if ('_' !== ch) {
+                        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) {
+                    if (':' === ch) break;
+                    if (!isDecCode(data.charCodeAt(index))) return false;
+                    hasDigits = true;
+                }
+            }
+            if (!hasDigits || '_' === ch) return false;
+            if (':' !== ch) return true;
+            return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
+        }
+        function constructYamlInteger(data) {
+            var value = data, sign = 1, ch, base, digits = [];
+            if (-1 !== value.indexOf('_')) value = value.replace(/_/g, '');
+            ch = value[0];
+            if ('-' === ch || '+' === ch) {
+                if ('-' === ch) sign = -1;
+                value = value.slice(1);
+                ch = value[0];
+            }
+            if ('0' === value) return 0;
+            if ('0' === ch) {
+                if ('b' === value[1]) return sign * parseInt(value.slice(2), 2);
+                if ('x' === value[1]) return sign * parseInt(value, 16);
+                return sign * parseInt(value, 8);
+            }
+            if (-1 !== value.indexOf(':')) {
+                value.split(':').forEach(function(v) {
+                    digits.unshift(parseInt(v, 10));
+                });
+                value = 0;
+                base = 1;
+                digits.forEach(function(d) {
+                    value += d * base;
+                    base *= 60;
+                });
+                return sign * value;
+            }
+            return sign * parseInt(value, 10);
+        }
+        function isInteger(object) {
+            return '[object Number]' === Object.prototype.toString.call(object) && 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 ? '0' + obj.toString(8) : '-0' + 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);
+                }
+            },
+            defaultStyle: 'decimal',
+            styleAliases: {
+                binary: [
+                    2,
+                    'bin'
+                ],
+                octal: [
+                    8,
+                    'oct'
+                ],
+                decimal: [
+                    10,
+                    'dec'
+                ],
+                hexadecimal: [
+                    16,
+                    'hex'
+                ]
+            }
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/js/function.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var esprima;
+        try {
+            var _require = require;
+            esprima = _require('esprima');
+        } catch (_) {
+            if ("u" > typeof window) esprima = window.esprima;
+        }
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        function resolveJavascriptFunction(data) {
+            if (null === data) return false;
+            try {
+                var source = '(' + data + ')', ast = esprima.parse(source, {
+                    range: true
+                });
+                if ('Program' !== ast.type || 1 !== ast.body.length || 'ExpressionStatement' !== ast.body[0].type || 'ArrowFunctionExpression' !== ast.body[0].expression.type && 'FunctionExpression' !== ast.body[0].expression.type) return false;
+                return true;
+            } catch (err) {
+                return false;
+            }
+        }
+        function constructJavascriptFunction(data) {
+            var source = '(' + data + ')', ast = esprima.parse(source, {
+                range: true
+            }), params = [], body;
+            if ('Program' !== ast.type || 1 !== ast.body.length || 'ExpressionStatement' !== ast.body[0].type || 'ArrowFunctionExpression' !== ast.body[0].expression.type && 'FunctionExpression' !== ast.body[0].expression.type) throw new Error('Failed to resolve function');
+            ast.body[0].expression.params.forEach(function(param) {
+                params.push(param.name);
+            });
+            body = ast.body[0].expression.body.range;
+            if ('BlockStatement' === ast.body[0].expression.body.type) return new Function(params, source.slice(body[0] + 1, body[1] - 1));
+            return new Function(params, 'return ' + source.slice(body[0], body[1]));
+        }
+        function representJavascriptFunction(object) {
+            return object.toString();
+        }
+        function isFunction(object) {
+            return '[object Function]' === Object.prototype.toString.call(object);
+        }
+        module.exports = new Type('tag:yaml.org,2002:js/function', {
+            kind: 'scalar',
+            resolve: resolveJavascriptFunction,
+            construct: constructJavascriptFunction,
+            predicate: isFunction,
+            represent: representJavascriptFunction
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/js/regexp.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        function resolveJavascriptRegExp(data) {
+            if (null === data) return false;
+            if (0 === data.length) return false;
+            var regexp = data, tail = /\/([gim]*)$/.exec(data), modifiers = '';
+            if ('/' === regexp[0]) {
+                if (tail) modifiers = tail[1];
+                if (modifiers.length > 3) return false;
+                if ('/' !== regexp[regexp.length - modifiers.length - 1]) return false;
+            }
+            return true;
+        }
+        function constructJavascriptRegExp(data) {
+            var regexp = data, tail = /\/([gim]*)$/.exec(data), modifiers = '';
+            if ('/' === regexp[0]) {
+                if (tail) modifiers = tail[1];
+                regexp = regexp.slice(1, regexp.length - modifiers.length - 1);
+            }
+            return new RegExp(regexp, modifiers);
+        }
+        function representJavascriptRegExp(object) {
+            var result = '/' + object.source + '/';
+            if (object.global) result += 'g';
+            if (object.multiline) result += 'm';
+            if (object.ignoreCase) result += 'i';
+            return result;
+        }
+        function isRegExp(object) {
+            return '[object RegExp]' === Object.prototype.toString.call(object);
+        }
+        module.exports = new Type('tag:yaml.org,2002:js/regexp', {
+            kind: 'scalar',
+            resolve: resolveJavascriptRegExp,
+            construct: constructJavascriptRegExp,
+            predicate: isRegExp,
+            represent: representJavascriptRegExp
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/js/undefined.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        function resolveJavascriptUndefined() {
+            return true;
+        }
+        function constructJavascriptUndefined() {}
+        function representJavascriptUndefined() {
+            return '';
+        }
+        function isUndefined(object) {
+            return void 0 === object;
+        }
+        module.exports = new Type('tag:yaml.org,2002:js/undefined', {
+            kind: 'scalar',
+            resolve: resolveJavascriptUndefined,
+            construct: constructJavascriptUndefined,
+            predicate: isUndefined,
+            represent: representJavascriptUndefined
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/map.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        module.exports = new Type('tag:yaml.org,2002:map', {
+            kind: 'mapping',
+            construct: function(data) {
+                return null !== data ? data : {};
+            }
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/merge.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        function resolveYamlMerge(data) {
+            return '<<' === data || null === data;
+        }
+        module.exports = new Type('tag:yaml.org,2002:merge', {
+            kind: 'scalar',
+            resolve: resolveYamlMerge
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/null.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        function resolveYamlNull(data) {
+            if (null === data) return true;
+            var max = data.length;
+            return 1 === max && '~' === data || 4 === max && ('null' === data || 'Null' === data || 'NULL' === data);
+        }
+        function constructYamlNull() {
+            return null;
+        }
+        function isNull(object) {
+            return null === object;
+        }
+        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';
+                }
+            },
+            defaultStyle: 'lowercase'
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/omap.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        var _hasOwnProperty = Object.prototype.hasOwnProperty;
+        var _toString = Object.prototype.toString;
+        function resolveYamlOmap(data) {
+            if (null === data) 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 ('[object Object]' !== _toString.call(pair)) return false;
+                for(pairKey in pair)if (_hasOwnProperty.call(pair, pairKey)) if (pairHasKey) return false;
+                else pairHasKey = true;
+                if (!pairHasKey) return false;
+                if (-1 !== objectKeys.indexOf(pairKey)) return false;
+                objectKeys.push(pairKey);
+            }
+            return true;
+        }
+        function constructYamlOmap(data) {
+            return null !== data ? data : [];
+        }
+        module.exports = new Type('tag:yaml.org,2002:omap', {
+            kind: 'sequence',
+            resolve: resolveYamlOmap,
+            construct: constructYamlOmap
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/pairs.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        var _toString = Object.prototype.toString;
+        function resolveYamlPairs(data) {
+            if (null === data) 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 ('[object Object]' !== _toString.call(pair)) return false;
+                keys = Object.keys(pair);
+                if (1 !== keys.length) return false;
+                result[index] = [
+                    keys[0],
+                    pair[keys[0]]
+                ];
+            }
+            return true;
+        }
+        function constructYamlPairs(data) {
+            if (null === data) 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]]
+                ];
+            }
+            return result;
+        }
+        module.exports = new Type('tag:yaml.org,2002:pairs', {
+            kind: 'sequence',
+            resolve: resolveYamlPairs,
+            construct: constructYamlPairs
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/seq.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        module.exports = new Type('tag:yaml.org,2002:seq', {
+            kind: 'sequence',
+            construct: function(data) {
+                return null !== data ? data : [];
+            }
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/set.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        var _hasOwnProperty = Object.prototype.hasOwnProperty;
+        function resolveYamlSet(data) {
+            if (null === data) return true;
+            var key, object = data;
+            for(key in object)if (_hasOwnProperty.call(object, key)) {
+                if (null !== object[key]) return false;
+            }
+            return true;
+        }
+        function constructYamlSet(data) {
+            return null !== data ? data : {};
+        }
+        module.exports = new Type('tag:yaml.org,2002:set', {
+            kind: 'mapping',
+            resolve: resolveYamlSet,
+            construct: constructYamlSet
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/str.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        module.exports = new Type('tag:yaml.org,2002:str', {
+            kind: 'scalar',
+            construct: function(data) {
+                return null !== data ? data : '';
+            }
+        });
+    },
+    "../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/timestamp.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Type = __webpack_require__("../../node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js");
+        var YAML_DATE_REGEXP = new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
+        var YAML_TIMESTAMP_REGEXP = 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 (null === data) return false;
+            if (null !== YAML_DATE_REGEXP.exec(data)) return true;
+            if (null !== YAML_TIMESTAMP_REGEXP.exec(data)) 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 (null === match) match = YAML_TIMESTAMP_REGEXP.exec(data);
+            if (null === match) 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 *= 1;
+            }
+            if (match[9]) {
+                tz_hour = +match[10];
+                tz_minute = +(match[11] || 0);
+                delta = (60 * tz_hour + tz_minute) * 60000;
+                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();
+        }
+        module.exports = new Type('tag:yaml.org,2002:timestamp', {
+            kind: 'scalar',
+            resolve: resolveYamlTimestamp,
+            construct: constructYamlTimestamp,
+            instanceOf: Date,
+            represent: representYamlTimestamp
+        });
+    },
+    "../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js" (module) {
+        var toString = Object.prototype.toString;
+        module.exports = function(val) {
+            if (void 0 === val) return 'undefined';
+            if (null === val) return 'null';
+            var type = typeof val;
+            if ('boolean' === type) return 'boolean';
+            if ('string' === type) return 'string';
+            if ('number' === type) return 'number';
+            if ('symbol' === type) return 'symbol';
+            if ('function' === type) return isGeneratorFn(val) ? 'generatorfunction' : 'function';
+            if (isArray(val)) return 'array';
+            if (isBuffer(val)) return 'buffer';
+            if (isArguments(val)) return 'arguments';
+            if (isDate(val)) return 'date';
+            if (isError(val)) return 'error';
+            if (isRegexp(val)) return 'regexp';
+            switch(ctorName(val)){
+                case 'Symbol':
+                    return 'symbol';
+                case 'Promise':
+                    return 'promise';
+                case 'WeakMap':
+                    return 'weakmap';
+                case 'WeakSet':
+                    return 'weakset';
+                case 'Map':
+                    return 'map';
+                case 'Set':
+                    return 'set';
+                case 'Int8Array':
+                    return 'int8array';
+                case 'Uint8Array':
+                    return 'uint8array';
+                case 'Uint8ClampedArray':
+                    return 'uint8clampedarray';
+                case 'Int16Array':
+                    return 'int16array';
+                case 'Uint16Array':
+                    return 'uint16array';
+                case 'Int32Array':
+                    return 'int32array';
+                case 'Uint32Array':
+                    return 'uint32array';
+                case 'Float32Array':
+                    return 'float32array';
+                case 'Float64Array':
+                    return 'float64array';
+            }
+            if (isGeneratorObj(val)) return 'generator';
+            type = toString.call(val);
+            switch(type){
+                case '[object Object]':
+                    return 'object';
+                case '[object Map Iterator]':
+                    return 'mapiterator';
+                case '[object Set Iterator]':
+                    return 'setiterator';
+                case '[object String Iterator]':
+                    return 'stringiterator';
+                case '[object Array Iterator]':
+                    return 'arrayiterator';
+            }
+            return type.slice(8, -1).toLowerCase().replace(/\s/g, '');
+        };
+        function ctorName(val) {
+            return 'function' == typeof val.constructor ? val.constructor.name : null;
+        }
+        function isArray(val) {
+            if (Array.isArray) return Array.isArray(val);
+            return val instanceof Array;
+        }
+        function isError(val) {
+            return val instanceof Error || 'string' == typeof val.message && val.constructor && 'number' == typeof val.constructor.stackTraceLimit;
+        }
+        function isDate(val) {
+            if (val instanceof Date) return true;
+            return 'function' == typeof val.toDateString && 'function' == typeof val.getDate && 'function' == typeof val.setDate;
+        }
+        function isRegexp(val) {
+            if (val instanceof RegExp) return true;
+            return 'string' == typeof val.flags && 'boolean' == typeof val.ignoreCase && 'boolean' == typeof val.multiline && 'boolean' == typeof val.global;
+        }
+        function isGeneratorFn(name, val) {
+            return 'GeneratorFunction' === ctorName(name);
+        }
+        function isGeneratorObj(val) {
+            return 'function' == typeof val.throw && 'function' == typeof val.return && 'function' == typeof val.next;
+        }
+        function isArguments(val) {
+            try {
+                if ('number' == typeof val.length && 'function' == typeof val.callee) return true;
+            } catch (err) {
+                if (-1 !== err.message.indexOf('callee')) return true;
+            }
+            return false;
+        }
+        function isBuffer(val) {
+            if (val.constructor && 'function' == typeof val.constructor.isBuffer) return val.constructor.isBuffer(val);
+            return false;
+        }
+    },
+    "../../node_modules/.pnpm/section-matter@1.0.0/node_modules/section-matter/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var typeOf = __webpack_require__("../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js");
+        var extend = __webpack_require__("../../node_modules/.pnpm/extend-shallow@2.0.1/node_modules/extend-shallow/index.js");
+        module.exports = function(input, options) {
+            if ('function' == typeof options) options = {
+                parse: options
+            };
+            var file = toObject(input);
+            var defaults = {
+                section_delimiter: '---',
+                parse: identity
+            };
+            var opts = extend({}, defaults, options);
+            var delim = opts.section_delimiter;
+            var lines = file.content.split(/\r?\n/);
+            var sections = null;
+            var section = createSection();
+            var content = [];
+            var stack = [];
+            function initSections(val) {
+                file.content = val;
+                sections = [];
+                content = [];
+            }
+            function closeSection(val) {
+                if (stack.length) {
+                    section.key = getKey(stack[0], delim);
+                    section.content = val;
+                    opts.parse(section, sections);
+                    sections.push(section);
+                    section = createSection();
+                    content = [];
+                    stack = [];
+                }
+            }
+            for(var i = 0; i < lines.length; i++){
+                var line = lines[i];
+                var len = stack.length;
+                var ln = line.trim();
+                if (isDelimiter(ln, delim)) {
+                    if (3 === ln.length && 0 !== i) {
+                        if (0 === len || 2 === len) {
+                            content.push(line);
+                            continue;
+                        }
+                        stack.push(ln);
+                        section.data = content.join('\n');
+                        content = [];
+                        continue;
+                    }
+                    if (null === sections) initSections(content.join('\n'));
+                    if (2 === len) closeSection(content.join('\n'));
+                    stack.push(ln);
+                    continue;
+                }
+                content.push(line);
+            }
+            if (null === sections) initSections(content.join('\n'));
+            else closeSection(content.join('\n'));
+            file.sections = sections;
+            return file;
+        };
+        function isDelimiter(line, delim) {
+            if (line.slice(0, delim.length) !== delim) return false;
+            if (line.charAt(delim.length + 1) === delim.slice(-1)) return false;
+            return true;
+        }
+        function toObject(input) {
+            if ('object' !== typeOf(input)) input = {
+                content: input
+            };
+            if ('string' != typeof input.content && !isBuffer(input.content)) throw new TypeError('expected a buffer or string');
+            input.content = input.content.toString();
+            input.sections = [];
+            return input;
+        }
+        function getKey(val, delim) {
+            return val ? val.slice(delim.length).trim() : '';
+        }
+        function createSection() {
+            return {
+                key: '',
+                data: '',
+                content: ''
+            };
+        }
+        function identity(val) {
+            return val;
+        }
+        function isBuffer(val) {
+            if (val && val.constructor && 'function' == typeof val.constructor.isBuffer) return val.constructor.isBuffer(val);
+            return false;
+        }
+    },
+    "../../node_modules/.pnpm/strip-bom-string@1.0.0/node_modules/strip-bom-string/index.js" (module) {
+        /*!
+ * strip-bom-string <https://github.com/jonschlinkert/strip-bom-string>
+ *
+ * Copyright (c) 2015, 2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */ module.exports = function(str) {
+            if ('string' == typeof str && '\ufeff' === str.charAt(0)) return str.slice(1);
+            return str;
+        };
+    },
+    fs (module) {
+        module.exports = __rspack_createRequire_require("fs");
+    }
+});
+const gray_matter = __webpack_require__("../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/index.js");
+var gray_matter_default = /*#__PURE__*/ __webpack_require__.n(gray_matter);
+function grayMatter(source, options) {
+    const result = gray_matter_default()(source, options);
+    return result;
+}
+const src_grayMatter = grayMatter;
+export default src_grayMatter;
+export { grayMatter };