From 920ea4bfb8055da9cb7b366cb324fc5683c5b08e Mon Sep 17 00:00:00 2001 From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com> Date: Mon, 22 Jun 2026 06:17:37 +0000 Subject: [PATCH 1/3] fix(deps): update dependency js-yaml to v5 --- .github/actions/core/package-lock.json | 10 +++++----- .github/actions/core/package.json | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/actions/core/package-lock.json b/.github/actions/core/package-lock.json index a13951f..1ad32a1 100644 --- a/.github/actions/core/package-lock.json +++ b/.github/actions/core/package-lock.json @@ -11,7 +11,7 @@ "@actions/core": "^3.0.0", "@actions/exec": "^3.0.0", "actions-toolkit": "^6.0.1", - "js-yaml": "^4.1.0", + "js-yaml": "^5.0.0", "mentions-regex": "^2.0.3", "parse-commit-message": "^5.0.4", "pom-parser": "^1.2.0", @@ -6497,9 +6497,9 @@ "dev": true }, "node_modules/js-yaml": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.2.0.tgz", - "integrity": "sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-5.0.0.tgz", + "integrity": "sha512-GSvaPUbk1U+FMZ7rJzF+F8e5YVtu7KnD40et/5rBXXRBv2jCO9L3qCewvIDDdudC0QycTFlf6EAA+h3kxBsuUw==", "funding": [ { "type": "github", @@ -6515,7 +6515,7 @@ "argparse": "^2.0.1" }, "bin": { - "js-yaml": "bin/js-yaml.js" + "js-yaml": "bin/js-yaml.mjs" } }, "node_modules/jsesc": { diff --git a/.github/actions/core/package.json b/.github/actions/core/package.json index 8578c64..95cccff 100644 --- a/.github/actions/core/package.json +++ b/.github/actions/core/package.json @@ -18,7 +18,7 @@ "pom-parser": "^1.2.0", "semver": "^7.7.4", "simple-git": "^3.36.0", - "js-yaml": "^4.1.0" + "js-yaml": "^5.0.0" }, "devDependencies": { "@types/jest": "^30.0.0", From 28facbb2968634b8c0122c71a670f27f0d9f7504 Mon Sep 17 00:00:00 2001 From: Rico Gu Date: Mon, 22 Jun 2026 08:18:17 +0200 Subject: [PATCH 2/3] fix: use named import from js-yaml v5 (no default export) --- .github/actions/core/src/version/fetch-version.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/actions/core/src/version/fetch-version.ts b/.github/actions/core/src/version/fetch-version.ts index a82e7da..f447725 100644 --- a/.github/actions/core/src/version/fetch-version.ts +++ b/.github/actions/core/src/version/fetch-version.ts @@ -3,7 +3,7 @@ import { BUILD_TYPE } from '../types/build-type.js'; import { getFileFromDefaultBranch } from '../git/git.js'; import { parsePom } from '../utils/pom.js'; import { fetchPomPath } from '../utils/file.js'; -import yaml from 'js-yaml'; +import { load } from 'js-yaml'; export async function fetchCurrentVersion( git: SimpleGit, @@ -43,7 +43,7 @@ export async function fetchCurrentVersion( case BUILD_TYPE.HELM: { const content = await getFileFromDefaultBranch(git, files.chart, defaultBranch); - const parsed = yaml.load(content) as Record; + const parsed = load(content) as Record; if (!parsed || !parsed.version) { throw new Error(`Version not found in ${files.chart}`); } From 2eb3fd4a2312dae13974d99874bfd8370aa99d89 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 22 Jun 2026 06:19:20 +0000 Subject: [PATCH 3/3] chore: build core action dist (auto) --- .github/actions/core/dist/index.js | 5194 ++++++++++++++++------------ 1 file changed, 2954 insertions(+), 2240 deletions(-) diff --git a/.github/actions/core/dist/index.js b/.github/actions/core/dist/index.js index d5f1e2a..7ac623e 100644 --- a/.github/actions/core/dist/index.js +++ b/.github/actions/core/dist/index.js @@ -55258,2384 +55258,3098 @@ function fetchPomPath(obj, path) { } ;// CONCATENATED MODULE: ./node_modules/js-yaml/dist/js-yaml.mjs -/*! js-yaml 4.2.0 https://github.com/nodeca/js-yaml @license MIT */ -//#region \0rolldown/runtime.js -var __create = Object.create; -var js_yaml_defProp = Object.defineProperty; -var js_yaml_getOwnPropDesc = Object.getOwnPropertyDescriptor; -var js_yaml_getOwnPropNames = Object.getOwnPropertyNames; -var __getProtoOf = Object.getPrototypeOf; -var js_yaml_hasOwnProp = Object.prototype.hasOwnProperty; -var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports); -var js_yaml_copyProps = (to, from, except, desc) => { - if (from && typeof from === "object" || typeof from === "function") for (var keys = js_yaml_getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) { - key = keys[i]; - if (!js_yaml_hasOwnProp.call(to, key) && key !== except) js_yaml_defProp(to, key, { - get: ((k) => from[k]).bind(null, key), - enumerable: !(desc = js_yaml_getOwnPropDesc(from, key)) || desc.enumerable - }); - } - return to; -}; -var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, js_yaml_copyProps(isNodeMode || !mod || !mod.__esModule ? js_yaml_defProp(target, "default", { - value: mod, - enumerable: true -}) : target, mod)); -//#endregion -//#region lib/common.js -var require_common = /* @__PURE__ */ __commonJSMin(((exports, module) => { - function isNothing(subject) { - return typeof subject === "undefined" || subject === null; - } - function isObject(subject) { - return typeof subject === "object" && subject !== null; - } - function toArray(sequence) { - if (Array.isArray(sequence)) return sequence; - else if (isNothing(sequence)) return []; - return [sequence]; - } - function extend(target, source) { - if (source) { - const sourceKeys = Object.keys(source); - for (let index = 0, length = sourceKeys.length; index < length; index += 1) { - const key = sourceKeys[index]; - target[key] = source[key]; - } - } - return target; - } - function repeat(string, count) { - let result = ""; - for (let cycle = 0; cycle < count; cycle += 1) result += string; - return result; - } - function isNegativeZero(number) { - return number === 0 && Number.NEGATIVE_INFINITY === 1 / number; - } - module.exports.isNothing = isNothing; - module.exports.isObject = isObject; - module.exports.toArray = toArray; - module.exports.repeat = repeat; - module.exports.isNegativeZero = isNegativeZero; - module.exports.extend = extend; -})); -//#endregion -//#region lib/exception.js -var require_exception = /* @__PURE__ */ __commonJSMin(((exports, module) => { - function formatError(exception, compact) { - let where = ""; - const message = exception.reason || "(unknown reason)"; - if (!exception.mark) return message; - if (exception.mark.name) where += "in \"" + exception.mark.name + "\" "; - where += "(" + (exception.mark.line + 1) + ":" + (exception.mark.column + 1) + ")"; - if (!compact && exception.mark.snippet) where += "\n\n" + exception.mark.snippet; - return message + " " + where; - } - function YAMLException(reason, mark) { - Error.call(this); - this.name = "YAMLException"; - this.reason = reason; - this.mark = mark; - this.message = formatError(this, false); - if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor); - else this.stack = (/* @__PURE__ */ new Error()).stack || ""; - } - YAMLException.prototype = Object.create(Error.prototype); - YAMLException.prototype.constructor = YAMLException; - YAMLException.prototype.toString = function toString(compact) { - return this.name + ": " + formatError(this, compact); +/*! js-yaml 5.0.0 https://github.com/nodeca/js-yaml @license MIT */ +//#region src/tag.ts +var NOT_RESOLVED = Symbol("NOT_RESOLVED"); +var MERGE_KEY = Symbol("MERGE_KEY"); +function defineScalarTag(tagName, options) { + return { + tagName, + nodeKind: "scalar", + implicit: options.implicit ?? false, + matchByTagPrefix: options.matchByTagPrefix ?? false, + implicitFirstChars: options.implicitFirstChars ?? null, + resolve: options.resolve, + identify: options.identify ?? null, + represent: options.represent ?? ((data) => String(data)), + representTagName: options.representTagName ?? null }; - module.exports = YAMLException; -})); +} +function defineSequenceTag(tagName, options) { + return { + tagName, + nodeKind: "sequence", + implicit: false, + matchByTagPrefix: options.matchByTagPrefix ?? false, + create: options.create, + addItem: options.addItem, + identify: options.identify ?? null, + represent: options.represent ?? ((data) => data), + representTagName: options.representTagName ?? null + }; +} +function defineMappingTag(tagName, options) { + return { + tagName, + nodeKind: "mapping", + implicit: false, + matchByTagPrefix: options.matchByTagPrefix ?? false, + create: options.create, + addPair: options.addPair, + has: options.has, + keys: options.keys, + get: options.get, + identify: options.identify ?? null, + represent: options.represent ?? ((data) => data), + representTagName: options.representTagName ?? null + }; +} //#endregion -//#region lib/snippet.js -var require_snippet = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var common = require_common(); - function getLine(buffer, lineStart, lineEnd, position, maxLineLength) { - let head = ""; - let tail = ""; - const maxHalfLength = Math.floor(maxLineLength / 2) - 1; - if (position - lineStart > maxHalfLength) { - head = " ... "; - lineStart = position - maxHalfLength + head.length; - } - if (lineEnd - position > maxHalfLength) { - tail = " ..."; - lineEnd = position + maxHalfLength - tail.length; - } - return { - str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "→") + tail, - pos: position - lineStart + head.length - }; - } - function padStart(string, max) { - return common.repeat(" ", max - string.length) + string; - } - function makeSnippet(mark, options) { - options = Object.create(options || null); - if (!mark.buffer) return null; - if (!options.maxLength) options.maxLength = 79; - if (typeof options.indent !== "number") options.indent = 1; - if (typeof options.linesBefore !== "number") options.linesBefore = 3; - if (typeof options.linesAfter !== "number") options.linesAfter = 2; - const re = /\r?\n|\r|\0/g; - const lineStarts = [0]; - const lineEnds = []; - let match; - let foundLineNo = -1; - while (match = re.exec(mark.buffer)) { - lineEnds.push(match.index); - lineStarts.push(match.index + match[0].length); - if (mark.position <= match.index && foundLineNo < 0) foundLineNo = lineStarts.length - 2; - } - if (foundLineNo < 0) foundLineNo = lineStarts.length - 1; - let result = ""; - const lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length; - const maxLineLength = options.maxLength - (options.indent + lineNoLength + 3); - for (let i = 1; i <= options.linesBefore; i++) { - if (foundLineNo - i < 0) break; - const line = getLine(mark.buffer, lineStarts[foundLineNo - i], lineEnds[foundLineNo - i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), maxLineLength); - result = common.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line.str + "\n" + result; - } - const line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength); - result += common.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + "\n"; - result += common.repeat("-", options.indent + lineNoLength + 3 + line.pos) + "^\n"; - for (let i = 1; i <= options.linesAfter; i++) { - if (foundLineNo + i >= lineEnds.length) break; - const line = getLine(mark.buffer, lineStarts[foundLineNo + i], lineEnds[foundLineNo + i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), maxLineLength); - result += common.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line.str + "\n"; - } - return result.replace(/\n$/, ""); - } - module.exports = makeSnippet; -})); +//#region src/tag/scalar/str.ts +var strTag = defineScalarTag("tag:yaml.org,2002:str", { + resolve: (source) => source, + identify: (data) => typeof data === "string" +}); //#endregion -//#region lib/type.js -var require_type = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var YAMLException = require_exception(); - var TYPE_CONSTRUCTOR_OPTIONS = [ - "kind", - "multi", - "resolve", - "construct", - "instanceOf", - "predicate", - "represent", - "representName", - "defaultStyle", - "styleAliases" - ]; - var YAML_NODE_KINDS = [ - "scalar", - "sequence", - "mapping" - ]; - function compileStyleAliases(map) { - const result = {}; - if (map !== null) Object.keys(map).forEach(function(style) { - map[style].forEach(function(alias) { - result[String(alias)] = style; - }); - }); - return result; - } - function Type(tag, options) { - options = options || {}; - Object.keys(options).forEach(function(name) { - if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) throw new YAMLException("Unknown option \"" + name + "\" is met in definition of \"" + tag + "\" YAML type."); - }); - this.options = options; - this.tag = tag; - this.kind = options["kind"] || null; - this.resolve = options["resolve"] || function() { - return true; - }; - this.construct = options["construct"] || function(data) { - return data; - }; - this.instanceOf = options["instanceOf"] || null; - this.predicate = options["predicate"] || null; - this.represent = options["represent"] || null; - this.representName = options["representName"] || null; - this.defaultStyle = options["defaultStyle"] || null; - this.multi = options["multi"] || false; - this.styleAliases = compileStyleAliases(options["styleAliases"] || null); - if (YAML_NODE_KINDS.indexOf(this.kind) === -1) throw new YAMLException("Unknown kind \"" + this.kind + "\" is specified for \"" + tag + "\" YAML type."); - } - module.exports = Type; -})); +//#region src/tag/scalar/null_core.ts +var NULL_VALUES$1 = [ + "", + "~", + "null", + "Null", + "NULL" +]; +var nullCoreTag = defineScalarTag("tag:yaml.org,2002:null", { + implicit: true, + implicitFirstChars: [ + "", + "~", + "n", + "N" + ], + resolve: (source) => { + if (NULL_VALUES$1.indexOf(source) !== -1) return null; + return NOT_RESOLVED; + }, + identify: (object) => object === null, + represent: () => "null" +}); //#endregion -//#region lib/schema.js -var require_schema = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var YAMLException = require_exception(); - var Type = require_type(); - function compileList(schema, name) { - const result = []; - schema[name].forEach(function(currentType) { - let newIndex = result.length; - result.forEach(function(previousType, previousIndex) { - if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) newIndex = previousIndex; - }); - result[newIndex] = currentType; - }); - return result; - } - function compileMap() { - const result = { - scalar: {}, - sequence: {}, - mapping: {}, - fallback: {}, - multi: { - scalar: [], - sequence: [], - mapping: [], - fallback: [] - } - }; - function collectType(type) { - if (type.multi) { - result.multi[type.kind].push(type); - result.multi["fallback"].push(type); - } else result[type.kind][type.tag] = result["fallback"][type.tag] = type; - } - for (let index = 0, length = arguments.length; index < length; index += 1) arguments[index].forEach(collectType); - return result; - } - function Schema(definition) { - return this.extend(definition); - } - Schema.prototype.extend = function extend(definition) { - let implicit = []; - let explicit = []; - if (definition instanceof Type) explicit.push(definition); - else if (Array.isArray(definition)) explicit = explicit.concat(definition); - else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) { - if (definition.implicit) implicit = implicit.concat(definition.implicit); - if (definition.explicit) explicit = explicit.concat(definition.explicit); - } else throw new YAMLException("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })"); - implicit.forEach(function(type) { - if (!(type instanceof Type)) throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object."); - if (type.loadKind && type.loadKind !== "scalar") throw new YAMLException("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported."); - if (type.multi) throw new YAMLException("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit."); - }); - explicit.forEach(function(type) { - if (!(type instanceof Type)) throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object."); - }); - const result = Object.create(Schema.prototype); - result.implicit = (this.implicit || []).concat(implicit); - result.explicit = (this.explicit || []).concat(explicit); - result.compiledImplicit = compileList(result, "implicit"); - result.compiledExplicit = compileList(result, "explicit"); - result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit); - return result; - }; - module.exports = Schema; -})); +//#region src/tag/scalar/null_json.ts +var nullJsonTag = defineScalarTag("tag:yaml.org,2002:null", { + implicit: true, + implicitFirstChars: ["n"], + resolve: (source, isExplicit) => { + if (source === "null" || isExplicit && source === "") return null; + return NOT_RESOLVED; + }, + identify: (object) => object === null, + represent: () => "null" +}); //#endregion -//#region lib/type/str.js -var require_str = /* @__PURE__ */ __commonJSMin(((exports, module) => { - module.exports = new (require_type())("tag:yaml.org,2002:str", { - kind: "scalar", - construct: function(data) { - return data !== null ? data : ""; - } - }); -})); +//#region src/tag/scalar/null_yaml11.ts +var NULL_VALUES = [ + "", + "~", + "null", + "Null", + "NULL" +]; +var nullYaml11Tag = defineScalarTag("tag:yaml.org,2002:null", { + implicit: true, + implicitFirstChars: [ + "", + "~", + "n", + "N" + ], + resolve: (source) => { + if (NULL_VALUES.indexOf(source) !== -1) return null; + return NOT_RESOLVED; + }, + identify: (object) => object === null, + represent: () => "null" +}); //#endregion -//#region lib/type/seq.js -var require_seq = /* @__PURE__ */ __commonJSMin(((exports, module) => { - module.exports = new (require_type())("tag:yaml.org,2002:seq", { - kind: "sequence", - construct: function(data) { - return data !== null ? data : []; - } - }); -})); +//#region src/tag/scalar/bool_core.ts +var TRUE_VALUES$2 = [ + "true", + "True", + "TRUE" +]; +var FALSE_VALUES$2 = [ + "false", + "False", + "FALSE" +]; +var boolCoreTag = defineScalarTag("tag:yaml.org,2002:bool", { + implicit: true, + implicitFirstChars: [ + "t", + "T", + "f", + "F" + ], + resolve: (source) => { + if (TRUE_VALUES$2.indexOf(source) !== -1) return true; + if (FALSE_VALUES$2.indexOf(source) !== -1) return false; + return NOT_RESOLVED; + }, + identify: (object) => Object.prototype.toString.call(object) === "[object Boolean]", + represent: (object) => object ? "true" : "false" +}); //#endregion -//#region lib/type/map.js -var require_map = /* @__PURE__ */ __commonJSMin(((exports, module) => { - module.exports = new (require_type())("tag:yaml.org,2002:map", { - kind: "mapping", - construct: function(data) { - return data !== null ? data : {}; - } - }); -})); +//#region src/tag/scalar/bool_json.ts +var TRUE_VALUES$1 = ["true"]; +var FALSE_VALUES$1 = ["false"]; +var boolJsonTag = defineScalarTag("tag:yaml.org,2002:bool", { + implicit: true, + implicitFirstChars: ["t", "f"], + resolve: (source) => { + if (TRUE_VALUES$1.indexOf(source) !== -1) return true; + if (FALSE_VALUES$1.indexOf(source) !== -1) return false; + return NOT_RESOLVED; + }, + identify: (object) => Object.prototype.toString.call(object) === "[object Boolean]", + represent: (object) => object ? "true" : "false" +}); //#endregion -//#region lib/schema/failsafe.js -var require_failsafe = /* @__PURE__ */ __commonJSMin(((exports, module) => { - module.exports = new (require_schema())({ explicit: [ - require_str(), - require_seq(), - require_map() - ] }); -})); +//#region src/tag/scalar/bool_yaml11.ts +var TRUE_VALUES = [ + "true", + "True", + "TRUE", + "y", + "Y", + "yes", + "Yes", + "YES", + "on", + "On", + "ON" +]; +var FALSE_VALUES = [ + "false", + "False", + "FALSE", + "n", + "N", + "no", + "No", + "NO", + "off", + "Off", + "OFF" +]; +var boolYaml11Tag = defineScalarTag("tag:yaml.org,2002:bool", { + implicit: true, + implicitFirstChars: [ + "y", + "Y", + "n", + "N", + "t", + "T", + "f", + "F", + "o", + "O" + ], + resolve: (source) => { + if (TRUE_VALUES.indexOf(source) !== -1) return true; + if (FALSE_VALUES.indexOf(source) !== -1) return false; + return NOT_RESOLVED; + }, + identify: (object) => Object.prototype.toString.call(object) === "[object Boolean]", + represent: (object) => object ? "true" : "false" +}); //#endregion -//#region lib/type/null.js -var require_null = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var Type = require_type(); - function resolveYamlNull(data) { - if (data === null) return true; - const max = data.length; - return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL"); - } - function constructYamlNull() { - return null; - } - function isNull(object) { - return object === null; - } - module.exports = new Type("tag:yaml.org,2002:null", { - kind: "scalar", - resolve: resolveYamlNull, - construct: constructYamlNull, - predicate: isNull, - represent: { - canonical: function() { - return "~"; - }, - lowercase: function() { - return "null"; - }, - uppercase: function() { - return "NULL"; - }, - camelcase: function() { - return "Null"; - }, - empty: function() { - return ""; - } - }, - defaultStyle: "lowercase" - }); -})); +//#region src/tag/scalar/int_core.ts +var YAML_INTEGER_IMPLICIT_PATTERN$1 = /* @__PURE__ */ new RegExp("^(?:0o[0-7]+|0x[0-9a-fA-F]+|[-+]?[0-9]+)$"); +var YAML_INTEGER_EXPLICIT_PATTERN$1 = /* @__PURE__ */ new RegExp("^(?:[-+]?0b[0-1]+|[-+]?0o[0-7]+|[-+]?0x[0-9a-fA-F]+|[-+]?[0-9]+)$"); +function parseYamlInteger$2(source) { + let value = source; + let sign = 1; + if (value[0] === "-" || value[0] === "+") { + if (value[0] === "-") sign = -1; + value = value.slice(1); + } + if (value.startsWith("0b")) return sign * parseInt(value.slice(2), 2); + if (value.startsWith("0o")) return sign * parseInt(value.slice(2), 8); + if (value.startsWith("0x")) return sign * parseInt(value.slice(2), 16); + return sign * parseInt(value, 10); +} +function resolveYamlInteger$2(source, isExplicit) { + if (isExplicit) { + if (!YAML_INTEGER_EXPLICIT_PATTERN$1.test(source)) return NOT_RESOLVED; + } else if (!YAML_INTEGER_IMPLICIT_PATTERN$1.test(source)) return NOT_RESOLVED; + const result = parseYamlInteger$2(source); + return Number.isFinite(result) ? result : NOT_RESOLVED; +} +var intCoreTag = defineScalarTag("tag:yaml.org,2002:int", { + implicit: true, + implicitFirstChars: [ + "-", + "+", + ..."0123456789" + ], + resolve: resolveYamlInteger$2, + identify: (object) => Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !Object.is(object, -0), + represent: (object) => object.toString(10) +}); //#endregion -//#region lib/type/bool.js -var require_bool = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var Type = require_type(); - function resolveYamlBoolean(data) { - if (data === null) return false; - const max = data.length; - return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE"); - } - function constructYamlBoolean(data) { - return data === "true" || data === "True" || data === "TRUE"; - } - function isBoolean(object) { - return Object.prototype.toString.call(object) === "[object Boolean]"; - } - module.exports = new Type("tag:yaml.org,2002:bool", { - kind: "scalar", - resolve: resolveYamlBoolean, - construct: constructYamlBoolean, - predicate: isBoolean, - represent: { - lowercase: function(object) { - return object ? "true" : "false"; - }, - uppercase: function(object) { - return object ? "TRUE" : "FALSE"; - }, - camelcase: function(object) { - return object ? "True" : "False"; - } - }, - defaultStyle: "lowercase" - }); -})); +//#region src/tag/scalar/int_json.ts +var YAML_INTEGER_IMPLICIT_PATTERN = /* @__PURE__ */ new RegExp("^-?(?:0|[1-9][0-9]*)$"); +var YAML_INTEGER_EXPLICIT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?0b[0-1]+|[-+]?0o[0-7]+|[-+]?0x[0-9a-fA-F]+|[-+]?[0-9]+)$"); +function parseYamlInteger$1(source) { + let value = source; + let sign = 1; + if (value[0] === "-" || value[0] === "+") { + if (value[0] === "-") sign = -1; + value = value.slice(1); + } + if (value.startsWith("0b")) return sign * parseInt(value.slice(2), 2); + if (value.startsWith("0o")) return sign * parseInt(value.slice(2), 8); + if (value.startsWith("0x")) return sign * parseInt(value.slice(2), 16); + return sign * parseInt(value, 10); +} +function resolveYamlInteger$1(source, isExplicit) { + if (isExplicit) { + if (!YAML_INTEGER_EXPLICIT_PATTERN.test(source)) return NOT_RESOLVED; + } else if (!YAML_INTEGER_IMPLICIT_PATTERN.test(source)) return NOT_RESOLVED; + const result = parseYamlInteger$1(source); + return Number.isFinite(result) ? result : NOT_RESOLVED; +} +var intJsonTag = defineScalarTag("tag:yaml.org,2002:int", { + implicit: true, + implicitFirstChars: ["-", ..."0123456789"], + resolve: resolveYamlInteger$1, + identify: (object) => Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !Object.is(object, -0), + represent: (object) => object.toString(10) +}); //#endregion -//#region lib/type/int.js -var require_int = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var common = require_common(); - var Type = require_type(); - function isHexCode(c) { - return c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102; - } - function isOctCode(c) { - return c >= 48 && c <= 55; - } - function isDecCode(c) { - return c >= 48 && c <= 57; - } - function resolveYamlInteger(data) { - if (data === null) return false; - const max = data.length; - let index = 0; - let hasDigits = false; - if (!max) return false; - let ch = data[index]; - if (ch === "-" || ch === "+") ch = data[++index]; - if (ch === "0") { - if (index + 1 === max) return true; - ch = data[++index]; - if (ch === "b") { - index++; - for (; index < max; index++) { - ch = data[index]; - if (ch !== "0" && ch !== "1") return false; - hasDigits = true; - } - return hasDigits && Number.isFinite(parseYamlInteger(data)); - } - if (ch === "x") { - index++; - for (; index < max; index++) { - if (!isHexCode(data.charCodeAt(index))) return false; - hasDigits = true; - } - return hasDigits && Number.isFinite(parseYamlInteger(data)); - } - if (ch === "o") { - index++; - for (; index < max; index++) { - if (!isOctCode(data.charCodeAt(index))) return false; - hasDigits = true; - } - return hasDigits && Number.isFinite(parseYamlInteger(data)); - } - } - for (; index < max; index++) { - if (!isDecCode(data.charCodeAt(index))) return false; - hasDigits = true; - } - if (!hasDigits) return false; - return Number.isFinite(parseYamlInteger(data)); - } - function parseYamlInteger(data) { - let value = data; - let sign = 1; - let ch = value[0]; - if (ch === "-" || ch === "+") { - if (ch === "-") sign = -1; - value = value.slice(1); - ch = value[0]; - } - if (value === "0") return 0; - if (ch === "0") { - if (value[1] === "b") return sign * parseInt(value.slice(2), 2); - if (value[1] === "x") return sign * parseInt(value.slice(2), 16); - if (value[1] === "o") return sign * parseInt(value.slice(2), 8); - } - return sign * parseInt(value, 10); - } - function constructYamlInteger(data) { - return parseYamlInteger(data); - } - function isInteger(object) { - return Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !common.isNegativeZero(object); - } - module.exports = new Type("tag:yaml.org,2002:int", { - kind: "scalar", - resolve: resolveYamlInteger, - construct: constructYamlInteger, - predicate: isInteger, - represent: { - binary: function(obj) { - return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1); - }, - octal: function(obj) { - return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1); - }, - decimal: function(obj) { - return obj.toString(10); - }, - hexadecimal: function(obj) { - return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1); - } - }, - defaultStyle: "decimal", - styleAliases: { - binary: [2, "bin"], - octal: [8, "oct"], - decimal: [10, "dec"], - hexadecimal: [16, "hex"] - } - }); -})); +//#region src/tag/scalar/int_yaml11.ts +var YAML_INTEGER_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?0b[0-1_]+|[-+]?0[0-7_]+|[-+]?0x[0-9a-fA-F_]+|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+|[-+]?(?:0|[1-9][0-9_]*))$"); +function parseYamlInteger(source) { + let value = source.replace(/_/g, ""); + let sign = 1; + if (value[0] === "-" || value[0] === "+") { + if (value[0] === "-") sign = -1; + value = value.slice(1); + } + if (value.startsWith("0b")) return sign * parseInt(value.slice(2), 2); + if (value.startsWith("0x")) return sign * parseInt(value.slice(2), 16); + if (value.includes(":")) { + let result = 0; + for (const part of value.split(":")) result = result * 60 + Number(part); + return sign * result; + } + if (value !== "0" && value[0] === "0") return sign * parseInt(value, 8); + return sign * parseInt(value, 10); +} +function resolveYamlInteger(source) { + if (!YAML_INTEGER_PATTERN.test(source)) return NOT_RESOLVED; + const result = parseYamlInteger(source); + return Number.isFinite(result) ? result : NOT_RESOLVED; +} +var intYaml11Tag = defineScalarTag("tag:yaml.org,2002:int", { + implicit: true, + implicitFirstChars: [ + "-", + "+", + ..."0123456789" + ], + resolve: resolveYamlInteger, + identify: (object) => Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !Object.is(object, -0), + represent: (object) => object.toString(10) +}); //#endregion -//#region lib/type/float.js -var require_float = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var common = require_common(); - var Type = require_type(); - var YAML_FLOAT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:[0-9]+)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"); - var YAML_FLOAT_SPECIAL_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"); - function resolveYamlFloat(data) { - if (data === null) return false; - if (!YAML_FLOAT_PATTERN.test(data)) return false; - if (Number.isFinite(parseFloat(data, 10))) return true; - return YAML_FLOAT_SPECIAL_PATTERN.test(data); - } - function constructYamlFloat(data) { - let value = data.toLowerCase(); +//#region src/tag/scalar/float_core.ts +var YAML_FLOAT_PATTERN$1 = /* @__PURE__ */ new RegExp("^(?:[-+]?[0-9]+(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|[-+]?\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"); +var YAML_FLOAT_SPECIAL_PATTERN$1 = /* @__PURE__ */ new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"); +function resolveYamlFloat$2(source) { + if (!YAML_FLOAT_PATTERN$1.test(source)) return NOT_RESOLVED; + let value = source.toLowerCase(); + const sign = value[0] === "-" ? -1 : 1; + if ("+-".includes(value[0])) value = value.slice(1); + if (value === ".inf") return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; + if (value === ".nan") return NaN; + const result = sign * parseFloat(value); + if (Number.isFinite(result) || YAML_FLOAT_SPECIAL_PATTERN$1.test(source)) return result; + return NOT_RESOLVED; +} +function representYamlFloat$2(object) { + if (isNaN(object)) return ".nan"; + if (object === Number.POSITIVE_INFINITY) return ".inf"; + if (object === Number.NEGATIVE_INFINITY) return "-.inf"; + if (Object.is(object, -0)) return "-0.0"; + const result = object.toString(10); + return /^[-+]?[0-9]+e/.test(result) ? result.replace("e", ".e") : result; +} +var floatCoreTag = defineScalarTag("tag:yaml.org,2002:float", { + implicit: true, + implicitFirstChars: [ + "-", + "+", + ".", + ..."0123456789" + ], + resolve: resolveYamlFloat$2, + identify: (object) => Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || Object.is(object, -0)), + represent: representYamlFloat$2 +}); +//#endregion +//#region src/tag/scalar/float_json.ts +var YAML_FLOAT_IMPLICIT_PATTERN = /* @__PURE__ */ new RegExp("^-?(?:0|[1-9][0-9]*)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$"); +var YAML_FLOAT_EXPLICIT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?[0-9]+(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|[-+]?\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"); +function resolveYamlFloat$1(source, isExplicit) { + if (isExplicit) { + if (!YAML_FLOAT_EXPLICIT_PATTERN.test(source)) return NOT_RESOLVED; + let value = source.toLowerCase(); const sign = value[0] === "-" ? -1 : 1; - if ("+-".indexOf(value[0]) >= 0) value = value.slice(1); + if ("+-".includes(value[0])) value = value.slice(1); if (value === ".inf") return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; - else if (value === ".nan") return NaN; - return sign * parseFloat(value, 10); - } - var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/; - function representYamlFloat(object, style) { - if (isNaN(object)) switch (style) { - case "lowercase": return ".nan"; - case "uppercase": return ".NAN"; - case "camelcase": return ".NaN"; - } - else if (Number.POSITIVE_INFINITY === object) switch (style) { - case "lowercase": return ".inf"; - case "uppercase": return ".INF"; - case "camelcase": return ".Inf"; - } - else if (Number.NEGATIVE_INFINITY === object) switch (style) { - case "lowercase": return "-.inf"; - case "uppercase": return "-.INF"; - case "camelcase": return "-.Inf"; - } - else if (common.isNegativeZero(object)) return "-0.0"; - const res = object.toString(10); - return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res; - } - function isFloat(object) { - return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object)); - } - module.exports = new Type("tag:yaml.org,2002:float", { - kind: "scalar", - resolve: resolveYamlFloat, - construct: constructYamlFloat, - predicate: isFloat, - represent: representYamlFloat, - defaultStyle: "lowercase" - }); -})); -//#endregion -//#region lib/schema/json.js -var require_json = /* @__PURE__ */ __commonJSMin(((exports, module) => { - module.exports = require_failsafe().extend({ implicit: [ - require_null(), - require_bool(), - require_int(), - require_float() - ] }); -})); + if (value === ".nan") return NaN; + const result = sign * parseFloat(value); + return Number.isFinite(result) ? result : NOT_RESOLVED; + } + if (!YAML_FLOAT_IMPLICIT_PATTERN.test(source)) return NOT_RESOLVED; + const result = Number(source); + if (Number.isFinite(result)) return result; + return NOT_RESOLVED; +} +function representYamlFloat$1(object) { + if (isNaN(object)) return ".nan"; + if (object === Number.POSITIVE_INFINITY) return ".inf"; + if (object === Number.NEGATIVE_INFINITY) return "-.inf"; + if (Object.is(object, -0)) return "-0.0"; + const result = object.toString(10); + return /^[-+]?[0-9]+e/.test(result) ? result.replace("e", ".e") : result; +} +var floatJsonTag = defineScalarTag("tag:yaml.org,2002:float", { + implicit: true, + implicitFirstChars: ["-", ..."0123456789"], + resolve: resolveYamlFloat$1, + identify: (object) => Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || Object.is(object, -0)), + represent: representYamlFloat$1 +}); //#endregion -//#region lib/schema/core.js -var require_core = /* @__PURE__ */ __commonJSMin(((exports, module) => { - module.exports = require_json(); -})); +//#region src/tag/scalar/float_yaml11.ts +var YAML_FLOAT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:(?:[0-9][0-9_]*)?\\.[0-9_]*)(?:[eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"); +var YAML_FLOAT_SPECIAL_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"); +function resolveYamlFloat(source) { + if (!YAML_FLOAT_PATTERN.test(source)) return NOT_RESOLVED; + let value = source.toLowerCase().replace(/_/g, ""); + const sign = value[0] === "-" ? -1 : 1; + if ("+-".includes(value[0])) value = value.slice(1); + if (value === ".inf") return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; + if (value === ".nan") return NaN; + let result = 0; + if (value.includes(":")) { + for (const part of value.split(":")) result = result * 60 + Number(part); + result *= sign; + } else result = sign * parseFloat(value); + if (Number.isFinite(result) || YAML_FLOAT_SPECIAL_PATTERN.test(source)) return result; + return NOT_RESOLVED; +} +function representYamlFloat(object) { + if (isNaN(object)) return ".nan"; + if (object === Number.POSITIVE_INFINITY) return ".inf"; + if (object === Number.NEGATIVE_INFINITY) return "-.inf"; + if (Object.is(object, -0)) return "-0.0"; + const result = object.toString(10); + return /^[-+]?[0-9]+e/.test(result) ? result.replace("e", ".e") : result; +} +var floatYaml11Tag = defineScalarTag("tag:yaml.org,2002:float", { + implicit: true, + implicitFirstChars: [ + "-", + "+", + ".", + ..."0123456789" + ], + resolve: resolveYamlFloat, + identify: (object) => Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || Object.is(object, -0)), + represent: representYamlFloat +}); //#endregion -//#region lib/type/timestamp.js -var require_timestamp = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var Type = require_type(); - var YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$"); - var YAML_TIMESTAMP_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$"); - function resolveYamlTimestamp(data) { - if (data === null) return false; - if (YAML_DATE_REGEXP.exec(data) !== null) return true; - if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true; - return false; +//#region src/tag/scalar/merge.ts +var mergeTag = defineScalarTag("tag:yaml.org,2002:merge", { + implicit: true, + implicitFirstChars: ["<"], + resolve: (source, isExplicit) => { + if (source === "<<" || isExplicit && source === "") return MERGE_KEY; + return NOT_RESOLVED; } - function constructYamlTimestamp(data) { - let fraction = 0; - let delta = null; - let match = YAML_DATE_REGEXP.exec(data); - if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data); - if (match === null) throw new Error("Date resolve error"); - const year = +match[1]; - const month = +match[2] - 1; - const day = +match[3]; - if (!match[4]) return new Date(Date.UTC(year, month, day)); - const hour = +match[4]; - const minute = +match[5]; - const second = +match[6]; - if (match[7]) { - fraction = match[7].slice(0, 3); - while (fraction.length < 3) fraction += "0"; - fraction = +fraction; - } - if (match[9]) { - const tzHour = +match[10]; - const tzMinute = +(match[11] || 0); - delta = (tzHour * 60 + tzMinute) * 6e4; - if (match[9] === "-") delta = -delta; - } - const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction)); - if (delta) date.setTime(date.getTime() - delta); +}); +//#endregion +//#region src/tag/scalar/binary.ts +var BASE64_PATTERN = /^[A-Za-z0-9+/]*={0,2}$/; +function resolveYamlBinary(source) { + const input = source.replace(/\s/g, ""); + if (input.length % 4 !== 0 || !BASE64_PATTERN.test(input)) return NOT_RESOLVED; + const binary = atob(input); + const result = new Uint8Array(binary.length); + for (let index = 0; index < binary.length; index++) result[index] = binary.charCodeAt(index); + return result; +} +function representYamlBinary(object) { + let binary = ""; + for (let index = 0; index < object.length; index++) binary += String.fromCharCode(object[index]); + return btoa(binary); +} +var binaryTag = defineScalarTag("tag:yaml.org,2002:binary", { + resolve: resolveYamlBinary, + identify: (object) => Object.prototype.toString.call(object) === "[object Uint8Array]", + represent: representYamlBinary +}); +//#endregion +//#region src/tag/scalar/timestamp.ts +var YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$"); +var YAML_TIMESTAMP_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$"); +function resolveYamlTimestamp(source) { + let match = YAML_DATE_REGEXP.exec(source); + if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(source); + if (match === null) return NOT_RESOLVED; + const year = +match[1]; + const month = +match[2] - 1; + const day = +match[3]; + if (!match[4]) { + const date = new Date(Date.UTC(year, month, day)); + if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month || date.getUTCDate() !== day) return NOT_RESOLVED; 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 - }); -})); + const hour = +match[4]; + const minute = +match[5]; + const second = +match[6]; + let fraction = 0; + if (hour > 23 || minute > 59 || second > 59) return NOT_RESOLVED; + if (match[7]) { + let value = match[7].slice(0, 3); + while (value.length < 3) value += "0"; + fraction = +value; + } + const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction)); + if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month || date.getUTCDate() !== day) return NOT_RESOLVED; + if (match[9]) { + const offsetHour = +match[10]; + const offsetMinute = +(match[11] || 0); + if (offsetHour > 23 || offsetMinute > 59) return NOT_RESOLVED; + const offset = (offsetHour * 60 + offsetMinute) * 6e4; + date.setTime(date.getTime() - (match[9] === "-" ? -offset : offset)); + } + return date; +} +var timestampTag = defineScalarTag("tag:yaml.org,2002:timestamp", { + implicit: true, + implicitFirstChars: [..."0123456789"], + resolve: resolveYamlTimestamp, + identify: (object) => object instanceof Date, + represent: (object) => object.toISOString() +}); +//#endregion +//#region src/tag/sequence/seq.ts +var seqTag = defineSequenceTag("tag:yaml.org,2002:seq", { + create: () => [], + addItem: (container, item) => { + container.push(item); + }, + identify: Array.isArray +}); //#endregion -//#region lib/type/merge.js -var require_merge = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var Type = require_type(); - function resolveYamlMerge(data) { - return data === "<<" || data === null; +//#region src/tag/sequence/omap.ts +var omapTag = defineSequenceTag("tag:yaml.org,2002:omap", { + create: () => [], + addItem: (container, item) => { + if (Object.prototype.toString.call(item) !== "[object Object]") return "cannot resolve an ordered map item"; + const object = item; + const itemKeys = Object.keys(object); + if (itemKeys.length !== 1) return "cannot resolve an ordered map item"; + for (const existing of container) if (Object.prototype.hasOwnProperty.call(existing, itemKeys[0])) return "cannot resolve an ordered map item"; + container.push(object); + return ""; } - module.exports = new Type("tag:yaml.org,2002:merge", { - kind: "scalar", - resolve: resolveYamlMerge - }); -})); +}); //#endregion -//#region lib/type/binary.js -var require_binary = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var Type = require_type(); - var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r"; - function resolveYamlBinary(data) { - if (data === null) return false; - let bitlen = 0; - const max = data.length; - const map = BASE64_MAP; - for (let idx = 0; idx < max; idx++) { - const code = map.indexOf(data.charAt(idx)); - if (code > 64) continue; - if (code < 0) return false; - bitlen += 6; +//#region src/tag/sequence/pairs.ts +var pairsTag = defineSequenceTag("tag:yaml.org,2002:pairs", { + create: () => [], + addItem: (container, item) => { + if (item instanceof Map) { + if (item.size !== 1) return "cannot resolve a pairs item"; + container.push(item.entries().next().value); + return ""; } - return bitlen % 8 === 0; - } - function constructYamlBinary(data) { - const input = data.replace(/[\r\n=]/g, ""); - const max = input.length; - const map = BASE64_MAP; - let bits = 0; - const result = []; - for (let idx = 0; idx < max; idx++) { - if (idx % 4 === 0 && idx) { - result.push(bits >> 16 & 255); - result.push(bits >> 8 & 255); - result.push(bits & 255); + if (Object.prototype.toString.call(item) !== "[object Object]") return "cannot resolve a pairs item"; + const object = item; + const keys = Object.keys(object); + if (keys.length !== 1) return "cannot resolve a pairs item"; + container.push([keys[0], object[keys[0]]]); + return ""; + } +}); +//#endregion +//#region src/common/object.ts +function isPlainObject(data) { + if (data === null || typeof data !== "object" || Array.isArray(data)) return false; + const prototype = Object.getPrototypeOf(data); + return prototype === null || prototype === Object.prototype; +} +function js_yaml_pick(object, keys) { + const result = {}; + for (const key of keys) if (object[key] !== void 0) result[key] = object[key]; + return result; +} +//#endregion +//#region src/tag/mapping/map.ts +var mapTag = defineMappingTag("tag:yaml.org,2002:map", { + create: () => ({}), + identify: isPlainObject, + represent: (o) => { + const map = /* @__PURE__ */ new Map(); + for (const key of Object.keys(o)) map.set(key, o[key]); + return map; + }, + addPair: (container, key, value) => { + if (key !== null && typeof key === "object") return "object-based map does not support complex keys"; + const normalizedKey = String(key); + if (normalizedKey === "__proto__") Object.defineProperty(container, normalizedKey, { + value, + enumerable: true, + configurable: true, + writable: true + }); + else container[normalizedKey] = value; + return ""; + }, + has: (container, key) => { + if (key !== null && typeof key === "object") return false; + return Object.prototype.hasOwnProperty.call(container, String(key)); + }, + keys: (container) => Object.keys(container), + get: (container, key) => container[String(key)] +}); +//#endregion +//#region src/tag/mapping/set.ts +var setTag = defineMappingTag("tag:yaml.org,2002:set", { + create: () => /* @__PURE__ */ new Set(), + identify: (data) => data instanceof Set, + represent: (data) => { + const map = /* @__PURE__ */ new Map(); + for (const key of data) map.set(key, null); + return map; + }, + addPair: (container, key, value) => { + if (value !== null) return "cannot resolve a set item"; + container.add(key); + return ""; + }, + has: (container, key) => container.has(key), + keys: (container) => container.keys(), + get: () => null +}); +//#endregion +//#region src/schema.ts +function createTagDefinitionMap() { + return { + scalar: {}, + sequence: {}, + mapping: {} + }; +} +function createTagDefinitionListMap() { + return { + scalar: [], + sequence: [], + mapping: [] + }; +} +function compileTags(tags) { + const result = []; + for (const tag of tags) { + let index = result.length; + for (let previousIndex = 0; previousIndex < result.length; previousIndex++) { + const previous = result[previousIndex]; + if (previous.nodeKind === tag.nodeKind && previous.tagName === tag.tagName && previous.matchByTagPrefix === tag.matchByTagPrefix) { + index = previousIndex; + break; } - bits = bits << 6 | map.indexOf(input.charAt(idx)); } - const tailbits = max % 4 * 6; - if (tailbits === 0) { - result.push(bits >> 16 & 255); - result.push(bits >> 8 & 255); - result.push(bits & 255); - } else if (tailbits === 18) { - result.push(bits >> 10 & 255); - result.push(bits >> 2 & 255); - } else if (tailbits === 12) result.push(bits >> 4 & 255); - return new Uint8Array(result); - } - function representYamlBinary(object) { - let result = ""; - let bits = 0; - const max = object.length; - const map = BASE64_MAP; - for (let idx = 0; idx < max; idx++) { - if (idx % 3 === 0 && idx) { - result += map[bits >> 18 & 63]; - result += map[bits >> 12 & 63]; - result += map[bits >> 6 & 63]; - result += map[bits & 63]; + result[index] = tag; + } + return result; +} +var Schema = class Schema { + tags; + implicitScalarTags; + implicitScalarByFirstChar; + implicitScalarAnyFirstChar; + defaultScalarTag; + defaultSequenceTag; + defaultMappingTag; + exact; + prefix; + constructor(tags) { + const compiledTags = compileTags(tags); + const implicitScalarTags = []; + const exact = createTagDefinitionMap(); + const prefix = createTagDefinitionListMap(); + for (const tag of compiledTags) { + if (tag.nodeKind === "scalar" && tag.implicit) { + if (tag.matchByTagPrefix) throw new Error("Implicit scalar tags cannot match by tag prefix"); + implicitScalarTags.push(tag); + } + switch (tag.nodeKind) { + case "scalar": + if (tag.matchByTagPrefix) prefix.scalar.push(tag); + else exact.scalar[tag.tagName] = tag; + break; + case "sequence": + if (tag.matchByTagPrefix) prefix.sequence.push(tag); + else exact.sequence[tag.tagName] = tag; + break; + case "mapping": + if (tag.matchByTagPrefix) prefix.mapping.push(tag); + else exact.mapping[tag.tagName] = tag; + break; } - bits = (bits << 8) + object[idx]; - } - const tail = max % 3; - if (tail === 0) { - result += map[bits >> 18 & 63]; - result += map[bits >> 12 & 63]; - result += map[bits >> 6 & 63]; - result += map[bits & 63]; - } else if (tail === 2) { - result += map[bits >> 10 & 63]; - result += map[bits >> 4 & 63]; - result += map[bits << 2 & 63]; - result += map[64]; - } else if (tail === 1) { - result += map[bits >> 2 & 63]; - result += map[bits << 4 & 63]; - result += map[64]; - result += map[64]; } - return result; + const implicitScalarAnyFirstChar = implicitScalarTags.filter((tag) => tag.implicitFirstChars === null); + const keys = /* @__PURE__ */ new Set(); + for (const tag of implicitScalarTags) if (tag.implicitFirstChars !== null) for (const key of tag.implicitFirstChars) keys.add(key); + const implicitScalarByFirstChar = /* @__PURE__ */ new Map(); + for (const key of keys) implicitScalarByFirstChar.set(key, implicitScalarTags.filter((tag) => tag.implicitFirstChars === null || tag.implicitFirstChars.indexOf(key) !== -1)); + const defaultScalarTag = exact.scalar["tag:yaml.org,2002:str"]; + if (!defaultScalarTag) throw new Error("schema does not define the default scalar tag (tag:yaml.org,2002:str)"); + this.tags = compiledTags; + this.implicitScalarTags = implicitScalarTags; + this.implicitScalarByFirstChar = implicitScalarByFirstChar; + this.implicitScalarAnyFirstChar = implicitScalarAnyFirstChar; + this.defaultScalarTag = defaultScalarTag; + this.defaultSequenceTag = exact.sequence["tag:yaml.org,2002:seq"]; + this.defaultMappingTag = exact.mapping["tag:yaml.org,2002:map"]; + this.exact = exact; + this.prefix = prefix; + } + withTags(...tags) { + let flatTags = []; + for (const tag of tags) flatTags = flatTags.concat(tag); + return new Schema([...this.tags, ...flatTags]); } - function isBinary(obj) { - return Object.prototype.toString.call(obj) === "[object Uint8Array]"; +}; +var FAILSAFE_SCHEMA = new Schema([ + strTag, + seqTag, + mapTag +]); +var JSON_SCHEMA = new Schema([ + ...FAILSAFE_SCHEMA.tags, + nullJsonTag, + boolJsonTag, + intJsonTag, + floatJsonTag +]); +var CORE_SCHEMA = new Schema([ + ...FAILSAFE_SCHEMA.tags, + nullCoreTag, + boolCoreTag, + intCoreTag, + floatCoreTag +]); +var YAML11_SCHEMA = new Schema([ + ...FAILSAFE_SCHEMA.tags, + nullYaml11Tag, + boolYaml11Tag, + intYaml11Tag, + floatYaml11Tag, + timestampTag, + mergeTag, + binaryTag, + omapTag, + pairsTag, + setTag +]); +//#endregion +//#region src/tag/mapping/real_map.ts +var realMapTag = defineMappingTag("tag:yaml.org,2002:map", { + create: () => /* @__PURE__ */ new Map(), + addPair: (container, key, value) => { + container.set(key, value); + return ""; + }, + has: (container, key) => container.has(key), + keys: (container) => container.keys(), + get: (container, key) => container.get(key), + identify: (data) => data instanceof Map || isPlainObject(data), + represent: (data) => { + if (data instanceof Map) return data; + const map = /* @__PURE__ */ new Map(); + const obj = data; + for (const key of Object.keys(obj)) map.set(key, obj[key]); + return map; } - module.exports = new Type("tag:yaml.org,2002:binary", { - kind: "scalar", - resolve: resolveYamlBinary, - construct: constructYamlBinary, - predicate: isBinary, - represent: representYamlBinary - }); -})); +}); //#endregion -//#region lib/type/omap.js -var require_omap = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var Type = require_type(); - var _hasOwnProperty = Object.prototype.hasOwnProperty; - var _toString = Object.prototype.toString; - function resolveYamlOmap(data) { - if (data === null) return true; - const objectKeys = []; - const object = data; - for (let index = 0, length = object.length; index < length; index += 1) { - const pair = object[index]; - let pairHasKey = false; - if (_toString.call(pair) !== "[object Object]") return false; - let pairKey; - for (pairKey in pair) if (_hasOwnProperty.call(pair, pairKey)) if (!pairHasKey) pairHasKey = true; - else return false; - if (!pairHasKey) return false; - if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey); - else return false; +//#region src/tag/mapping/legacy_map.ts +function normalizeKey(key) { + if (Array.isArray(key)) { + const array = Array.prototype.slice.call(key); + for (let index = 0; index < array.length; index++) { + if (Array.isArray(array[index])) return null; + if (typeof array[index] === "object" && Object.prototype.toString.call(array[index]) === "[object Object]") array[index] = "[object Object]"; } - return true; - } - function constructYamlOmap(data) { - return data !== null ? data : []; + return String(array); + } + if (typeof key === "object" && Object.prototype.toString.call(key) === "[object Object]") return "[object Object]"; + return String(key); +} +var legacyMapTag = defineMappingTag("tag:yaml.org,2002:map", { + create: () => ({}), + identify: isPlainObject, + represent: (o) => { + const map = /* @__PURE__ */ new Map(); + for (const key of Object.keys(o)) map.set(key, o[key]); + return map; + }, + addPair: (container, key, value) => { + const normalizedKey = normalizeKey(key); + if (normalizedKey === null) return "nested arrays are not supported inside keys"; + if (normalizedKey === "__proto__") Object.defineProperty(container, normalizedKey, { + value, + enumerable: true, + configurable: true, + writable: true + }); + else container[normalizedKey] = value; + return ""; + }, + has: (container, key) => { + const normalizedKey = normalizeKey(key); + return normalizedKey !== null && Object.prototype.hasOwnProperty.call(container, normalizedKey); + }, + keys: (container) => Object.keys(container), + get: (container, key) => container[String(key)] +}); +//#endregion +//#region src/common/snippet.ts +var DEFAULT_SNIPPET_OPTIONS = { + maxLength: 79, + indent: 1, + linesBefore: 3, + linesAfter: 2 +}; +function getLine(buffer, lineStart, lineEnd, position, maxLineLength) { + let head = ""; + let tail = ""; + const maxHalfLength = Math.floor(maxLineLength / 2) - 1; + if (position - lineStart > maxHalfLength) { + head = " ... "; + lineStart = position - maxHalfLength + head.length; + } + if (lineEnd - position > maxHalfLength) { + tail = " ..."; + lineEnd = position + maxHalfLength - tail.length; } - module.exports = new Type("tag:yaml.org,2002:omap", { - kind: "sequence", - resolve: resolveYamlOmap, - construct: constructYamlOmap - }); -})); + return { + str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "→") + tail, + pos: position - lineStart + head.length + }; +} +function padStart(string, max) { + return " ".repeat(Math.max(max - string.length, 0)) + string; +} +function makeSnippet(mark, options) { + if (!mark.buffer) return null; + const opts = { + ...DEFAULT_SNIPPET_OPTIONS, + ...options + }; + const re = /\r?\n|\r|\0/g; + const lineStarts = [0]; + const lineEnds = []; + let match; + let foundLineNo = -1; + while (match = re.exec(mark.buffer)) { + lineEnds.push(match.index); + lineStarts.push(match.index + match[0].length); + if (mark.position <= match.index && foundLineNo < 0) foundLineNo = lineStarts.length - 2; + } + if (foundLineNo < 0) foundLineNo = lineStarts.length - 1; + let result = ""; + const lineNoLength = Math.min(mark.line + opts.linesAfter, lineEnds.length).toString().length; + const maxLineLength = opts.maxLength - (opts.indent + lineNoLength + 3); + for (let i = 1; i <= opts.linesBefore; i++) { + if (foundLineNo - i < 0) break; + const line = getLine(mark.buffer, lineStarts[foundLineNo - i], lineEnds[foundLineNo - i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), maxLineLength); + result = `${" ".repeat(opts.indent)}${padStart((mark.line - i + 1).toString(), lineNoLength)} | ${line.str}\n${result}`; + } + const line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength); + result += `${" ".repeat(opts.indent)}${padStart((mark.line + 1).toString(), lineNoLength)} | ${line.str}\n`; + result += `${"-".repeat(opts.indent + lineNoLength + 3 + line.pos)}^\n`; + for (let i = 1; i <= opts.linesAfter; i++) { + if (foundLineNo + i >= lineEnds.length) break; + const line = getLine(mark.buffer, lineStarts[foundLineNo + i], lineEnds[foundLineNo + i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), maxLineLength); + result += `${" ".repeat(opts.indent)}${padStart((mark.line + i + 1).toString(), lineNoLength)} | ${line.str}\n`; + } + return result.replace(/\n$/, ""); +} //#endregion -//#region lib/type/pairs.js -var require_pairs = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var Type = require_type(); - var _toString = Object.prototype.toString; - function resolveYamlPairs(data) { - if (data === null) return true; - const object = data; - const result = new Array(object.length); - for (let index = 0, length = object.length; index < length; index += 1) { - const pair = object[index]; - if (_toString.call(pair) !== "[object Object]") return false; - const keys = Object.keys(pair); - if (keys.length !== 1) return false; - result[index] = [keys[0], pair[keys[0]]]; - } - return true; +//#region src/common/exception.ts +function formatError(exception, compact) { + let where = ""; + if (!exception.mark) return exception.reason; + if (exception.mark.name) where += `in "${exception.mark.name}" `; + where += `(${exception.mark.line + 1}:${exception.mark.column + 1})`; + if (!compact && exception.mark.snippet) where += `\n\n${exception.mark.snippet}`; + return `${exception.reason} ${where}`; +} +var YAMLException = class extends Error { + reason; + mark; + constructor(reason, mark) { + super(); + this.name = "YAMLException"; + this.reason = reason; + this.mark = mark; + this.message = formatError(this, false); + if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor); } - function constructYamlPairs(data) { - if (data === null) return []; - const object = data; - const result = new Array(object.length); - for (let index = 0, length = object.length; index < length; index += 1) { - const pair = object[index]; - const keys = Object.keys(pair); - result[index] = [keys[0], pair[keys[0]]]; + toString(compact) { + return `${this.name}: ${formatError(this, compact)}`; + } +}; +function throwErrorAt(source, position, message, filename = "") { + let line = 0; + let lineStart = 0; + for (let index = 0; index < position; index++) { + const ch = source.charCodeAt(index); + if (ch === 10) { + line++; + lineStart = index + 1; + } else if (ch === 13) { + line++; + if (source.charCodeAt(index + 1) === 10) index++; + lineStart = index + 1; } - return result; } - module.exports = new Type("tag:yaml.org,2002:pairs", { - kind: "sequence", - resolve: resolveYamlPairs, - construct: constructYamlPairs - }); -})); + const mark = { + name: filename, + buffer: source, + position, + line, + column: position - lineStart + }; + mark.snippet = makeSnippet(mark); + throw new YAMLException(message, mark); +} +//#endregion +//#region src/parser/events.ts +var EVENT_DOCUMENT = 1; +var EVENT_SEQUENCE = 2; +var EVENT_MAPPING = 3; +var EVENT_SCALAR = 4; +var EVENT_ALIAS = 5; +var EVENT_POP = 6; +var SCALAR_STYLE_PLAIN = 1; +var SCALAR_STYLE_SINGLE_QUOTED = 2; +var SCALAR_STYLE_DOUBLE_QUOTED = 3; +var SCALAR_STYLE_LITERAL_BLOCK = 4; +var SCALAR_STYLE_FOLDED_BLOCK = 5; +var COLLECTION_STYLE_BLOCK = 1; +var COLLECTION_STYLE_FLOW = 2; +var CHOMPING_CLIP = 1; +var CHOMPING_STRIP = 2; +var CHOMPING_KEEP = 3; //#endregion -//#region lib/type/set.js -var require_set = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var Type = require_type(); - var _hasOwnProperty = Object.prototype.hasOwnProperty; - function resolveYamlSet(data) { - if (data === null) return true; - const object = data; - for (const key in object) if (_hasOwnProperty.call(object, key)) { - if (object[key] !== null) return false; +//#region src/parser/parser_scalar.ts +var NO_RANGE$3 = -1; +function simpleEscapeSequence(c) { + switch (c) { + case 48: return "\0"; + case 97: return "\x07"; + case 98: return "\b"; + case 116: return " "; + case 9: return " "; + case 110: return "\n"; + case 118: return "\v"; + case 102: return "\f"; + case 114: return "\r"; + case 101: return "\x1B"; + case 32: return " "; + case 34: return "\""; + case 47: return "/"; + case 92: return "\\"; + case 78: return "…"; + case 95: return "\xA0"; + case 76: return "\u2028"; + case 80: return "\u2029"; + default: return ""; + } +} +var simpleEscapeCheck = new Array(256); +var simpleEscapeMap = new Array(256); +for (let i = 0; i < 256; i++) { + simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0; + simpleEscapeMap[i] = simpleEscapeSequence(i); +} +function charFromCodepoint(c) { + if (c <= 65535) return String.fromCharCode(c); + return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320); +} +function fromHexCode$1(c) { + if (c >= 48 && c <= 57) return c - 48; + return (c | 32) - 97 + 10; +} +function escapedHexLen$1(c) { + if (c === 120) return 2; + if (c === 117) return 4; + return 8; +} +function skipFoldedBreaks(input, position, end) { + let breaks = 0; + while (position < end) { + const ch = input.charCodeAt(position); + if (ch === 10) { + breaks++; + position++; + } else if (ch === 13) { + breaks++; + position++; + if (input.charCodeAt(position) === 10) position++; + } else if (ch === 32 || ch === 9) position++; + else break; + } + return { + position, + breaks + }; +} +function foldedBreaks(count) { + if (count === 1) return " "; + return "\n".repeat(count - 1); +} +function getPlainValue(input, start, end) { + let result = ""; + let position = start; + let captureStart = start; + let captureEnd = start; + while (position < end) { + const ch = input.charCodeAt(position); + if (ch === 10 || ch === 13) { + result += input.slice(captureStart, captureEnd); + const fold = skipFoldedBreaks(input, position, end); + result += foldedBreaks(fold.breaks); + position = captureStart = captureEnd = fold.position; + } else { + position++; + if (ch !== 32 && ch !== 9) captureEnd = position; } - return true; } - function constructYamlSet(data) { - return data !== null ? data : {}; + return result + input.slice(captureStart, captureEnd); +} +function getSingleQuotedValue(input, start, end) { + let result = ""; + let position = start; + let captureStart = start; + let captureEnd = start; + while (position < end) { + const ch = input.charCodeAt(position); + if (ch === 39) { + result += input.slice(captureStart, position) + "'"; + position += 2; + captureStart = captureEnd = position; + } else if (ch === 10 || ch === 13) { + result += input.slice(captureStart, captureEnd); + const fold = skipFoldedBreaks(input, position, end); + result += foldedBreaks(fold.breaks); + position = captureStart = captureEnd = fold.position; + } else { + position++; + if (ch !== 32 && ch !== 9) captureEnd = position; + } } - module.exports = new Type("tag:yaml.org,2002:set", { - kind: "mapping", - resolve: resolveYamlSet, - construct: constructYamlSet - }); -})); -//#endregion -//#region lib/schema/default.js -var require_default = /* @__PURE__ */ __commonJSMin(((exports, module) => { - module.exports = require_core().extend({ - implicit: [require_timestamp(), require_merge()], - explicit: [ - require_binary(), - require_omap(), - require_pairs(), - require_set() - ] - }); -})); -//#endregion -//#region lib/loader.js -var require_loader = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var common = require_common(); - var YAMLException = require_exception(); - var makeSnippet = require_snippet(); - var DEFAULT_SCHEMA = require_default(); - var _hasOwnProperty = Object.prototype.hasOwnProperty; - var CONTEXT_FLOW_IN = 1; - var CONTEXT_FLOW_OUT = 2; - var CONTEXT_BLOCK_IN = 3; - var CONTEXT_BLOCK_OUT = 4; - var CHOMPING_CLIP = 1; - var CHOMPING_STRIP = 2; - var CHOMPING_KEEP = 3; - var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; - var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/; - var PATTERN_FLOW_INDICATORS = /[,\[\]{}]/; - var PATTERN_TAG_HANDLE = /^(?:!|!!|![0-9A-Za-z-]+!)$/; - var PATTERN_TAG_URI = /^(?:!|[^,\[\]{}])(?:%[0-9a-f]{2}|[0-9a-z\-#;/?:@&=+$,_.!~*'()\[\]])*$/i; - function _class(obj) { - return Object.prototype.toString.call(obj); - } - function isEol(c) { - return c === 10 || c === 13; - } - function isWhiteSpace(c) { - return c === 9 || c === 32; - } - function isWsOrEol(c) { - return c === 9 || c === 32 || c === 10 || c === 13; - } - function isFlowIndicator(c) { - return c === 44 || c === 91 || c === 93 || c === 123 || c === 125; - } - function fromHexCode(c) { - if (c >= 48 && c <= 57) return c - 48; - const lc = c | 32; - if (lc >= 97 && lc <= 102) return lc - 97 + 10; - return -1; - } - function escapedHexLen(c) { - if (c === 120) return 2; - if (c === 117) return 4; - if (c === 85) return 8; - return 0; + return result + input.slice(captureStart, end); +} +function getDoubleQuotedValue(input, start, end) { + let result = ""; + let position = start; + let captureStart = start; + let captureEnd = start; + while (position < end) { + const ch = input.charCodeAt(position); + if (ch === 92) { + result += input.slice(captureStart, position); + position++; + const escaped = input.charCodeAt(position); + if (escaped === 10 || escaped === 13) position = skipFoldedBreaks(input, position, end).position; + else if (escaped < 256 && simpleEscapeCheck[escaped]) { + result += simpleEscapeMap[escaped]; + position++; + } else { + let hexLength = escapedHexLen$1(escaped); + let hexResult = 0; + for (; hexLength > 0; hexLength--) { + position++; + const digit = fromHexCode$1(input.charCodeAt(position)); + hexResult = (hexResult << 4) + digit; + } + result += charFromCodepoint(hexResult); + position++; + } + captureStart = captureEnd = position; + } else if (ch === 10 || ch === 13) { + result += input.slice(captureStart, captureEnd); + const fold = skipFoldedBreaks(input, position, end); + result += foldedBreaks(fold.breaks); + position = captureStart = captureEnd = fold.position; + } else { + position++; + if (ch !== 32 && ch !== 9) captureEnd = position; + } } - function fromDecimalCode(c) { - if (c >= 48 && c <= 57) return c - 48; - return -1; - } - function simpleEscapeSequence(c) { - switch (c) { - case 48: return "\0"; - case 97: return "\x07"; - case 98: return "\b"; - case 116: return " "; - case 9: return " "; - case 110: return "\n"; - case 118: return "\v"; - case 102: return "\f"; - case 114: return "\r"; - case 101: return "\x1B"; - case 32: return " "; - case 34: return "\""; - case 47: return "/"; - case 92: return "\\"; - case 78: return "…"; - case 95: return "\xA0"; - case 76: return "\u2028"; - case 80: return "\u2029"; - default: return ""; + return result + input.slice(captureStart, end); +} +function getBlockValue(input, start, end, indent, chomping, folded) { + const textIndent = indent < 0 ? 0 : indent; + const region = input.slice(start, end).replace(/\r\n?/g, "\n"); + const lines = region === "" ? [] : (region.endsWith("\n") ? region.slice(0, -1) : region).split("\n"); + let result = ""; + let didReadContent = false; + let emptyLines = 0; + let atMoreIndented = false; + for (const line of lines) { + let column = 0; + while (column < textIndent && line.charCodeAt(column) === 32) column++; + if (indent < 0 || column >= line.length) { + emptyLines++; + continue; } + const content = line.slice(textIndent); + const first = content.charCodeAt(0); + if (folded) if (first === 32 || first === 9) { + atMoreIndented = true; + result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines); + } else if (atMoreIndented) { + atMoreIndented = false; + result += "\n".repeat(emptyLines + 1); + } else if (emptyLines === 0) { + if (didReadContent) result += " "; + } else result += "\n".repeat(emptyLines); + else result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines); + result += content; + didReadContent = true; + emptyLines = 0; + } + if (chomping === 3) result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines); + else if (chomping !== 2) { + if (didReadContent) result += "\n"; } - function charFromCodepoint(c) { - if (c <= 65535) return String.fromCharCode(c); - return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320); + return result; +} +function getScalarValue(input, scalar) { + if (scalar.valueStart === NO_RANGE$3) return ""; + const { valueStart, valueEnd } = scalar; + if (scalar.fast) return input.slice(valueStart, valueEnd); + switch (scalar.style) { + case 2: return getSingleQuotedValue(input, valueStart, valueEnd); + case 3: return getDoubleQuotedValue(input, valueStart, valueEnd); + case 4: return getBlockValue(input, valueStart, valueEnd, scalar.indent, scalar.chomping, false); + case 5: return getBlockValue(input, valueStart, valueEnd, scalar.indent, scalar.chomping, true); + default: return getPlainValue(input, valueStart, valueEnd); } - function setProperty(object, key, value) { - if (key === "__proto__") Object.defineProperty(object, key, { - configurable: true, - enumerable: true, - writable: true, - value - }); - else object[key] = value; - } - var simpleEscapeCheck = new Array(256); - var simpleEscapeMap = new Array(256); - for (let i = 0; i < 256; i++) { - simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0; - simpleEscapeMap[i] = simpleEscapeSequence(i); - } - function State(input, options) { - this.input = input; - this.filename = options["filename"] || null; - this.schema = options["schema"] || DEFAULT_SCHEMA; - this.onWarning = options["onWarning"] || null; - this.legacy = options["legacy"] || false; - this.json = options["json"] || false; - this.listener = options["listener"] || null; - this.maxDepth = typeof options["maxDepth"] === "number" ? options["maxDepth"] : 100; - this.maxMergeSeqLength = typeof options["maxMergeSeqLength"] === "number" ? options["maxMergeSeqLength"] : 20; - this.implicitTypes = this.schema.compiledImplicit; - this.typeMap = this.schema.compiledTypeMap; - this.length = input.length; - this.position = 0; - this.line = 0; - this.lineStart = 0; - this.lineIndent = 0; - this.depth = 0; - this.firstTabInLine = -1; - this.documents = []; - this.anchorMapTransactions = []; - } - function generateError(state, message) { - const mark = { - name: state.filename, - buffer: state.input.slice(0, -1), - position: state.position, - line: state.line, - column: state.position - state.lineStart +} +//#endregion +//#region src/common/tagname.ts +var DEFAULT_TAG_HANDLERS = { + "!": "!", + "!!": "tag:yaml.org,2002:" +}; +function tagPercentEncode(source) { + return encodeURI(source).replace(/!/g, "%21"); +} +function tagNameFull(rawTag, tagHandlers) { + if (rawTag.startsWith("!<") && rawTag.endsWith(">")) return decodeURIComponent(rawTag.slice(2, -1)); + const handleEnd = rawTag.indexOf("!", 1); + const handle = handleEnd === -1 ? "!" : rawTag.slice(0, handleEnd + 1); + const prefix = tagHandlers?.[handle] ?? DEFAULT_TAG_HANDLERS[handle] ?? handle; + return decodeURIComponent(prefix) + decodeURIComponent(rawTag.slice(handle.length)); +} +function tagNameShort(fullTag) { + let tag = fullTag; + if (tag.charCodeAt(0) === 33) { + tag = tag.slice(1); + return `!${tagPercentEncode(tag)}`; + } + if (tag.slice(0, 18) === "tag:yaml.org,2002:") return `!!${tagPercentEncode(tag.slice(18))}`; + return `!<${tagPercentEncode(tag)}>`; +} +//#endregion +//#region src/parser/constructor.ts +var NO_RANGE$2 = -1; +var DEFAULT_CONSTRUCTOR_OPTIONS = { + filename: "", + schema: CORE_SCHEMA, + json: false, + maxMergeSeqLength: 20 +}; +function eventPosition$1(event) { + if ("tagStart" in event && event.tagStart !== NO_RANGE$2) return event.tagStart; + if ("anchorStart" in event && event.anchorStart !== NO_RANGE$2) return event.anchorStart; + if ("valueStart" in event && event.valueStart !== NO_RANGE$2) return event.valueStart; + if ("start" in event) return event.start; + return 0; +} +function throwError$1(state, message) { + throwErrorAt(state.source, state.position, message, state.filename); +} +function lookupTag(exact, prefix, tagName) { + const exactTag = exact[tagName]; + if (exactTag) return exactTag; + for (const tag of prefix) if (tagName.startsWith(tag.tagName)) return tag; +} +function findExplicitTag(state, exact, prefix, tagName, nodeKind) { + const tag = lookupTag(exact, prefix, tagName); + if (tag) return tag; + throwError$1(state, `unknown ${nodeKind} tag !<${tagName}>`); +} +function constructScalar(state, event) { + const source = getScalarValue(state.source, event); + const rawTag = event.tagStart === NO_RANGE$2 ? "" : state.source.slice(event.tagStart, event.tagEnd); + const strTag = state.schema.defaultScalarTag; + if (rawTag !== "") { + if (rawTag === "!") return { + value: source, + tag: strTag }; - mark.snippet = makeSnippet(mark); - return new YAMLException(message, mark); - } - function throwError(state, message) { - throw generateError(state, message); - } - function throwWarning(state, message) { - if (state.onWarning) state.onWarning.call(null, generateError(state, message)); - } - function storeAnchor(state, name, value) { - const transactions = state.anchorMapTransactions; - if (transactions.length !== 0) { - const transaction = transactions[transactions.length - 1]; - if (!_hasOwnProperty.call(transaction, name)) transaction[name] = { - existed: _hasOwnProperty.call(state.anchorMap, name), - value: state.anchorMap[name] + const tagName = tagNameFull(rawTag, state.tagHandlers); + const scalarTag = lookupTag(state.schema.exact.scalar, state.schema.prefix.scalar, tagName); + if (scalarTag) { + const result = scalarTag.resolve(source, true, tagName); + if (result === NOT_RESOLVED) throwError$1(state, `cannot resolve a node with !<${tagName}> explicit tag`); + return { + value: result, + tag: scalarTag }; } - state.anchorMap[name] = value; - } - function beginAnchorTransaction(state) { - state.anchorMapTransactions.push(Object.create(null)); - } - function commitAnchorTransaction(state) { - const transaction = state.anchorMapTransactions.pop(); - const transactions = state.anchorMapTransactions; - if (transactions.length === 0) return; - const parent = transactions[transactions.length - 1]; - const names = Object.keys(transaction); - for (let index = 0, length = names.length; index < length; index += 1) { - const name = names[index]; - if (!_hasOwnProperty.call(parent, name)) parent[name] = transaction[name]; + const collectionTagDef = lookupTag(state.schema.exact.mapping, state.schema.prefix.mapping, tagName) ?? lookupTag(state.schema.exact.sequence, state.schema.prefix.sequence, tagName); + if (collectionTagDef) { + if (source !== "") throwError$1(state, `cannot resolve a node with !<${tagName}> explicit tag`); + return { + value: collectionTagDef.create(tagName), + tag: collectionTagDef + }; } - } - function rollbackAnchorTransaction(state) { - const transaction = state.anchorMapTransactions.pop(); - const names = Object.keys(transaction); - for (let index = names.length - 1; index >= 0; index -= 1) { - const entry = transaction[names[index]]; - if (entry.existed) state.anchorMap[names[index]] = entry.value; - else delete state.anchorMap[names[index]]; + throwError$1(state, `unknown scalar tag !<${tagName}>`); + } + if (event.style === 1) { + const candidates = state.schema.implicitScalarByFirstChar.get(source.charAt(0)) ?? state.schema.implicitScalarAnyFirstChar; + for (const tag of candidates) { + const result = tag.resolve(source, false, tag.tagName); + if (result !== NOT_RESOLVED) return { + value: result, + tag + }; } } - function snapshotState(state) { - return { - position: state.position, - line: state.line, - lineStart: state.lineStart, - lineIndent: state.lineIndent, - firstTabInLine: state.firstTabInLine, - tag: state.tag, - anchor: state.anchor, - kind: state.kind, - result: state.result - }; - } - function restoreState(state, snapshot) { - state.position = snapshot.position; - state.line = snapshot.line; - state.lineStart = snapshot.lineStart; - state.lineIndent = snapshot.lineIndent; - state.firstTabInLine = snapshot.firstTabInLine; - state.tag = snapshot.tag; - state.anchor = snapshot.anchor; - state.kind = snapshot.kind; - state.result = snapshot.result; - } - var directiveHandlers = { - YAML: function handleYamlDirective(state, name, args) { - if (state.version !== null) throwError(state, "duplication of %YAML directive"); - if (args.length !== 1) throwError(state, "YAML directive accepts exactly one argument"); - const match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]); - if (match === null) throwError(state, "ill-formed argument of the YAML directive"); - const major = parseInt(match[1], 10); - const minor = parseInt(match[2], 10); - if (major !== 1) throwError(state, "unacceptable YAML version of the document"); - state.version = args[0]; - state.checkLineBreaks = minor < 2; - if (minor !== 1 && minor !== 2) throwWarning(state, "unsupported YAML version of the document"); - }, - TAG: function handleTagDirective(state, name, args) { - let prefix; - if (args.length !== 2) throwError(state, "TAG directive accepts exactly two arguments"); - const handle = args[0]; - prefix = args[1]; - if (!PATTERN_TAG_HANDLE.test(handle)) throwError(state, "ill-formed tag handle (first argument) of the TAG directive"); - if (_hasOwnProperty.call(state.tagMap, handle)) throwError(state, "there is a previously declared suffix for \"" + handle + "\" tag handle"); - if (!PATTERN_TAG_URI.test(prefix)) throwError(state, "ill-formed tag prefix (second argument) of the TAG directive"); - try { - prefix = decodeURIComponent(prefix); - } catch (err) { - throwError(state, "tag prefix is malformed: " + prefix); - } - state.tagMap[handle] = prefix; - } + return { + value: strTag.resolve(source, false, strTag.tagName), + tag: strTag }; - function captureSegment(state, start, end, checkJson) { - if (start < end) { - const _result = state.input.slice(start, end); - if (checkJson) for (let _position = 0, _length = _result.length; _position < _length; _position += 1) { - const _character = _result.charCodeAt(_position); - if (!(_character === 9 || _character >= 32 && _character <= 1114111)) throwError(state, "expected valid JSON character"); - } - else if (PATTERN_NON_PRINTABLE.test(_result)) throwError(state, "the stream contains non-printable characters"); - state.result += _result; +} +function collectionTag(state, event, exact, prefix, defaultTagName, nodeKind) { + const rawTag = event.tagStart === NO_RANGE$2 ? "" : state.source.slice(event.tagStart, event.tagEnd); + const tagName = rawTag === "" || rawTag === "!" ? defaultTagName : tagNameFull(rawTag, state.tagHandlers); + return { + tagName, + tag: findExplicitTag(state, exact, prefix, tagName, nodeKind) + }; +} +function isMappingTag(tag) { + return tag.nodeKind === "mapping"; +} +function mergeKeys(state, frame, source, sourceTag) { + for (const sourceKey of sourceTag.keys(source)) { + if (frame.tag.has(frame.value, sourceKey)) continue; + const err = frame.tag.addPair(frame.value, sourceKey, sourceTag.get(source, sourceKey)); + if (err) throwError$1(state, err); + (frame.overridable ??= /* @__PURE__ */ new Set()).add(sourceKey); + } +} +function mergeSource(state, frame, source, sourceTag) { + state.position = frame.keyPosition; + if (isMappingTag(sourceTag)) mergeKeys(state, frame, source, sourceTag); + else if (sourceTag.nodeKind === "sequence" && Array.isArray(source)) { + const seen = /* @__PURE__ */ new Set(); + for (const element of source) { + if (seen.has(element)) continue; + seen.add(element); + mergeKeys(state, frame, element, frame.tag); } + } else throwError$1(state, "cannot merge mappings; the provided source object is unacceptable"); +} +function addMappingValue(state, frame, key, value, tag) { + state.position = frame.keyPosition; + if (key === MERGE_KEY) { + mergeSource(state, frame, value, tag); + return; } - function mergeMappings(state, destination, source, overridableKeys) { - if (!common.isObject(source)) throwError(state, "cannot merge mappings; the provided source object is unacceptable"); - const sourceKeys = Object.keys(source); - for (let index = 0, quantity = sourceKeys.length; index < quantity; index += 1) { - const key = sourceKeys[index]; - if (!_hasOwnProperty.call(destination, key)) { - setProperty(destination, key, source[key]); - overridableKeys[key] = true; - } + if (!state.json && frame.tag.has(frame.value, key) && !frame.overridable?.has(key)) throwError$1(state, "duplicated mapping key"); + const err = frame.tag.addPair(frame.value, key, value); + if (err) throwError$1(state, err); + frame.overridable?.delete(key); +} +function addValue(state, value, tag) { + const frame = state.frames[state.frames.length - 1]; + if (frame.kind === "document") { + frame.value = value; + frame.hasValue = true; + } else if (frame.kind === "sequence") { + if (frame.merge) { + if (!isMappingTag(tag)) throwError$1(state, "cannot merge mappings; the provided source object is unacceptable"); + if (frame.index >= state.maxMergeSeqLength) throwError$1(state, `merge sequence length exceeded maxMergeSeqLength (${state.maxMergeSeqLength})`); } + const err = frame.tag.addItem(frame.value, value, frame.index++); + if (err) throwError$1(state, err); + } else if (frame.hasKey) { + const key = frame.key; + frame.key = void 0; + frame.hasKey = false; + addMappingValue(state, frame, key, value, tag); + } else { + frame.key = value; + frame.keyPosition = state.position; + frame.hasKey = true; } - function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) { - if (Array.isArray(keyNode)) { - keyNode = Array.prototype.slice.call(keyNode); - for (let index = 0, quantity = keyNode.length; index < quantity; index += 1) { - if (Array.isArray(keyNode[index])) throwError(state, "nested arrays are not supported inside keys"); - if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") keyNode[index] = "[object Object]"; +} +function storeAnchor(state, event, value, tag) { + if (event.anchorStart !== NO_RANGE$2) state.anchors.set(state.source.slice(event.anchorStart, event.anchorEnd), { + value, + tag + }); +} +function constructFromEvents(events, options) { + const state = { + ...DEFAULT_CONSTRUCTOR_OPTIONS, + ...options, + events, + documents: [], + eventIndex: 0, + position: 0, + frames: [], + anchors: /* @__PURE__ */ new Map(), + tagHandlers: Object.create(null) + }; + while (state.eventIndex < state.events.length) { + const event = state.events[state.eventIndex++]; + state.position = eventPosition$1(event); + switch (event.type) { + case 1: + state.anchors = /* @__PURE__ */ new Map(); + state.tagHandlers = Object.create(null); + for (const directive of event.directives) if (directive.kind === "tag") state.tagHandlers[directive.handle] = directive.prefix; + state.frames.push({ + kind: "document", + position: state.position, + value: void 0, + hasValue: false + }); + break; + case 4: { + const { value, tag } = constructScalar(state, event); + storeAnchor(state, event, value, tag); + addValue(state, value, tag); + break; } - } - if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") keyNode = "[object Object]"; - keyNode = String(keyNode); - if (_result === null) _result = {}; - if (keyTag === "tag:yaml.org,2002:merge") if (Array.isArray(valueNode)) { - if (valueNode.length > state.maxMergeSeqLength) throwError(state, "merge sequence length exceeded maxMergeSeqLength (" + state.maxMergeSeqLength + ")"); - const seen = /* @__PURE__ */ new Set(); - for (let index = 0, quantity = valueNode.length; index < quantity; index += 1) { - const src = valueNode[index]; - if (seen.has(src)) continue; - seen.add(src); - mergeMappings(state, _result, src, overridableKeys); + case 2: { + const definition = collectionTag(state, event, state.schema.exact.sequence, state.schema.prefix.sequence, "tag:yaml.org,2002:seq", "sequence"); + const value = definition.tag.create(definition.tagName); + storeAnchor(state, event, value, definition.tag); + const parent = state.frames[state.frames.length - 1]; + const merge = parent !== void 0 && parent.kind === "mapping" && parent.hasKey && parent.key === MERGE_KEY; + state.frames.push({ + kind: "sequence", + position: state.position, + value, + tag: definition.tag, + index: 0, + merge + }); + break; } - } else mergeMappings(state, _result, valueNode, overridableKeys); - else { - if (!state.json && !_hasOwnProperty.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) { - state.line = startLine || state.line; - state.lineStart = startLineStart || state.lineStart; - state.position = startPos || state.position; - throwError(state, "duplicated mapping key"); + case 3: { + const definition = collectionTag(state, event, state.schema.exact.mapping, state.schema.prefix.mapping, "tag:yaml.org,2002:map", "mapping"); + const value = definition.tag.create(definition.tagName); + storeAnchor(state, event, value, definition.tag); + state.frames.push({ + kind: "mapping", + position: state.position, + value, + tag: definition.tag, + key: void 0, + keyPosition: state.position, + hasKey: false, + overridable: null + }); + break; } - setProperty(_result, keyNode, valueNode); - delete overridableKeys[keyNode]; - } - return _result; - } - function readLineBreak(state) { - const ch = state.input.charCodeAt(state.position); - if (ch === 10) state.position++; - else if (ch === 13) { - state.position++; - if (state.input.charCodeAt(state.position) === 10) state.position++; - } else throwError(state, "a line break is expected"); - state.line += 1; - state.lineStart = state.position; - state.firstTabInLine = -1; - } - function skipSeparationSpace(state, allowComments, checkIndent) { - let lineBreaks = 0; - let ch = state.input.charCodeAt(state.position); - while (ch !== 0) { - while (isWhiteSpace(ch)) { - if (ch === 9 && state.firstTabInLine === -1) state.firstTabInLine = state.position; - ch = state.input.charCodeAt(++state.position); + case 5: { + const name = state.source.slice(event.anchorStart, event.anchorEnd); + const anchor = state.anchors.get(name); + if (!anchor) throwError$1(state, `unidentified alias "${name}"`); + addValue(state, anchor.value, anchor.tag); + break; + } + case 6: { + const frame = state.frames.pop(); + if (frame.kind === "document") state.documents.push(frame.value); + else addValue(state, frame.value, frame.tag); + break; } - if (allowComments && ch === 35) do - ch = state.input.charCodeAt(++state.position); - while (ch !== 10 && ch !== 13 && ch !== 0); - if (isEol(ch)) { - readLineBreak(state); - ch = state.input.charCodeAt(state.position); - lineBreaks++; - state.lineIndent = 0; - while (ch === 32) { - state.lineIndent++; - ch = state.input.charCodeAt(++state.position); - } - } else break; - } - if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) throwWarning(state, "deficient indentation"); - return lineBreaks; - } - function testDocumentSeparator(state) { - let _position = state.position; - let ch = state.input.charCodeAt(_position); - if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) { - _position += 3; - ch = state.input.charCodeAt(_position); - if (ch === 0 || isWsOrEol(ch)) return true; } - return false; } - function writeFoldedLines(state, count) { - if (count === 1) state.result += " "; - else if (count > 1) state.result += common.repeat("\n", count - 1); - } - function readPlainScalar(state, nodeIndent, withinFlowCollection) { - let captureStart; - let captureEnd; - let hasPendingContent; - let _line; - let _lineStart; - let _lineIndent; - const _kind = state.kind; - const _result = state.result; - let ch = state.input.charCodeAt(state.position); - if (isWsOrEol(ch) || isFlowIndicator(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) return false; - if (ch === 63 || ch === 45) { - const following = state.input.charCodeAt(state.position + 1); - if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following)) return false; + return state.documents; +} +//#endregion +//#region src/parser/parser.ts +var NO_RANGE$1 = -1; +var HAS_OWN = Object.prototype.hasOwnProperty; +var CONTEXT_FLOW_IN = 1; +var CONTEXT_FLOW_OUT = 2; +var CONTEXT_BLOCK_IN = 3; +var CONTEXT_BLOCK_OUT = 4; +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_FLOW_INDICATORS = /[,\[\]{}]/; +var PATTERN_TAG_HANDLE = /^(?:!|!!|![0-9A-Za-z-]+!)$/; +var NS_URI_CHAR = String.raw`(?:%[0-9A-Fa-f]{2}|[0-9A-Za-z\-#;/?:@&=+$,_.!~*'()\[\]])`; +var NS_TAG_CHAR = String.raw`(?:%[0-9A-Fa-f]{2}|[0-9A-Za-z\-#;/?:@&=+$.~*'()_])`; +var PATTERN_TAG_URI = new RegExp(`^(?:${NS_URI_CHAR})*$`); +var PATTERN_TAG_SUFFIX = new RegExp(`^(?:${NS_TAG_CHAR})+$`); +var PATTERN_TAG_PREFIX = new RegExp(`^(?:!(?:${NS_URI_CHAR})*|${NS_TAG_CHAR}(?:${NS_URI_CHAR})*)$`); +var DEFAULT_PARSER_OPTIONS = { + filename: "", + maxDepth: 100 +}; +function addDocumentEvent(state, explicitStart, explicitEnd) { + state.events.push({ + type: 1, + explicitStart, + explicitEnd, + directives: state.directives + }); +} +function addSequenceEvent(state, start, anchorStart, anchorEnd, tagStart, tagEnd, style) { + state.events.push({ + type: 2, + start, + anchorStart, + anchorEnd, + tagStart, + tagEnd, + style + }); +} +function addMappingEvent(state, start, anchorStart, anchorEnd, tagStart, tagEnd, style) { + state.events.push({ + type: 3, + start, + anchorStart, + anchorEnd, + tagStart, + tagEnd, + style + }); +} +function addScalarEvent(state, valueStart, valueEnd, anchorStart, anchorEnd, tagStart, tagEnd, style, chomping = 1, indent = -1, fast = false) { + state.events.push({ + type: 4, + valueStart, + valueEnd, + anchorStart, + anchorEnd, + tagStart, + tagEnd, + style, + chomping, + indent, + fast + }); +} +function addAliasEvent(state, anchorStart, anchorEnd) { + state.events.push({ + type: 5, + anchorStart, + anchorEnd + }); +} +function addPopEvent(state) { + state.events.push({ type: 6 }); +} +function addEmptyScalarEvent(state) { + addScalarEvent(state, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, 1); +} +function emptyProperties() { + return { + anchorStart: NO_RANGE$1, + anchorEnd: NO_RANGE$1, + tagStart: NO_RANGE$1, + tagEnd: NO_RANGE$1 + }; +} +function snapshotState(state) { + return { + position: state.position, + line: state.line, + lineStart: state.lineStart, + lineIndent: state.lineIndent, + firstTabInLine: state.firstTabInLine, + eventsLength: state.events.length + }; +} +function restoreState(state, snapshot) { + state.position = snapshot.position; + state.line = snapshot.line; + state.lineStart = snapshot.lineStart; + state.lineIndent = snapshot.lineIndent; + state.firstTabInLine = snapshot.firstTabInLine; + state.events.length = snapshot.eventsLength; +} +function throwError(state, message) { + throwErrorAt(state.input.slice(0, state.length), state.position, message, state.filename); +} +function isEol(c) { + return c === 10 || c === 13; +} +function isWhiteSpace(c) { + return c === 9 || c === 32; +} +function isWsOrEol(c) { + return isWhiteSpace(c) || isEol(c); +} +function isWsOrEolOrEnd(c) { + return c === 0 || isWsOrEol(c); +} +function isFlowIndicator(c) { + return c === 44 || c === 91 || c === 93 || c === 123 || c === 125; +} +function fromDecimalCode(c) { + return c >= 48 && c <= 57 ? c - 48 : -1; +} +function fromHexCode(c) { + if (c >= 48 && c <= 57) return c - 48; + const lc = c | 32; + if (lc >= 97 && lc <= 102) return lc - 97 + 10; + return -1; +} +function escapedHexLen(c) { + if (c === 120) return 2; + if (c === 117) return 4; + if (c === 85) return 8; + return 0; +} +function isSimpleEscape(c) { + return c === 48 || c === 97 || c === 98 || c === 116 || c === 9 || c === 110 || c === 118 || c === 102 || c === 114 || c === 101 || c === 32 || c === 34 || c === 47 || c === 92 || c === 78 || c === 95 || c === 76 || c === 80; +} +function consumeLineBreak(state) { + if (state.input.charCodeAt(state.position) === 10) state.position++; + else { + state.position++; + if (state.input.charCodeAt(state.position) === 10) state.position++; + } + state.line++; + state.lineStart = state.position; + state.lineIndent = 0; + state.firstTabInLine = -1; +} +function skipSeparationSpace(state, allowComments) { + let lineBreaks = 0; + let ch = state.input.charCodeAt(state.position); + let hasSeparation = state.position === state.lineStart || isWsOrEol(state.input.charCodeAt(state.position - 1)); + while (ch !== 0) { + while (isWhiteSpace(ch)) { + hasSeparation = true; + if (ch === 9 && state.firstTabInLine === -1) state.firstTabInLine = state.position; + ch = state.input.charCodeAt(++state.position); } - state.kind = "scalar"; - state.result = ""; - captureStart = captureEnd = state.position; - hasPendingContent = false; - while (ch !== 0) { - if (ch === 58) { - const following = state.input.charCodeAt(state.position + 1); - if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following)) break; - } else if (ch === 35) { - if (isWsOrEol(state.input.charCodeAt(state.position - 1))) break; - } else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && isFlowIndicator(ch)) break; - else if (isEol(ch)) { - _line = state.line; - _lineStart = state.lineStart; - _lineIndent = state.lineIndent; - skipSeparationSpace(state, false, -1); - if (state.lineIndent >= nodeIndent) { - hasPendingContent = true; - ch = state.input.charCodeAt(state.position); - continue; - } else { - state.position = captureEnd; - state.line = _line; - state.lineStart = _lineStart; - state.lineIndent = _lineIndent; - break; - } - } - if (hasPendingContent) { - captureSegment(state, captureStart, captureEnd, false); - writeFoldedLines(state, state.line - _line); - captureStart = captureEnd = state.position; - hasPendingContent = false; - } - if (!isWhiteSpace(ch)) captureEnd = state.position + 1; + if (allowComments && hasSeparation && ch === 35) do + ch = state.input.charCodeAt(++state.position); + while (!isEol(ch) && ch !== 0); + if (!isEol(ch)) break; + consumeLineBreak(state); + lineBreaks++; + hasSeparation = true; + ch = state.input.charCodeAt(state.position); + while (ch === 32) { + state.lineIndent++; ch = state.input.charCodeAt(++state.position); } - captureSegment(state, captureStart, captureEnd, false); - if (state.result) return true; - state.kind = _kind; - state.result = _result; - return false; } - function readSingleQuotedScalar(state, nodeIndent) { - let captureStart; - let captureEnd; - let ch = state.input.charCodeAt(state.position); - if (ch !== 39) return false; - state.kind = "scalar"; - state.result = ""; + return lineBreaks; +} +function testDocumentSeparator(state, position = state.position) { + const ch = state.input.charCodeAt(position); + if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(position + 1) && ch === state.input.charCodeAt(position + 2)) { + const following = state.input.charCodeAt(position + 3); + return following === 0 || isWsOrEol(following); + } + return false; +} +function skipUntilLineEnd(state) { + let ch = state.input.charCodeAt(state.position); + while (ch !== 0 && !isEol(ch)) ch = state.input.charCodeAt(++state.position); +} +function checkPrintable(state, start, end) { + if (PATTERN_NON_PRINTABLE.test(state.input.slice(start, end))) throwError(state, "the stream contains non-printable characters"); +} +function readTagProperty(state, props, inFlow) { + if (state.input.charCodeAt(state.position) !== 33) return false; + if (props.tagStart !== NO_RANGE$1) throwError(state, "duplication of a tag property"); + const start = state.position; + let isVerbatim = false; + let isNamed = false; + let tagHandle = "!"; + let ch = state.input.charCodeAt(++state.position); + if (ch === 60) { + isVerbatim = true; + ch = state.input.charCodeAt(++state.position); + } else if (ch === 33) { + isNamed = true; + tagHandle = "!!"; + ch = state.input.charCodeAt(++state.position); + } + let suffixStart = state.position; + let tagName; + if (isVerbatim) { + while (ch !== 0 && ch !== 62) ch = state.input.charCodeAt(++state.position); + if (ch !== 62) throwError(state, "unexpected end of the stream within a verbatim tag"); + tagName = state.input.slice(suffixStart, state.position); state.position++; - captureStart = captureEnd = state.position; - while ((ch = state.input.charCodeAt(state.position)) !== 0) if (ch === 39) { - captureSegment(state, captureStart, state.position, true); + } else { + while (ch !== 0 && !isWsOrEol(ch) && !(inFlow && isFlowIndicator(ch))) { + if (ch === 33) if (!isNamed) { + tagHandle = state.input.slice(suffixStart - 1, state.position + 1); + if (!PATTERN_TAG_HANDLE.test(tagHandle)) throwError(state, "named tag handle cannot contain such characters"); + isNamed = true; + suffixStart = state.position + 1; + } else throwError(state, "tag suffix cannot contain exclamation marks"); ch = state.input.charCodeAt(++state.position); - if (ch === 39) { - captureStart = state.position; - state.position++; - captureEnd = state.position; - } else return true; - } else if (isEol(ch)) { - captureSegment(state, captureStart, captureEnd, true); - writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); - captureStart = captureEnd = state.position; - } else if (state.position === state.lineStart && testDocumentSeparator(state)) throwError(state, "unexpected end of the document within a single quoted scalar"); - else { + } + tagName = state.input.slice(suffixStart, state.position); + if (PATTERN_FLOW_INDICATORS.test(tagName)) throwError(state, "tag suffix cannot contain flow indicator characters"); + } + if (tagName && !(isVerbatim ? PATTERN_TAG_URI.test(tagName) : PATTERN_TAG_SUFFIX.test(tagName))) throwError(state, `tag name cannot contain such characters: ${tagName}`); + if (!isVerbatim && tagHandle !== "!" && tagHandle !== "!!" && !HAS_OWN.call(state.tagHandlers, tagHandle)) throwError(state, `undeclared tag handle "${tagHandle}"`); + props.tagStart = start; + props.tagEnd = state.position; + return true; +} +function readAnchorProperty(state, props) { + if (state.input.charCodeAt(state.position) !== 38) return false; + if (props.anchorStart !== NO_RANGE$1) throwError(state, "duplication of an anchor property"); + state.position++; + const start = state.position; + while (state.input.charCodeAt(state.position) !== 0 && !isWsOrEol(state.input.charCodeAt(state.position)) && !isFlowIndicator(state.input.charCodeAt(state.position))) state.position++; + if (state.position === start) throwError(state, "name of an anchor node must contain at least one character"); + props.anchorStart = start; + props.anchorEnd = state.position; + return true; +} +function readAlias(state, props) { + if (state.input.charCodeAt(state.position) !== 42) return false; + if (props.anchorStart !== NO_RANGE$1 || props.tagStart !== NO_RANGE$1) throwError(state, "alias node should not have any properties"); + state.position++; + const start = state.position; + while (state.input.charCodeAt(state.position) !== 0 && !isWsOrEol(state.input.charCodeAt(state.position)) && !isFlowIndicator(state.input.charCodeAt(state.position))) state.position++; + if (state.position === start) throwError(state, "name of an alias node must contain at least one character"); + addAliasEvent(state, start, state.position); + return true; +} +function readFlowScalarBreak(state, nodeIndent) { + skipSeparationSpace(state, false); + if (state.lineIndent < nodeIndent) throwError(state, "deficient indentation"); +} +function readSingleQuotedScalar(state, nodeIndent, props) { + if (state.input.charCodeAt(state.position) !== 39) return false; + state.position++; + const start = state.position; + let simple = true; + while (state.input.charCodeAt(state.position) !== 0) { + const ch = state.input.charCodeAt(state.position); + if (ch === 39) { + if (state.input.charCodeAt(state.position + 1) === 39) { + simple = false; + state.position += 2; + continue; + } + const end = state.position; state.position++; - if (!isWhiteSpace(ch)) captureEnd = state.position; + addScalarEvent(state, start, end, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 2, 1, -1, simple); + return true; } - throwError(state, "unexpected end of the stream within a single quoted scalar"); + if (isEol(ch)) { + simple = false; + readFlowScalarBreak(state, nodeIndent); + } else if (state.position === state.lineStart && testDocumentSeparator(state)) throwError(state, "unexpected end of the document within a single quoted scalar"); + else if (ch !== 9 && ch < 32) throwError(state, "expected valid JSON character"); + else state.position++; } - function readDoubleQuotedScalar(state, nodeIndent) { - let captureStart; - let captureEnd; - let tmp; - let ch = state.input.charCodeAt(state.position); - if (ch !== 34) return false; - state.kind = "scalar"; - state.result = ""; - state.position++; - captureStart = captureEnd = state.position; - while ((ch = state.input.charCodeAt(state.position)) !== 0) if (ch === 34) { - captureSegment(state, captureStart, state.position, true); + throwError(state, "unexpected end of the stream within a single quoted scalar"); +} +function readDoubleQuotedScalar(state, nodeIndent, props) { + if (state.input.charCodeAt(state.position) !== 34) return false; + state.position++; + const start = state.position; + let simple = true; + while (state.input.charCodeAt(state.position) !== 0) { + const ch = state.input.charCodeAt(state.position); + if (ch === 34) { + const end = state.position; state.position++; + addScalarEvent(state, start, end, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 3, 1, -1, simple); return true; - } else if (ch === 92) { - captureSegment(state, captureStart, state.position, true); - ch = state.input.charCodeAt(++state.position); - if (isEol(ch)) skipSeparationSpace(state, false, nodeIndent); - else if (ch < 256 && simpleEscapeCheck[ch]) { - state.result += simpleEscapeMap[ch]; - state.position++; - } else if ((tmp = escapedHexLen(ch)) > 0) { - let hexLength = tmp; - let hexResult = 0; - for (; hexLength > 0; hexLength--) { - ch = state.input.charCodeAt(++state.position); - if ((tmp = fromHexCode(ch)) >= 0) hexResult = (hexResult << 4) + tmp; - else throwError(state, "expected hexadecimal character"); + } + if (ch === 92) { + simple = false; + const escaped = state.input.charCodeAt(++state.position); + if (isEol(escaped)) readFlowScalarBreak(state, nodeIndent); + else if (isSimpleEscape(escaped)) state.position++; + else { + let hexLength = escapedHexLen(escaped); + if (hexLength === 0) throwError(state, "unknown escape sequence"); + while (hexLength-- > 0) { + state.position++; + if (fromHexCode(state.input.charCodeAt(state.position)) < 0) throwError(state, "expected hexadecimal character"); } - state.result += charFromCodepoint(hexResult); state.position++; - } else throwError(state, "unknown escape sequence"); - captureStart = captureEnd = state.position; + } } else if (isEol(ch)) { - captureSegment(state, captureStart, captureEnd, true); - writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); - captureStart = captureEnd = state.position; + simple = false; + readFlowScalarBreak(state, nodeIndent); } else if (state.position === state.lineStart && testDocumentSeparator(state)) throwError(state, "unexpected end of the document within a double quoted scalar"); - else { + else if (ch !== 9 && ch < 32) throwError(state, "expected valid JSON character"); + else state.position++; + } + throwError(state, "unexpected end of the stream within a double quoted scalar"); +} +function readBlockScalar(state, parentIndent, props) { + const ch = state.input.charCodeAt(state.position); + let chomping = 1; + let indent = -1; + let detectedIndent = false; + if (ch !== 124 && ch !== 62) return false; + const style = ch === 124 ? 4 : 5; + state.position++; + while (state.input.charCodeAt(state.position) !== 0) { + const current = state.input.charCodeAt(state.position); + const digit = fromDecimalCode(current); + if (current === 43 || current === 45) { + if (chomping !== 1) throwError(state, "repeat of a chomping mode identifier"); + chomping = current === 43 ? 3 : 2; state.position++; - if (!isWhiteSpace(ch)) captureEnd = state.position; - } - throwError(state, "unexpected end of the stream within a double quoted scalar"); - } - function readFlowCollection(state, nodeIndent) { - let readNext = true; - let _line; - let _lineStart; - let _pos; - const _tag = state.tag; - let _result; - const _anchor = state.anchor; - let terminator; - let isPair; - let isExplicitPair; - let isMapping; - const overridableKeys = Object.create(null); - let keyNode; - let keyTag; - let valueNode; - let ch = state.input.charCodeAt(state.position); - if (ch === 91) { - terminator = 93; - isMapping = false; - _result = []; - } else if (ch === 123) { - terminator = 125; - isMapping = true; - _result = {}; - } else return false; - if (state.anchor !== null) storeAnchor(state, state.anchor, _result); - ch = state.input.charCodeAt(++state.position); - while (ch !== 0) { - skipSeparationSpace(state, true, nodeIndent); - ch = state.input.charCodeAt(state.position); - if (ch === terminator) { - state.position++; - state.tag = _tag; - state.anchor = _anchor; - state.kind = isMapping ? "mapping" : "sequence"; - state.result = _result; - return true; - } else if (!readNext) throwError(state, "missed comma between flow collection entries"); - else if (ch === 44) throwError(state, "expected the node content, but found ','"); - keyTag = keyNode = valueNode = null; - isPair = isExplicitPair = false; - if (ch === 63) { - if (isWsOrEol(state.input.charCodeAt(state.position + 1))) { - isPair = isExplicitPair = true; - state.position++; - skipSeparationSpace(state, true, nodeIndent); - } - } - _line = state.line; - _lineStart = state.lineStart; - _pos = state.position; - composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); - keyTag = state.tag; - keyNode = state.result; - skipSeparationSpace(state, true, nodeIndent); - ch = state.input.charCodeAt(state.position); - if ((isExplicitPair || state.line === _line) && ch === 58) { - isPair = true; - ch = state.input.charCodeAt(++state.position); - skipSeparationSpace(state, true, nodeIndent); - composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); - valueNode = state.result; - } - if (isMapping) storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos); - else if (isPair) _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos)); - else _result.push(keyNode); - skipSeparationSpace(state, true, nodeIndent); - ch = state.input.charCodeAt(state.position); - if (ch === 44) { - readNext = true; - ch = state.input.charCodeAt(++state.position); - } else readNext = false; - } - throwError(state, "unexpected end of the stream within a flow collection"); - } - function readBlockScalar(state, nodeIndent) { - let folding; - let chomping = CHOMPING_CLIP; - let didReadContent = false; - let detectedIndent = false; - let textIndent = nodeIndent; - let emptyLines = 0; - let atMoreIndented = false; - let tmp; - let ch = state.input.charCodeAt(state.position); - if (ch === 124) folding = false; - else if (ch === 62) folding = true; - else return false; - state.kind = "scalar"; - state.result = ""; - while (ch !== 0) { - ch = state.input.charCodeAt(++state.position); - if (ch === 43 || ch === 45) if (CHOMPING_CLIP === chomping) chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP; - else throwError(state, "repeat of a chomping mode identifier"); - else if ((tmp = fromDecimalCode(ch)) >= 0) if (tmp === 0) throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one"); - else if (!detectedIndent) { - textIndent = nodeIndent + tmp - 1; - detectedIndent = true; - } else throwError(state, "repeat of an indentation width identifier"); - else break; - } - if (isWhiteSpace(ch)) { - do - ch = state.input.charCodeAt(++state.position); - while (isWhiteSpace(ch)); - if (ch === 35) do - ch = state.input.charCodeAt(++state.position); - while (!isEol(ch) && ch !== 0); - } - while (ch !== 0) { - readLineBreak(state); - state.lineIndent = 0; - ch = state.input.charCodeAt(state.position); - while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) { - state.lineIndent++; - ch = state.input.charCodeAt(++state.position); - } - if (!detectedIndent && state.lineIndent > textIndent) textIndent = state.lineIndent; - if (isEol(ch)) { - emptyLines++; - continue; - } - if (!detectedIndent && textIndent === 0) throwError(state, "missing indentation for block scalar"); - if (state.lineIndent < textIndent) { - if (chomping === CHOMPING_KEEP) state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); - else if (chomping === CHOMPING_CLIP) { - if (didReadContent) state.result += "\n"; - } - break; - } - if (folding) if (isWhiteSpace(ch)) { - atMoreIndented = true; - state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); - } else if (atMoreIndented) { - atMoreIndented = false; - state.result += common.repeat("\n", emptyLines + 1); - } else if (emptyLines === 0) { - if (didReadContent) state.result += " "; - } else state.result += common.repeat("\n", emptyLines); - else state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); - didReadContent = true; + } else if (digit >= 0) { + if (digit === 0) throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one"); + if (detectedIndent) throwError(state, "repeat of an indentation width identifier"); + indent = parentIndent + digit - 1; detectedIndent = true; - emptyLines = 0; - const captureStart = state.position; - while (!isEol(ch) && ch !== 0) ch = state.input.charCodeAt(++state.position); - captureSegment(state, captureStart, state.position, false); - } - return true; - } - function readBlockSequence(state, nodeIndent) { - const _tag = state.tag; - const _anchor = state.anchor; - const _result = []; - let detected = false; - if (state.firstTabInLine !== -1) return false; - if (state.anchor !== null) storeAnchor(state, state.anchor, _result); - let ch = state.input.charCodeAt(state.position); - while (ch !== 0) { - if (state.firstTabInLine !== -1) { - state.position = state.firstTabInLine; - throwError(state, "tab characters must not be used in indentation"); - } - if (ch !== 45) break; - if (!isWsOrEol(state.input.charCodeAt(state.position + 1))) break; - detected = true; state.position++; - if (skipSeparationSpace(state, true, -1)) { - if (state.lineIndent <= nodeIndent) { - _result.push(null); - ch = state.input.charCodeAt(state.position); - continue; - } - } - const _line = state.line; - composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true); - _result.push(state.result); - skipSeparationSpace(state, true, -1); - ch = state.input.charCodeAt(state.position); - if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) throwError(state, "bad indentation of a sequence entry"); - else if (state.lineIndent < nodeIndent) break; - } - if (detected) { - state.tag = _tag; - state.anchor = _anchor; - state.kind = "sequence"; - state.result = _result; - return true; - } - return false; + } else break; } - function readBlockMapping(state, nodeIndent, flowIndent) { - let allowCompact; - let _keyLine; - let _keyLineStart; - let _keyPos; - const _tag = state.tag; - const _anchor = state.anchor; - const _result = {}; - const overridableKeys = Object.create(null); - let keyTag = null; - let keyNode = null; - let valueNode = null; - let atExplicitKey = false; - let detected = false; - if (state.firstTabInLine !== -1) return false; - if (state.anchor !== null) storeAnchor(state, state.anchor, _result); - let ch = state.input.charCodeAt(state.position); - while (ch !== 0) { - if (!atExplicitKey && state.firstTabInLine !== -1) { - state.position = state.firstTabInLine; - throwError(state, "tab characters must not be used in indentation"); - } - const following = state.input.charCodeAt(state.position + 1); - const _line = state.line; - if ((ch === 63 || ch === 58) && isWsOrEol(following)) { - if (ch === 63) { - if (atExplicitKey) { - storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); - keyTag = keyNode = valueNode = null; - } - detected = true; - atExplicitKey = true; - allowCompact = true; - } else if (atExplicitKey) { - atExplicitKey = false; - allowCompact = true; - } else throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line"); - state.position += 1; - ch = following; - } else { - _keyLine = state.line; - _keyLineStart = state.lineStart; - _keyPos = state.position; - if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) break; - if (state.line === _line) { - ch = state.input.charCodeAt(state.position); - while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position); - if (ch === 58) { - ch = state.input.charCodeAt(++state.position); - if (!isWsOrEol(ch)) throwError(state, "a whitespace character is expected after the key-value separator within a block mapping"); - if (atExplicitKey) { - storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); - keyTag = keyNode = valueNode = null; - } - detected = true; - atExplicitKey = false; - allowCompact = false; - keyTag = state.tag; - keyNode = state.result; - } else if (detected) throwError(state, "can not read an implicit mapping pair; a colon is missed"); - else { - state.tag = _tag; - state.anchor = _anchor; - return true; - } - } else if (detected) throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key"); - else { - state.tag = _tag; - state.anchor = _anchor; - return true; - } + let hadWhitespace = false; + while (isWhiteSpace(state.input.charCodeAt(state.position))) { + hadWhitespace = true; + state.position++; + } + if (hadWhitespace && state.input.charCodeAt(state.position) === 35) skipUntilLineEnd(state); + if (isEol(state.input.charCodeAt(state.position))) consumeLineBreak(state); + else if (state.input.charCodeAt(state.position) !== 0) throwError(state, "a line break is expected"); + let contentIndent = detectedIndent ? indent : -1; + let maxLeadingIndent = 0; + const valueStart = state.position; + let valueEnd = state.position; + while (state.input.charCodeAt(state.position) !== 0) { + const linePosition = state.position; + let column = 0; + while (state.input.charCodeAt(linePosition + column) === 32) column++; + const first = state.input.charCodeAt(linePosition + column); + if (first === 0) { + if (contentIndent >= 0) { + if (column > contentIndent) valueEnd = linePosition + column; + } else if (column > 0) valueEnd = linePosition + column; + break; + } + if (linePosition === state.lineStart && testDocumentSeparator(state, linePosition)) break; + if (!detectedIndent && contentIndent === -1 && isEol(first)) maxLeadingIndent = Math.max(maxLeadingIndent, column); + if (!detectedIndent && contentIndent === -1 && !isEol(first)) { + if (first === 9 && column < parentIndent) { + state.position = linePosition + column; + throwError(state, "tab characters must not be used in indentation"); } - if (state.line === _line || state.lineIndent > nodeIndent) { - if (atExplicitKey) { - _keyLine = state.line; - _keyLineStart = state.lineStart; - _keyPos = state.position; - } - if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) if (atExplicitKey) keyNode = state.result; - else valueNode = state.result; - if (!atExplicitKey) { - storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos); - keyTag = keyNode = valueNode = null; - } - skipSeparationSpace(state, true, -1); - ch = state.input.charCodeAt(state.position); + if (column < maxLeadingIndent) { + state.position = linePosition + column; + throwError(state, "bad indentation of a mapping entry"); } - if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) throwError(state, "bad indentation of a mapping entry"); - else if (state.lineIndent < nodeIndent) break; } - if (atExplicitKey) storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); - if (detected) { - state.tag = _tag; - state.anchor = _anchor; - state.kind = "mapping"; - state.result = _result; + if (contentIndent === -1 && first !== 0 && !isEol(first) && column < parentIndent) { + state.lineIndent = column; + state.position = linePosition + column; + break; } - return detected; - } - function readTagProperty(state) { - let isVerbatim = false; - let isNamed = false; - let tagHandle; - let tagName; - let ch = state.input.charCodeAt(state.position); - if (ch !== 33) return false; - if (state.tag !== null) throwError(state, "duplication of a tag property"); - ch = state.input.charCodeAt(++state.position); - if (ch === 60) { - isVerbatim = true; - ch = state.input.charCodeAt(++state.position); - } else if (ch === 33) { - isNamed = true; - tagHandle = "!!"; - ch = state.input.charCodeAt(++state.position); - } else tagHandle = "!"; - let _position = state.position; - if (isVerbatim) { - do - ch = state.input.charCodeAt(++state.position); - while (ch !== 0 && ch !== 62); - if (state.position < state.length) { - tagName = state.input.slice(_position, state.position); - ch = state.input.charCodeAt(++state.position); - } else throwError(state, "unexpected end of the stream within a verbatim tag"); - } else { - while (ch !== 0 && !isWsOrEol(ch)) { - if (ch === 33) if (!isNamed) { - tagHandle = state.input.slice(_position - 1, state.position + 1); - if (!PATTERN_TAG_HANDLE.test(tagHandle)) throwError(state, "named tag handle cannot contain such characters"); - isNamed = true; - _position = state.position + 1; - } else throwError(state, "tag suffix cannot contain exclamation marks"); - ch = state.input.charCodeAt(++state.position); - } - tagName = state.input.slice(_position, state.position); - if (PATTERN_FLOW_INDICATORS.test(tagName)) throwError(state, "tag suffix cannot contain flow indicator characters"); + if (!detectedIndent && first !== 0 && !isEol(first) && contentIndent === -1) contentIndent = column; + const requiredIndent = contentIndent === -1 ? parentIndent + 1 : contentIndent; + if (first !== 0 && !isEol(first) && column < requiredIndent) { + state.lineIndent = column; + state.position = linePosition + column; + break; } - if (tagName && !PATTERN_TAG_URI.test(tagName)) throwError(state, "tag name cannot contain such characters: " + tagName); - try { - tagName = decodeURIComponent(tagName); - } catch (err) { - throwError(state, "tag name is malformed: " + tagName); + skipUntilLineEnd(state); + valueEnd = state.position; + if (isEol(state.input.charCodeAt(state.position))) { + consumeLineBreak(state); + valueEnd = state.position; } - 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) { - let ch = state.input.charCodeAt(state.position); - if (ch !== 38) return false; - if (state.anchor !== null) throwError(state, "duplication of an anchor property"); - ch = state.input.charCodeAt(++state.position); - const _position = state.position; - while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch)) ch = state.input.charCodeAt(++state.position); - if (state.position === _position) throwError(state, "name of an anchor node must contain at least one character"); - state.anchor = state.input.slice(_position, state.position); - return true; + checkPrintable(state, valueStart, valueEnd); + addScalarEvent(state, valueStart, valueEnd, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, style, chomping, contentIndent); + return true; +} +function canStartPlainScalar(state, nodeContext) { + const ch = state.input.charCodeAt(state.position); + const inFlow = nodeContext === CONTEXT_FLOW_IN; + if (ch === 0 || isWsOrEol(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96 || inFlow && isFlowIndicator(ch)) return false; + if (ch === 63 || ch === 45) { + const following = state.input.charCodeAt(state.position + 1); + if (isWsOrEolOrEnd(following) || inFlow && isFlowIndicator(following)) return false; } - function readAlias(state) { - let ch = state.input.charCodeAt(state.position); - if (ch !== 42) return false; + return true; +} +function readPlainScalar(state, nodeIndent, nodeContext, props) { + if (!canStartPlainScalar(state, nodeContext)) return false; + const start = state.position; + let end = state.position; + let ch = state.input.charCodeAt(state.position); + const inFlow = nodeContext === CONTEXT_FLOW_IN; + let multiline = false; + while (ch !== 0) { + if (state.position === state.lineStart && testDocumentSeparator(state)) break; + if (ch === 58) { + const following = state.input.charCodeAt(state.position + 1); + if (isWsOrEolOrEnd(following) || inFlow && isFlowIndicator(following)) break; + } else if (ch === 35) { + if (isWsOrEol(state.input.charCodeAt(state.position - 1))) break; + } else if (inFlow && isFlowIndicator(ch)) break; + else if (isEol(ch)) { + const savedPosition = state.position; + const savedLine = state.line; + const savedLineStart = state.lineStart; + const savedLineIndent = state.lineIndent; + skipSeparationSpace(state, false); + if (state.lineIndent >= nodeIndent) { + multiline = true; + ch = state.input.charCodeAt(state.position); + continue; + } + state.position = savedPosition; + state.line = savedLine; + state.lineStart = savedLineStart; + state.lineIndent = savedLineIndent; + break; + } + if (!isWhiteSpace(ch)) end = state.position + 1; ch = state.input.charCodeAt(++state.position); - const _position = state.position; - while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch)) ch = state.input.charCodeAt(++state.position); - if (state.position === _position) throwError(state, "name of an alias node must contain at least one character"); - const alias = state.input.slice(_position, state.position); - if (!_hasOwnProperty.call(state.anchorMap, alias)) throwError(state, "unidentified alias \"" + alias + "\""); - state.result = state.anchorMap[alias]; - skipSeparationSpace(state, true, -1); - return true; } - function tryReadBlockMappingFromProperty(state, propertyStart, nodeIndent, flowIndent) { - const fallbackState = snapshotState(state); - beginAnchorTransaction(state); - restoreState(state, propertyStart); - state.tag = null; - state.anchor = null; - state.kind = null; - state.result = null; - if (readBlockMapping(state, nodeIndent, flowIndent) && state.kind === "mapping") { - commitAnchorTransaction(state); + if (end === start) return false; + checkPrintable(state, start, end); + addScalarEvent(state, start, end, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 1, 1, -1, !multiline); + return true; +} +function skipFlowSeparationSpace(state, nodeIndent) { + const startLine = state.line; + skipSeparationSpace(state, true); + if (state.line > startLine && state.lineIndent < nodeIndent || state.firstTabInLine !== -1 && state.lineIndent < nodeIndent) throwError(state, "deficient indentation"); +} +function readFlowCollection(state, nodeIndent, props) { + const ch = state.input.charCodeAt(state.position); + const isMapping = ch === 123; + const start = state.position; + let readNext = true; + if (ch !== 91 && ch !== 123) return false; + const terminator = isMapping ? 125 : 93; + if (isMapping) addMappingEvent(state, start, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 2); + else addSequenceEvent(state, start, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 2); + state.position++; + while (state.input.charCodeAt(state.position) !== 0) { + skipFlowSeparationSpace(state, nodeIndent); + let ch = state.input.charCodeAt(state.position); + if (ch === terminator) { + state.position++; + addPopEvent(state); return true; + } else if (!readNext) throwError(state, "missed comma between flow collection entries"); + else if (ch === 44) throwError(state, "expected the node content, but found ','"); + let isPair = false; + let isExplicitPair = false; + if (ch === 63 && isWsOrEol(state.input.charCodeAt(state.position + 1))) { + isPair = isExplicitPair = true; + state.position += 1; + skipFlowSeparationSpace(state, nodeIndent); } - rollbackAnchorTransaction(state); - restoreState(state, fallbackState); - return false; + const entryLine = state.line; + const entryStart = snapshotState(state); + const keyWasRead = parseNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + skipFlowSeparationSpace(state, nodeIndent); + ch = state.input.charCodeAt(state.position); + if ((isMapping || isExplicitPair || state.line === entryLine) && ch === 58) { + isPair = true; + state.position++; + skipFlowSeparationSpace(state, nodeIndent); + if (!isMapping) { + restoreState(state, entryStart); + addMappingEvent(state, entryStart.position, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, 2); + if (!parseNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true)) addEmptyScalarEvent(state); + skipFlowSeparationSpace(state, nodeIndent); + state.position++; + skipFlowSeparationSpace(state, nodeIndent); + } else if (!keyWasRead) addEmptyScalarEvent(state); + if (!parseNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true)) addEmptyScalarEvent(state); + skipFlowSeparationSpace(state, nodeIndent); + if (!isMapping) addPopEvent(state); + } else if (isMapping && isPair) { + if (!keyWasRead) addEmptyScalarEvent(state); + addEmptyScalarEvent(state); + } else if (isMapping) addEmptyScalarEvent(state); + else if (isPair) { + restoreState(state, entryStart); + addMappingEvent(state, entryStart.position, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, 2); + parseNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + addEmptyScalarEvent(state); + addPopEvent(state); + } + ch = state.input.charCodeAt(state.position); + if (ch === 44) { + readNext = true; + state.position++; + } else readNext = false; } - function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) { - let allowBlockScalars; - let allowBlockCollections; - let indentStatus = 1; - let atNewLine = false; - let hasContent = false; - let propertyStart = null; - let type; - let flowIndent; - let blockIndent; - if (state.depth >= state.maxDepth) throwError(state, "nesting exceeded maxDepth (" + state.maxDepth + ")"); - state.depth += 1; - if (state.listener !== null) state.listener("open", state); - state.tag = null; - state.anchor = null; - state.kind = null; - state.result = null; - const allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext; - if (allowToSeek) { - if (skipSeparationSpace(state, true, -1)) { - atNewLine = true; - if (state.lineIndent > parentIndent) indentStatus = 1; - else if (state.lineIndent === parentIndent) indentStatus = 0; - else if (state.lineIndent < parentIndent) indentStatus = -1; - } + throwError(state, "unexpected end of the stream within a flow collection"); +} +function readBlockSequence(state, nodeIndent, props) { + if (state.firstTabInLine !== -1 || state.input.charCodeAt(state.position) !== 45 || !isWsOrEolOrEnd(state.input.charCodeAt(state.position + 1))) return false; + addSequenceEvent(state, state.position, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 1); + while (state.input.charCodeAt(state.position) === 45 && isWsOrEolOrEnd(state.input.charCodeAt(state.position + 1))) { + if (state.firstTabInLine !== -1) { + state.position = state.firstTabInLine; + throwError(state, "tab characters must not be used in indentation"); } - if (indentStatus === 1) while (true) { - const ch = state.input.charCodeAt(state.position); - const propertyState = snapshotState(state); - if (atNewLine && (ch === 33 && state.tag !== null || ch === 38 && state.anchor !== null)) break; - if (!readTagProperty(state) && !readAnchorProperty(state)) break; - if (propertyStart === null) propertyStart = propertyState; - if (skipSeparationSpace(state, true, -1)) { - atNewLine = true; - allowBlockCollections = allowBlockStyles; - if (state.lineIndent > parentIndent) indentStatus = 1; - else if (state.lineIndent === parentIndent) indentStatus = 0; - else if (state.lineIndent < parentIndent) indentStatus = -1; - } else allowBlockCollections = false; + const entryLine = state.line; + state.position++; + const hadBreak = skipSeparationSpace(state, true) > 0; + if (state.firstTabInLine !== -1 && state.input.charCodeAt(state.position) === 45 && isWsOrEolOrEnd(state.input.charCodeAt(state.position + 1))) throwError(state, "bad indentation of a sequence entry"); + if (hadBreak && state.lineIndent <= nodeIndent) addEmptyScalarEvent(state); + else parseNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true); + skipSeparationSpace(state, true); + if (state.lineIndent < nodeIndent || state.position >= state.length) break; + if (state.lineIndent > nodeIndent) throwError(state, "bad indentation of a sequence entry"); + if (state.line === entryLine && state.input.charCodeAt(state.position) === 45 && isWsOrEolOrEnd(state.input.charCodeAt(state.position + 1))) throwError(state, "bad indentation of a sequence entry"); + } + addPopEvent(state); + return true; +} +function readBlockMapping(state, nodeIndent, flowIndent, props) { + let atExplicitKey = false; + let detected = false; + let mappingOpened = false; + let pendingExplicitKey = false; + if (state.firstTabInLine !== -1) return false; + let ch = state.input.charCodeAt(state.position); + while (ch !== 0) { + if (!atExplicitKey && state.firstTabInLine !== -1) { + state.position = state.firstTabInLine; + throwError(state, "tab characters must not be used in indentation"); } - if (allowBlockCollections) allowBlockCollections = atNewLine || allowCompact; - if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) { - if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) flowIndent = parentIndent; - else flowIndent = parentIndent + 1; - blockIndent = state.position - state.lineStart; - if (indentStatus === 1) if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) hasContent = true; + const following = state.input.charCodeAt(state.position + 1); + const entryLine = state.line; + if ((ch === 63 || ch === 58) && isWsOrEolOrEnd(following)) { + if (!mappingOpened) { + addMappingEvent(state, state.position, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 1); + mappingOpened = true; + } + if (ch === 63) { + if (atExplicitKey) addEmptyScalarEvent(state); + detected = true; + atExplicitKey = true; + } else if (atExplicitKey) atExplicitKey = false; else { - const ch = state.input.charCodeAt(state.position); - if (propertyStart !== null && allowBlockStyles && !allowBlockCollections && ch !== 124 && ch !== 62 && tryReadBlockMappingFromProperty(state, propertyStart, propertyStart.position - propertyStart.lineStart, flowIndent)) hasContent = true; - else if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) hasContent = true; - else if (readAlias(state)) { - hasContent = true; - if (state.tag !== null || state.anchor !== null) throwError(state, "alias node should not have any properties"); - } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) { - hasContent = true; - if (state.tag === null) state.tag = "?"; - } - if (state.anchor !== null) storeAnchor(state, state.anchor, state.result); + addEmptyScalarEvent(state); + detected = true; + atExplicitKey = false; } - else if (indentStatus === 0) hasContent = allowBlockCollections && readBlockSequence(state, blockIndent); - } - if (state.tag === null) { - if (state.anchor !== null) storeAnchor(state, state.anchor, state.result); - } else if (state.tag === "?") { - if (state.result !== null && state.kind !== "scalar") throwError(state, "unacceptable node kind for ! tag; it should be \"scalar\", not \"" + state.kind + "\""); - for (let typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) { - type = state.implicitTypes[typeIndex]; - if (type.resolve(state.result)) { - state.result = type.construct(state.result); - state.tag = type.tag; - if (state.anchor !== null) storeAnchor(state, state.anchor, state.result); - break; - } + state.position += 1; + pendingExplicitKey = true; + } else { + if (atExplicitKey) { + addEmptyScalarEvent(state); + atExplicitKey = false; } - } else if (state.tag !== "!") { - if (_hasOwnProperty.call(state.typeMap[state.kind || "fallback"], state.tag)) type = state.typeMap[state.kind || "fallback"][state.tag]; + const beforeKey = snapshotState(state); + if (!parseNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) break; + if (state.line === entryLine) { + ch = state.input.charCodeAt(state.position); + while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position); + if (ch === 58) { + ch = state.input.charCodeAt(++state.position); + if (!isWsOrEolOrEnd(ch)) throwError(state, "a whitespace character is expected after the key-value separator within a block mapping"); + if (!mappingOpened) { + restoreState(state, beforeKey); + addMappingEvent(state, beforeKey.position, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 1); + mappingOpened = true; + parseNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true); + ch = state.input.charCodeAt(state.position); + while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position); + state.position++; + } + detected = true; + atExplicitKey = false; + pendingExplicitKey = false; + } else if (detected) throwError(state, "expected ':' after a mapping key"); + else { + if (props.anchorStart !== NO_RANGE$1 || props.tagStart !== NO_RANGE$1) { + restoreState(state, beforeKey); + return false; + } + return true; + } + } else if (detected) throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key"); else { - type = null; - const typeList = state.typeMap.multi[state.kind || "fallback"]; - for (let typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) { - type = typeList[typeIndex]; - break; + if (props.anchorStart !== NO_RANGE$1 || props.tagStart !== NO_RANGE$1) { + restoreState(state, beforeKey); + return false; } + return true; } - if (!type) throwError(state, "unknown tag !<" + state.tag + ">"); - if (state.result !== null && type.kind !== state.kind) throwError(state, "unacceptable node kind for !<" + state.tag + "> tag; it should be \"" + type.kind + "\", not \"" + state.kind + "\""); - if (!type.resolve(state.result, state.tag)) throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag"); - else { - state.result = type.construct(state.result, state.tag); - if (state.anchor !== null) storeAnchor(state, state.anchor, state.result); + } + if (parseNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, pendingExplicitKey)) pendingExplicitKey = false; + if (!atExplicitKey) { + if (pendingExplicitKey) { + addEmptyScalarEvent(state); + pendingExplicitKey = false; } } - if (state.listener !== null) state.listener("close", state); - state.depth -= 1; - return state.tag !== null || state.anchor !== null || hasContent; + skipSeparationSpace(state, true); + ch = state.input.charCodeAt(state.position); + if ((state.line === entryLine || state.lineIndent > nodeIndent) && ch !== 0) throwError(state, "bad indentation of a mapping entry"); + else if (state.lineIndent < nodeIndent) break; + } + if (!detected) return false; + if (atExplicitKey) addEmptyScalarEvent(state); + if (mappingOpened) addPopEvent(state); + return true; +} +function parseNode(state, parentIndent, nodeContext, allowToSeek, allowCompact, allowPropertyMapping = true) { + if (state.depth >= state.maxDepth) throwError(state, `nesting exceeded maxDepth (${state.maxDepth})`); + state.depth++; + let indentStatus = 1; + let atNewLine = false; + let hasContent = false; + let propertyStart = null; + const props = emptyProperties(); + let allowBlockScalars = nodeContext === CONTEXT_BLOCK_OUT || nodeContext === CONTEXT_BLOCK_IN; + let allowBlockCollections = allowBlockScalars; + const allowBlockStyles = allowBlockScalars; + if (allowToSeek && skipSeparationSpace(state, true)) { + atNewLine = true; + if (state.lineIndent > parentIndent) indentStatus = 1; + else if (state.lineIndent === parentIndent) indentStatus = 0; + else indentStatus = -1; + } + if (state.position === state.lineStart && testDocumentSeparator(state)) { + state.depth--; + return false; } - function readDocument(state) { - const documentStart = state.position; - let hasDirectives = false; - let ch; - state.version = null; - state.checkLineBreaks = state.legacy; - state.tagMap = Object.create(null); - state.anchorMap = Object.create(null); - while ((ch = state.input.charCodeAt(state.position)) !== 0) { - skipSeparationSpace(state, true, -1); - ch = state.input.charCodeAt(state.position); - if (state.lineIndent > 0 || ch !== 37) break; - hasDirectives = true; - ch = state.input.charCodeAt(++state.position); - let _position = state.position; - while (ch !== 0 && !isWsOrEol(ch)) ch = state.input.charCodeAt(++state.position); - const directiveName = state.input.slice(_position, state.position); - const directiveArgs = []; - if (directiveName.length < 1) throwError(state, "directive name must not be less than one character in length"); - while (ch !== 0) { - while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position); - if (ch === 35) { - do - ch = state.input.charCodeAt(++state.position); - while (ch !== 0 && !isEol(ch)); - break; - } - if (isEol(ch)) break; - _position = state.position; - while (ch !== 0 && !isWsOrEol(ch)) ch = state.input.charCodeAt(++state.position); - directiveArgs.push(state.input.slice(_position, state.position)); + if (indentStatus === 1) while (true) { + const ch = state.input.charCodeAt(state.position); + const propertyState = snapshotState(state); + if (atNewLine && indentStatus !== 1 && (ch === 33 || ch === 38)) break; + if (atNewLine && allowBlockStyles && (props.tagStart !== NO_RANGE$1 || props.anchorStart !== NO_RANGE$1) && (ch === 33 || ch === 38)) { + const fallbackState = snapshotState(state); + const flowIndent = parentIndent + 1; + if (readBlockMapping(state, state.position - state.lineStart, flowIndent, props) && state.events[fallbackState.eventsLength]?.type === 3) { + state.depth--; + return true; } - if (ch !== 0) readLineBreak(state); - if (_hasOwnProperty.call(directiveHandlers, directiveName)) directiveHandlers[directiveName](state, directiveName, directiveArgs); - else throwWarning(state, "unknown document directive \"" + directiveName + "\""); + restoreState(state, fallbackState); } - skipSeparationSpace(state, true, -1); - if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) { - state.position += 3; - skipSeparationSpace(state, true, -1); - } else if (hasDirectives) throwError(state, "directives end mark is expected"); - composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true); - skipSeparationSpace(state, true, -1); - if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) throwWarning(state, "non-ASCII line breaks are interpreted as content"); - state.documents.push(state.result); - if (state.position === state.lineStart && testDocumentSeparator(state)) { - if (state.input.charCodeAt(state.position) === 46) { - state.position += 3; - skipSeparationSpace(state, true, -1); + if (atNewLine && (ch === 33 && props.tagStart !== NO_RANGE$1 || ch === 38 && props.anchorStart !== NO_RANGE$1)) break; + if (!readTagProperty(state, props, nodeContext === CONTEXT_FLOW_IN) && !readAnchorProperty(state, props)) break; + if (propertyStart === null) propertyStart = propertyState; + if (skipSeparationSpace(state, true)) { + atNewLine = true; + allowBlockCollections = allowBlockStyles; + if (state.lineIndent > parentIndent) indentStatus = 1; + else if (state.lineIndent === parentIndent) indentStatus = 0; + else indentStatus = -1; + } else allowBlockCollections = false; + } + if (allowBlockCollections) allowBlockCollections = atNewLine || allowCompact; + if (indentStatus === 1 || nodeContext === CONTEXT_BLOCK_OUT) { + const flowIndent = nodeContext === CONTEXT_FLOW_IN || nodeContext === CONTEXT_FLOW_OUT ? parentIndent : parentIndent + 1; + const blockIndent = state.position - state.lineStart; + if (indentStatus === 1) if (allowBlockCollections && (readBlockSequence(state, blockIndent, props) || readBlockMapping(state, blockIndent, flowIndent, props)) || readFlowCollection(state, flowIndent, props)) hasContent = true; + else { + const ch = state.input.charCodeAt(state.position); + if (propertyStart !== null && allowPropertyMapping && allowBlockStyles && !allowBlockCollections && ch !== 124 && ch !== 62) { + const fallbackState = snapshotState(state); + const propertyIndent = propertyStart.position - propertyStart.lineStart; + restoreState(state, propertyStart); + if (readBlockMapping(state, propertyIndent, flowIndent, emptyProperties()) && state.events[fallbackState.eventsLength]?.type === 3) hasContent = true; + else restoreState(state, fallbackState); } - return; - } - if (state.position < state.length - 1) throwError(state, "end of the stream or a document separator is expected"); - } - function loadDocuments(input, options) { - input = String(input); - options = options || {}; - if (input.length !== 0) { - if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) input += "\n"; - if (input.charCodeAt(0) === 65279) input = input.slice(1); - } - const state = new State(input, options); - const nullpos = input.indexOf("\0"); - if (nullpos !== -1) { - state.position = nullpos; - throwError(state, "null byte is not allowed in input"); - } - state.input += "\0"; - while (state.input.charCodeAt(state.position) === 32) { - state.lineIndent += 1; - state.position += 1; + if (!hasContent && (allowBlockScalars && readBlockScalar(state, flowIndent, props) || readSingleQuotedScalar(state, flowIndent, props) || readDoubleQuotedScalar(state, flowIndent, props) || readAlias(state, props) || readPlainScalar(state, flowIndent, nodeContext, props))) hasContent = true; } - while (state.position < state.length - 1) readDocument(state); - return state.documents; + else if (indentStatus === 0) hasContent = allowBlockCollections && readBlockSequence(state, blockIndent, props); + } + allowBlockScalars = allowBlockScalars && !hasContent; + if (!hasContent && (props.anchorStart !== NO_RANGE$1 || props.tagStart !== NO_RANGE$1 || allowBlockScalars)) { + addScalarEvent(state, NO_RANGE$1, NO_RANGE$1, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 1); + hasContent = true; + } + state.depth--; + return hasContent || props.anchorStart !== NO_RANGE$1 || props.tagStart !== NO_RANGE$1; +} +function readDirective(state) { + if (state.lineIndent > 0 || state.input.charCodeAt(state.position) !== 37) return false; + state.position++; + const nameStart = state.position; + while (state.input.charCodeAt(state.position) !== 0 && !isWsOrEol(state.input.charCodeAt(state.position))) state.position++; + const name = state.input.slice(nameStart, state.position); + const args = []; + if (name.length === 0) throwError(state, "directive name must not be less than one character in length"); + while (state.input.charCodeAt(state.position) !== 0 && !isEol(state.input.charCodeAt(state.position))) { + while (isWhiteSpace(state.input.charCodeAt(state.position))) state.position++; + if (state.input.charCodeAt(state.position) === 35 || isEol(state.input.charCodeAt(state.position)) || state.input.charCodeAt(state.position) === 0) break; + const start = state.position; + while (state.input.charCodeAt(state.position) !== 0 && !isWsOrEol(state.input.charCodeAt(state.position))) state.position++; + args.push(state.input.slice(start, state.position)); + } + if (isEol(state.input.charCodeAt(state.position))) consumeLineBreak(state); + if (name === "YAML") { + if (state.directives.some((directive) => directive.kind === "yaml")) throwError(state, "duplication of %YAML directive"); + if (args.length !== 1) throwError(state, "YAML directive accepts exactly one argument"); + const match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]); + if (match === null) throwError(state, "ill-formed argument of the YAML directive"); + if (parseInt(match[1], 10) !== 1) throwError(state, "unacceptable YAML version of the document"); + state.directives.push({ + kind: "yaml", + version: args[0] + }); + } else if (name === "TAG") { + if (args.length !== 2) throwError(state, "TAG directive accepts exactly two arguments"); + const [handle, prefix] = args; + if (!PATTERN_TAG_HANDLE.test(handle)) throwError(state, "ill-formed tag handle (first argument) of the TAG directive"); + if (HAS_OWN.call(state.tagHandlers, handle)) throwError(state, `there is a previously declared suffix for "${handle}" tag handle`); + if (!PATTERN_TAG_PREFIX.test(prefix)) throwError(state, "ill-formed tag prefix (second argument) of the TAG directive"); + state.tagHandlers[handle] = prefix; + state.directives.push({ + kind: "tag", + handle, + prefix + }); + } + return true; +} +function readDocument(state) { + state.directives = []; + state.tagHandlers = Object.create(null); + let hasDirectives = false; + skipSeparationSpace(state, true); + while (readDirective(state)) { + hasDirectives = true; + skipSeparationSpace(state, true); + } + let explicitStart = false; + let explicitEnd = false; + let allowCompact = true; + if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45 && isWsOrEolOrEnd(state.input.charCodeAt(state.position + 3))) { + explicitStart = true; + const markerLine = state.line; + state.position += 3; + skipSeparationSpace(state, true); + allowCompact = state.line > markerLine; + } else if (hasDirectives) throwError(state, "directives end mark is expected"); + const documentEventIndex = state.events.length; + if (!explicitStart && state.position === state.lineStart && state.input.charCodeAt(state.position) === 46 && testDocumentSeparator(state)) { + state.position += 3; + skipSeparationSpace(state, true); + return; } - function loadAll(input, iterator, options) { - if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") { - options = iterator; - iterator = null; + addDocumentEvent(state, explicitStart, false); + if (!parseNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, allowCompact, allowCompact)) addEmptyScalarEvent(state); + skipSeparationSpace(state, true); + if (state.position === state.lineStart && testDocumentSeparator(state)) { + explicitEnd = state.input.charCodeAt(state.position) === 46; + if (explicitEnd) { + const markerLine = state.line; + state.position += 3; + skipSeparationSpace(state, true); + if (state.line === markerLine && state.position < state.length) throwError(state, "end of the stream or a document separator is expected"); } - const documents = loadDocuments(input, options); - if (typeof iterator !== "function") return documents; - for (let index = 0, length = documents.length; index < length; index += 1) iterator(documents[index]); - } - function load(input, options) { - const documents = loadDocuments(input, options); - if (documents.length === 0) return; - else if (documents.length === 1) return documents[0]; - throw new YAMLException("expected a single document in the stream, but found more"); - } - module.exports.loadAll = loadAll; - module.exports.load = load; -})); + } + const documentEvent = state.events[documentEventIndex]; + if (documentEvent?.type === 1) documentEvent.explicitEnd = explicitEnd; + addPopEvent(state); + if (!explicitEnd && state.position < state.length && !(state.position === state.lineStart && testDocumentSeparator(state))) throwError(state, "end of the stream or a document separator is expected"); +} +function parseEvents(input, options) { + const length = input.length; + const state = { + ...DEFAULT_PARSER_OPTIONS, + ...options, + input: `${input}\0`, + length, + position: 0, + line: 0, + lineStart: 0, + lineIndent: 0, + firstTabInLine: -1, + depth: 0, + directives: [], + tagHandlers: Object.create(null), + events: [] + }; + const nullpos = input.indexOf("\0"); + if (nullpos !== -1) throwErrorAt(input, nullpos, "null byte is not allowed in input", state.filename); + if (state.input.charCodeAt(state.position) === 65279) state.position++; + while (state.position < state.length) { + skipSeparationSpace(state, true); + if (state.position >= state.length) break; + const documentStart = state.position; + readDocument(state); + if (state.position === documentStart) + /* c8 ignore next */ + throwError(state, "can not read a document"); + } + return state.events; +} //#endregion -//#region lib/dumper.js -var require_dumper = /* @__PURE__ */ __commonJSMin(((exports, module) => { - var common = require_common(); - var YAMLException = require_exception(); - var DEFAULT_SCHEMA = require_default(); - var _toString = Object.prototype.toString; - var _hasOwnProperty = Object.prototype.hasOwnProperty; - var CHAR_BOM = 65279; - var CHAR_TAB = 9; - var CHAR_LINE_FEED = 10; - var CHAR_CARRIAGE_RETURN = 13; - var CHAR_SPACE = 32; - var CHAR_EXCLAMATION = 33; - var CHAR_DOUBLE_QUOTE = 34; - var CHAR_SHARP = 35; - var CHAR_PERCENT = 37; - var CHAR_AMPERSAND = 38; - var CHAR_SINGLE_QUOTE = 39; - var CHAR_ASTERISK = 42; - var CHAR_COMMA = 44; - var CHAR_MINUS = 45; - var CHAR_COLON = 58; - var CHAR_EQUALS = 61; - var CHAR_GREATER_THAN = 62; - var CHAR_QUESTION = 63; - var CHAR_COMMERCIAL_AT = 64; - var CHAR_LEFT_SQUARE_BRACKET = 91; - var CHAR_RIGHT_SQUARE_BRACKET = 93; - var CHAR_GRAVE_ACCENT = 96; - var CHAR_LEFT_CURLY_BRACKET = 123; - var CHAR_VERTICAL_LINE = 124; - var CHAR_RIGHT_CURLY_BRACKET = 125; - var ESCAPE_SEQUENCES = {}; - ESCAPE_SEQUENCES[0] = "\\0"; - ESCAPE_SEQUENCES[7] = "\\a"; - ESCAPE_SEQUENCES[8] = "\\b"; - ESCAPE_SEQUENCES[9] = "\\t"; - ESCAPE_SEQUENCES[10] = "\\n"; - ESCAPE_SEQUENCES[11] = "\\v"; - ESCAPE_SEQUENCES[12] = "\\f"; - ESCAPE_SEQUENCES[13] = "\\r"; - ESCAPE_SEQUENCES[27] = "\\e"; - ESCAPE_SEQUENCES[34] = "\\\""; - ESCAPE_SEQUENCES[92] = "\\\\"; - ESCAPE_SEQUENCES[133] = "\\N"; - ESCAPE_SEQUENCES[160] = "\\_"; - ESCAPE_SEQUENCES[8232] = "\\L"; - ESCAPE_SEQUENCES[8233] = "\\P"; - var DEPRECATED_BOOLEANS_SYNTAX = [ - "y", - "Y", - "yes", - "Yes", - "YES", - "on", - "On", - "ON", - "n", - "N", - "no", - "No", - "NO", - "off", - "Off", - "OFF" +//#region src/load.ts +var DEFAULT_LOAD_OPTIONS = { + ...DEFAULT_PARSER_OPTIONS, + ...DEFAULT_CONSTRUCTOR_OPTIONS +}; +function loadDocuments(input, options = {}) { + const opts = { + ...DEFAULT_LOAD_OPTIONS, + ...options + }; + const source = String(input); + const PARSER_OPT_KEYS = Object.keys(DEFAULT_PARSER_OPTIONS); + const CONSTRUCTOR_OPT_KEYS = Object.keys(DEFAULT_CONSTRUCTOR_OPTIONS); + return constructFromEvents(parseEvents(source, js_yaml_pick(opts, PARSER_OPT_KEYS)), { + ...js_yaml_pick(opts, CONSTRUCTOR_OPT_KEYS), + source + }); +} +function loadAll(input, iteratorOrOptions, options) { + let iterator = null; + if (typeof iteratorOrOptions === "function") iterator = iteratorOrOptions; + else if (iteratorOrOptions !== null && typeof iteratorOrOptions === "object") options = iteratorOrOptions; + const documents = loadDocuments(input, options); + if (iterator === null) return documents; + for (const document of documents) iterator(document); +} +function load(input, options) { + const documents = loadDocuments(input, options); + if (documents.length === 0) throw new YAMLException("expected a document, but the input is empty"); + if (documents.length === 1) return documents[0]; + throw new YAMLException("expected a single document in the stream, but found more"); +} +//#endregion +//#region src/ast/nodes.ts +var Style = class { + tagged = false; + flow = false; + singleQuoted = false; + doubleQuoted = false; + literal = false; + folded = false; +}; +//#endregion +//#region src/ast/from_js.ts +var INVALID = Symbol("INVALID"); +function buildRepresentTypes(schema) { + const defaultTags = new Set([ + schema.defaultScalarTag, + schema.defaultSequenceTag, + schema.defaultMappingTag + ].filter((t) => t !== void 0)); + const implicitScalars = schema.implicitScalarTags; + const explicitTags = schema.tags.filter((t) => !(t.nodeKind === "scalar" && t.implicit) && !defaultTags.has(t)); + const defaultTagsLast = schema.tags.filter((t) => defaultTags.has(t)); + return [ + ...implicitScalars.map((tag) => ({ + tag, + implicitTag: true + })), + ...explicitTags.map((tag) => ({ + tag, + implicitTag: false + })), + ...defaultTagsLast.map((tag) => ({ + tag, + implicitTag: true + })) ]; - var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/; - function compileStyleMap(schema, map) { - if (map === null) return {}; - const result = {}; - const keys = Object.keys(map); - for (let index = 0, length = keys.length; index < length; index += 1) { - let tag = keys[index]; - let style = String(map[tag]); - if (tag.slice(0, 2) === "!!") tag = "tag:yaml.org,2002:" + tag.slice(2); - const type = schema.compiledTypeMap["fallback"][tag]; - if (type && _hasOwnProperty.call(type.styleAliases, style)) style = type.styleAliases[style]; - result[tag] = style; - } - return result; - } - function encodeHex(character) { - let handle; - let length; - const string = character.toString(16).toUpperCase(); - if (character <= 255) { - handle = "x"; - length = 2; - } else if (character <= 65535) { - handle = "u"; - length = 4; - } else if (character <= 4294967295) { - handle = "U"; - length = 8; - } else throw new YAMLException("code point within a string may not be greater than 0xFFFFFFFF"); - return "\\" + handle + common.repeat("0", length - string.length) + string; - } - var QUOTING_TYPE_SINGLE = 1; - var QUOTING_TYPE_DOUBLE = 2; - function State(options) { - this.schema = options["schema"] || DEFAULT_SCHEMA; - this.indent = Math.max(1, options["indent"] || 2); - this.noArrayIndent = options["noArrayIndent"] || false; - this.skipInvalid = options["skipInvalid"] || false; - this.flowLevel = common.isNothing(options["flowLevel"]) ? -1 : options["flowLevel"]; - this.styleMap = compileStyleMap(this.schema, options["styles"] || null); - this.sortKeys = options["sortKeys"] || false; - this.lineWidth = options["lineWidth"] || 80; - this.noRefs = options["noRefs"] || false; - this.noCompatMode = options["noCompatMode"] || false; - this.condenseFlow = options["condenseFlow"] || false; - this.quotingType = options["quotingType"] === "\"" ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE; - this.forceQuotes = options["forceQuotes"] || false; - this.replacer = typeof options["replacer"] === "function" ? options["replacer"] : null; - this.implicitTypes = this.schema.compiledImplicit; - this.explicitTypes = this.schema.compiledExplicit; - this.tag = null; - this.result = ""; - this.duplicates = []; - this.usedDuplicates = null; - } - function indentString(string, spaces) { - const ind = common.repeat(" ", spaces); - let position = 0; - let result = ""; - const length = string.length; - while (position < length) { - let line; - const next = string.indexOf("\n", position); - if (next === -1) { - line = string.slice(position); - position = length; - } else { - line = string.slice(position, next + 1); - position = next + 1; - } - if (line.length && line !== "\n") result += ind; - result += line; +} +function matchTag(state, object) { + for (let index = 0, length = state.representTypes.length; index < length; index += 1) { + const { tag, implicitTag } = state.representTypes[index]; + if (tag.identify && tag.identify(object)) { + let tagName; + if (tag.matchByTagPrefix && tag.representTagName) tagName = tag.representTagName(object); + else tagName = tag.tagName; + return { + tag, + tagName, + implicitTag + }; } - return result; } - function generateNextLine(state, level) { - return "\n" + common.repeat(" ", state.indent * level); + return null; +} +function build(state, object) { + if (!state.noRefs && object !== null && typeof object === "object") { + const existing = state.refs.get(object); + if (existing) { + if (existing.anchor === void 0) existing.anchor = `ref_${state.refCounter++}`; + return { + kind: "alias", + tag: "", + style: new Style(), + anchor: existing.anchor + }; + } } - function testImplicitResolving(state, str) { - for (let index = 0, length = state.implicitTypes.length; index < length; index += 1) if (state.implicitTypes[index].resolve(str)) return true; - return false; + const matched = matchTag(state, object); + if (!matched) { + if (object === void 0) return INVALID; + if (state.skipInvalid) return INVALID; + throw new YAMLException(`unacceptable kind of an object to dump ${Object.prototype.toString.call(object)}`); + } + const { tag, tagName, implicitTag } = matched; + const nodeTagName = implicitTag ? tagName : tagNameShort(tagName); + if (tag.nodeKind === "scalar") { + const style = new Style(); + style.tagged = !implicitTag; + return { + kind: "scalar", + tag: nodeTagName, + style, + value: tag.represent(object) + }; } - function isWhitespace(c) { - return c === CHAR_SPACE || c === CHAR_TAB; + if (tag.nodeKind === "sequence") { + const container = tag.represent(object); + const style = new Style(); + style.tagged = !implicitTag; + const node = { + kind: "sequence", + tag: nodeTagName, + style, + items: [] + }; + if (!state.noRefs) state.refs.set(object, node); + for (let index = 0, length = container.length; index < length; index += 1) { + let item = build(state, container[index]); + if (item === INVALID && container[index] === void 0) item = build(state, null); + if (item === INVALID) continue; + node.items.push(item); + } + return node; } - function isPrintable(c) { - return c >= 32 && c <= 126 || c >= 161 && c <= 55295 && c !== 8232 && c !== 8233 || c >= 57344 && c <= 65533 && c !== CHAR_BOM || c >= 65536 && c <= 1114111; + const map = tag.represent(object); + const style = new Style(); + style.tagged = !implicitTag; + const node = { + kind: "mapping", + tag: nodeTagName, + style, + items: [] + }; + if (!state.noRefs) state.refs.set(object, node); + for (const [objectKey, objectValue] of map) { + const key = build(state, objectKey); + if (key === INVALID) continue; + const value = build(state, objectValue); + if (value === INVALID) continue; + node.items.push({ + key, + value + }); } - function isNsCharOrWhitespace(c) { - return isPrintable(c) && c !== CHAR_BOM && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED; + return node; +} +function jsToAst(input, schema, options = {}) { + const root = build({ + representTypes: buildRepresentTypes(schema), + noRefs: options.noRefs ?? false, + skipInvalid: options.skipInvalid ?? false, + refs: /* @__PURE__ */ new Map(), + refCounter: 0 + }, input); + return [{ + contents: root === INVALID ? null : root, + directives: [] + }]; +} +//#endregion +//#region src/ast/visit.ts +var VISIT_BREAK = Symbol("visit:break"); +var VISIT_SKIP = Symbol("visit:skip"); +function visitNode(node, visitor, ctx) { + const control = visitor(node, ctx); + if (control === VISIT_BREAK) return true; + if (control === VISIT_SKIP) return false; + const depth = ctx.depth + 1; + switch (node.kind) { + case "sequence": + for (const item of node.items) if (visitNode(item, visitor, { + depth, + parent: node, + isKey: false + })) return true; + break; + case "mapping": + for (const { key, value } of node.items) { + if (visitNode(key, visitor, { + depth, + parent: node, + isKey: true + })) return true; + if (visitNode(value, visitor, { + depth, + parent: node, + isKey: false + })) return true; + } + break; } - function isPlainSafe(c, prev, inblock) { - const cIsNsCharOrWhitespace = isNsCharOrWhitespace(c); - const cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c); - return (inblock ? cIsNsCharOrWhitespace : cIsNsCharOrWhitespace && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET) && c !== CHAR_SHARP && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar; + return false; +} +function visit(documents, visitor) { + for (const doc of documents) if (doc.contents && visitNode(doc.contents, visitor, { + depth: 0, + parent: null, + isKey: false + })) return; +} +//#endregion +//#region src/ast/presenter.ts +var CHAR_BOM = 65279; +var CHAR_TAB = 9; +var CHAR_LINE_FEED = 10; +var CHAR_CARRIAGE_RETURN = 13; +var CHAR_SPACE = 32; +var CHAR_EXCLAMATION = 33; +var CHAR_DOUBLE_QUOTE = 34; +var CHAR_SHARP = 35; +var CHAR_PERCENT = 37; +var CHAR_AMPERSAND = 38; +var CHAR_SINGLE_QUOTE = 39; +var CHAR_ASTERISK = 42; +var CHAR_COMMA = 44; +var CHAR_MINUS = 45; +var CHAR_COLON = 58; +var CHAR_EQUALS = 61; +var CHAR_GREATER_THAN = 62; +var CHAR_QUESTION = 63; +var CHAR_COMMERCIAL_AT = 64; +var CHAR_LEFT_SQUARE_BRACKET = 91; +var CHAR_RIGHT_SQUARE_BRACKET = 93; +var CHAR_GRAVE_ACCENT = 96; +var CHAR_LEFT_CURLY_BRACKET = 123; +var CHAR_VERTICAL_LINE = 124; +var CHAR_RIGHT_CURLY_BRACKET = 125; +var ESCAPE_SEQUENCES = {}; +ESCAPE_SEQUENCES[0] = "\\0"; +ESCAPE_SEQUENCES[7] = "\\a"; +ESCAPE_SEQUENCES[8] = "\\b"; +ESCAPE_SEQUENCES[9] = "\\t"; +ESCAPE_SEQUENCES[10] = "\\n"; +ESCAPE_SEQUENCES[11] = "\\v"; +ESCAPE_SEQUENCES[12] = "\\f"; +ESCAPE_SEQUENCES[13] = "\\r"; +ESCAPE_SEQUENCES[27] = "\\e"; +ESCAPE_SEQUENCES[34] = "\\\""; +ESCAPE_SEQUENCES[92] = "\\\\"; +ESCAPE_SEQUENCES[133] = "\\N"; +ESCAPE_SEQUENCES[160] = "\\_"; +ESCAPE_SEQUENCES[8232] = "\\L"; +ESCAPE_SEQUENCES[8233] = "\\P"; +var DEFAULT_PRESENTER_OPTIONS = { + indent: 2, + seqNoIndent: false, + seqInlineFirst: true, + sortKeys: false, + lineWidth: 80, + flowBracketPadding: false, + flowSkipCommaSpace: false, + flowSkipColonSpace: false, + quoteFlowKeys: false, + quoteStyle: "auto", + tagBeforeAnchor: false +}; +function nodeTagShort(node) { + return node.style.tagged ? node.tag : tagNameShort(node.tag); +} +function createPresenterState(options) { + const opts = { + ...DEFAULT_PRESENTER_OPTIONS, + ...options + }; + return { + ...opts, + defaultScalarTagName: opts.schema.defaultScalarTag.tagName, + implicitResolvers: opts.schema.implicitScalarTags + }; +} +function encodeNonPrintable(character) { + const string = character.toString(16).toUpperCase(); + const handle = character <= 255 ? "x" : "u"; + const length = character <= 255 ? 2 : 4; + return `\\${handle}${"0".repeat(length - string.length)}${string}`; +} +function indentString(string, spaces) { + const ind = " ".repeat(spaces); + let position = 0; + let result = ""; + const length = string.length; + while (position < length) { + let line; + const next = string.indexOf("\n", position); + if (next === -1) { + line = string.slice(position); + position = length; + } else { + line = string.slice(position, next + 1); + position = next + 1; + } + if (line.length && line !== "\n") result += ind; + result += line; } - function isPlainSafeFirst(c) { - return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT; + return result; +} +function generateNextLine(state, level) { + return `\n${" ".repeat(state.indent * level)}`; +} +function scalarLayout(state, level) { + const indent = state.indent * Math.max(1, level); + return { + indent, + blockIndent: level === 0 ? state.indent + 1 : state.indent, + lineWidth: state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent) + }; +} +function resolveImplicitTag(state, str) { + for (let index = 0, length = state.implicitResolvers.length; index < length; index += 1) { + const tagDefinition = state.implicitResolvers[index]; + if (tagDefinition.resolve(str, false, tagDefinition.tagName) !== NOT_RESOLVED) return tagDefinition.tagName; } - function isPlainSafeLast(c) { - return !isWhitespace(c) && c !== CHAR_COLON; + return state.defaultScalarTagName; +} +function isWhitespace(c) { + return c === CHAR_SPACE || c === CHAR_TAB; +} +function startsWithDocumentSeparator(string) { + const marker = string.charCodeAt(0); + if (marker !== CHAR_MINUS && marker !== 46 || string.charCodeAt(1) !== marker || string.charCodeAt(2) !== marker) return false; + if (string.length === 3) return true; + const following = string.charCodeAt(3); + return isWhitespace(following) || following === CHAR_CARRIAGE_RETURN || following === CHAR_LINE_FEED; +} +function isPrintable(c) { + return c >= 32 && c <= 126 || c >= 161 && c <= 55295 && c !== 8232 && c !== 8233 || c >= 57344 && c <= 65533 && c !== CHAR_BOM || c >= 65536 && c <= 1114111; +} +function isNsCharOrWhitespace(c) { + return isPrintable(c) && c !== CHAR_BOM && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED; +} +function isPlainSafe(c, prev, inblock) { + const cIsNsCharOrWhitespace = isNsCharOrWhitespace(c); + const cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c); + return (inblock ? cIsNsCharOrWhitespace : cIsNsCharOrWhitespace && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET) && c !== CHAR_SHARP && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar; +} +function isPlainSafeFirst(c) { + return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT; +} +function isPlainSafeAtStart(string, inblock) { + const first = codePointAt(string, 0); + if (isPlainSafeFirst(first)) return true; + if (string.length > 1 && (first === CHAR_MINUS || first === CHAR_QUESTION || first === CHAR_COLON)) { + const second = codePointAt(string, 1); + return !isWhitespace(second) && isPlainSafe(second, first, inblock); } - function codePointAt(string, pos) { - const first = string.charCodeAt(pos); - let second; - if (first >= 55296 && first <= 56319 && pos + 1 < string.length) { - second = string.charCodeAt(pos + 1); - if (second >= 56320 && second <= 57343) return (first - 55296) * 1024 + second - 56320 + 65536; - } - return first; - } - function needIndentIndicator(string) { - return /^\n* /.test(string); - } - var STYLE_PLAIN = 1; - var STYLE_SINGLE = 2; - var STYLE_LITERAL = 3; - var STYLE_FOLDED = 4; - var STYLE_DOUBLE = 5; - function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) { - let i; - let char = 0; - let prevChar = null; - let hasLineBreak = false; - let hasFoldableLine = false; - const shouldTrackWidth = lineWidth !== -1; - let previousLineBreak = -1; - let plain = isPlainSafeFirst(codePointAt(string, 0)) && isPlainSafeLast(codePointAt(string, string.length - 1)); - if (singleLineOnly || forceQuotes) for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) { + return false; +} +function isPlainSafeLast(c) { + return !isWhitespace(c) && c !== CHAR_COLON; +} +function codePointAt(string, pos) { + const first = string.charCodeAt(pos); + let second; + if (first >= 55296 && first <= 56319 && pos + 1 < string.length) { + second = string.charCodeAt(pos + 1); + if (second >= 56320 && second <= 57343) return (first - 55296) * 1024 + second - 56320 + 65536; + } + return first; +} +function needIndentIndicator(string) { + return /^\n* /.test(string); +} +var STYLE_PLAIN = 1; +var STYLE_SINGLE = 2; +var STYLE_LITERAL = 3; +var STYLE_FOLDED = 4; +var STYLE_DOUBLE = 5; +function chooseScalarStyle(state, string, layout, singleLineOnly, inblock) { + const { blockIndent, lineWidth } = layout; + const forceQuote = state.quoteStyle !== "auto"; + let i; + let char = 0; + let prevChar = -1; + let hasLineBreak = false; + let hasFoldableLine = false; + const shouldTrackWidth = lineWidth !== -1; + let previousLineBreak = -1; + let plain = !startsWithDocumentSeparator(string) && isPlainSafeAtStart(string, inblock) && isPlainSafeLast(codePointAt(string, string.length - 1)); + if (singleLineOnly || forceQuote) for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) { + char = codePointAt(string, i); + if (!isPrintable(char)) return STYLE_DOUBLE; + plain = plain && isPlainSafe(char, prevChar, inblock); + prevChar = char; + } + else { + for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) { char = codePointAt(string, i); - if (!isPrintable(char)) return STYLE_DOUBLE; + if (char === CHAR_LINE_FEED) { + hasLineBreak = true; + if (shouldTrackWidth) { + hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " "; + previousLineBreak = i; + } + } else if (!isPrintable(char)) return STYLE_DOUBLE; plain = plain && isPlainSafe(char, prevChar, inblock); prevChar = char; } - else { - for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) { - char = codePointAt(string, i); - if (char === CHAR_LINE_FEED) { - hasLineBreak = true; - if (shouldTrackWidth) { - hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " "; - previousLineBreak = i; - } - } else if (!isPrintable(char)) return STYLE_DOUBLE; - plain = plain && isPlainSafe(char, prevChar, inblock); - prevChar = char; - } - hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " "; - } - if (!hasLineBreak && !hasFoldableLine) { - if (plain && !forceQuotes && !testAmbiguousType(string)) return STYLE_PLAIN; - return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE; - } - if (indentPerLevel > 9 && needIndentIndicator(string)) return STYLE_DOUBLE; - if (!forceQuotes) return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL; - return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE; - } - function writeScalar(state, string, level, iskey, inblock) { - state.dump = function() { - if (string.length === 0) return state.quotingType === QUOTING_TYPE_DOUBLE ? "\"\"" : "''"; - if (!state.noCompatMode) { - if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) return state.quotingType === QUOTING_TYPE_DOUBLE ? "\"" + string + "\"" : "'" + string + "'"; - } - const indent = state.indent * Math.max(1, level); - const lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent); - const singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel; - function testAmbiguity(string) { - return testImplicitResolving(state, string); - } - switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) { - case STYLE_PLAIN: return string; - case STYLE_SINGLE: return "'" + string.replace(/'/g, "''") + "'"; - case STYLE_LITERAL: return "|" + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent)); - case STYLE_FOLDED: return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent)); - case STYLE_DOUBLE: return "\"" + escapeString(string, lineWidth) + "\""; - default: throw new YAMLException("impossible error: invalid scalar style"); - } - }(); - } - function blockHeader(string, indentPerLevel) { - const indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : ""; - const clip = string[string.length - 1] === "\n"; - return indentIndicator + (clip && (string[string.length - 2] === "\n" || string === "\n") ? "+" : clip ? "" : "-") + "\n"; - } - function dropEndingNewline(string) { - return string[string.length - 1] === "\n" ? string.slice(0, -1) : string; - } - function foldString(string, width) { - const lineRe = /(\n+)([^\n]*)/g; - let result = function() { - let nextLF = string.indexOf("\n"); - nextLF = nextLF !== -1 ? nextLF : string.length; - lineRe.lastIndex = nextLF; - return foldLine(string.slice(0, nextLF), width); - }(); - let prevMoreIndented = string[0] === "\n" || string[0] === " "; - let moreIndented; - let match; - while (match = lineRe.exec(string)) { - const prefix = match[1]; - const line = match[2]; - moreIndented = line[0] === " "; - result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width); - prevMoreIndented = moreIndented; - } - return result; - } - function foldLine(line, width) { - if (line === "" || line[0] === " ") return line; - const breakRe = / [^ ]/g; - let match; - let start = 0; - let end; - let curr = 0; - let next = 0; - let result = ""; - while (match = breakRe.exec(line)) { - next = match.index; - if (next - start > width) { - end = curr > start ? curr : next; - result += "\n" + line.slice(start, end); - start = end + 1; - } - curr = next; - } - result += "\n"; - if (line.length - start > width && curr > start) result += line.slice(start, curr) + "\n" + line.slice(curr + 1); - else result += line.slice(start); - return result.slice(1); - } - function escapeString(string) { - let result = ""; - let char = 0; - for (let i = 0; i < string.length; char >= 65536 ? i += 2 : i++) { - char = codePointAt(string, i); - const escapeSeq = ESCAPE_SEQUENCES[char]; - if (!escapeSeq && isPrintable(char)) { - result += string[i]; - if (char >= 65536) result += string[i + 1]; - } else result += escapeSeq || encodeHex(char); - } - return result; - } - function writeFlowSequence(state, level, object) { - let _result = ""; - const _tag = state.tag; - for (let index = 0, length = object.length; index < length; index += 1) { - let value = object[index]; - if (state.replacer) value = state.replacer.call(object, String(index), value); - if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) { - if (_result !== "") _result += "," + (!state.condenseFlow ? " " : ""); - _result += state.dump; - } + hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " "; + } + if (!hasLineBreak && !hasFoldableLine) { + if (plain && !forceQuote) return STYLE_PLAIN; + return state.quoteStyle === "double" ? STYLE_DOUBLE : STYLE_SINGLE; + } + if (blockIndent > 9 && needIndentIndicator(string)) return STYLE_DOUBLE; + return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL; +} +function renderScalarStyle(string, style, layout) { + const { indent, blockIndent, lineWidth } = layout; + switch (style) { + case STYLE_PLAIN: return encodeFlowBreaks(string, indent); + case STYLE_SINGLE: return `'${encodeFlowBreaks(string, indent).replace(/'/g, "''")}'`; + case STYLE_LITERAL: return "|" + blockHeader(string, blockIndent) + dropEndingNewline(indentString(string, indent)); + case STYLE_FOLDED: return ">" + blockHeader(string, blockIndent) + dropEndingNewline(indentString(foldBlockScalar(string, lineWidth), indent)); + case STYLE_DOUBLE: return `"${escapeString(string)}"`; + } +} +function resolveScalarStyle(state, node, layout, iskey, inblock) { + const singleLineOnly = iskey || !inblock; + if (node.style.singleQuoted) return STYLE_SINGLE; + if (node.style.doubleQuoted) return STYLE_DOUBLE; + if (!singleLineOnly) { + if (node.style.literal) return STYLE_LITERAL; + if (node.style.folded) return STYLE_FOLDED; + } + const string = node.value; + if (string.length === 0) { + if (state.quoteStyle === "auto" && (node.style.tagged || resolveImplicitTag(state, string) === node.tag)) return STYLE_PLAIN; + return state.quoteStyle === "double" ? STYLE_DOUBLE : STYLE_SINGLE; + } + const style = chooseScalarStyle(state, string, layout, singleLineOnly, inblock); + if (style === STYLE_PLAIN && !node.style.tagged && resolveImplicitTag(state, string) !== node.tag) return STYLE_SINGLE; + return style; +} +function blockHeader(string, indentPerLevel) { + const indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : ""; + const clip = string[string.length - 1] === "\n"; + return `${indentIndicator}${clip && (string[string.length - 2] === "\n" || string === "\n") ? "+" : clip ? "" : "-"}\n`; +} +function encodeFlowBreaks(string, indent) { + let nextLF = string.indexOf("\n"); + if (nextLF === -1) return string; + const pad = " ".repeat(indent); + let result = string.slice(0, nextLF); + const lineRe = /(\n+)([^\n]*)/g; + lineRe.lastIndex = nextLF; + let match; + while (match = lineRe.exec(string)) { + const breaks = match[1].length; + const line = match[2]; + result += "\n".repeat(breaks + 1) + pad + line; + } + return result; +} +function dropEndingNewline(string) { + return string[string.length - 1] === "\n" ? string.slice(0, -1) : string; +} +function foldBlockScalar(string, width) { + const lineRe = /(\n+)([^\n]*)/g; + let nextLF = string.indexOf("\n"); + if (nextLF === -1) nextLF = string.length; + lineRe.lastIndex = nextLF; + let result = foldLine(string.slice(0, nextLF), width); + let prevMoreIndented = string[0] === "\n" || string[0] === " "; + let moreIndented; + let match; + while (match = lineRe.exec(string)) { + const prefix = match[1]; + const line = match[2]; + moreIndented = line[0] === " "; + result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width); + prevMoreIndented = moreIndented; + } + return result; +} +function foldLine(line, width) { + if (line === "" || line[0] === " ") return line; + const breakRe = / [^ ]/g; + let match; + let start = 0; + let end; + let curr = 0; + let next = 0; + let result = ""; + while (match = breakRe.exec(line)) { + next = match.index; + if (next - start > width) { + end = curr > start ? curr : next; + result += `\n${line.slice(start, end)}`; + start = end + 1; } - state.tag = _tag; - state.dump = "[" + _result + "]"; - } - function writeBlockSequence(state, level, object, compact) { - let _result = ""; - const _tag = state.tag; - for (let index = 0, length = object.length; index < length; index += 1) { - let value = object[index]; - if (state.replacer) value = state.replacer.call(object, String(index), value); - if (writeNode(state, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode(state, level + 1, null, true, true, false, true)) { - if (!compact || _result !== "") _result += generateNextLine(state, level); - if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) _result += "-"; - else _result += "- "; - _result += state.dump; - } + curr = next; + } + result += "\n"; + if (line.length - start > width && curr > start) result += `${line.slice(start, curr)}\n${line.slice(curr + 1)}`; + else result += line.slice(start); + return result.slice(1); +} +function escapeString(string) { + let result = ""; + let char = 0; + for (let i = 0; i < string.length; char >= 65536 ? i += 2 : i++) { + char = codePointAt(string, i); + const escapeSeq = ESCAPE_SEQUENCES[char]; + if (escapeSeq) { + result += escapeSeq; + continue; } - state.tag = _tag; - state.dump = _result || "[]"; - } - function writeFlowMapping(state, level, object) { - let _result = ""; - const _tag = state.tag; - const objectKeyList = Object.keys(object); - for (let index = 0, length = objectKeyList.length; index < length; index += 1) { - let pairBuffer = ""; - if (_result !== "") pairBuffer += ", "; - if (state.condenseFlow) pairBuffer += "\""; - const objectKey = objectKeyList[index]; - let objectValue = object[objectKey]; - if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue); - if (!writeNode(state, level, objectKey, false, false)) continue; - if (state.dump.length > 1024) pairBuffer += "? "; - pairBuffer += state.dump + (state.condenseFlow ? "\"" : "") + ":" + (state.condenseFlow ? "" : " "); - if (!writeNode(state, level, objectValue, false, false)) continue; - pairBuffer += state.dump; - _result += pairBuffer; + if (isPrintable(char)) { + result += string[i]; + if (char >= 65536) result += string[i + 1]; + continue; } - state.tag = _tag; - state.dump = "{" + _result + "}"; - } - function writeBlockMapping(state, level, object, compact) { - let _result = ""; - const _tag = state.tag; - const objectKeyList = Object.keys(object); - if (state.sortKeys === true) objectKeyList.sort(); - else if (typeof state.sortKeys === "function") objectKeyList.sort(state.sortKeys); - else if (state.sortKeys) throw new YAMLException("sortKeys must be a boolean or a function"); - for (let index = 0, length = objectKeyList.length; index < length; index += 1) { - let pairBuffer = ""; - if (!compact || _result !== "") pairBuffer += generateNextLine(state, level); - const objectKey = objectKeyList[index]; - let objectValue = object[objectKey]; - if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue); - if (!writeNode(state, level + 1, objectKey, true, true, true)) continue; - const explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024; - if (explicitPair) if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += "?"; - else pairBuffer += "? "; - pairBuffer += state.dump; - if (explicitPair) pairBuffer += generateNextLine(state, level); - if (!writeNode(state, level + 1, objectValue, true, explicitPair)) continue; - if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += ":"; - else pairBuffer += ": "; - pairBuffer += state.dump; - _result += pairBuffer; + result += encodeNonPrintable(char); + } + return result; +} +function writeFlowSequence(state, level, node) { + let result = ""; + for (let index = 0, length = node.items.length; index < length; index += 1) { + const item = writeNode(state, level, node.items[index], {}); + if (result !== "") result += `,${!state.flowSkipCommaSpace ? " " : ""}`; + result += item; + } + const pad = state.flowBracketPadding && result !== "" ? " " : ""; + return `[${pad}${result}${pad}]`; +} +function writeBlockSequence(state, level, node, compact) { + let result = ""; + for (let index = 0, length = node.items.length; index < length; index += 1) { + const item = writeNode(state, level + 1, node.items[index], { + block: true, + compact: state.seqInlineFirst, + isblockseq: true + }); + if (!compact || result !== "") result += generateNextLine(state, level); + if (item === "" || CHAR_LINE_FEED === item.charCodeAt(0)) result += "-"; + else result += "- "; + result += item; + } + return result; +} +function writeFlowMapping(state, level, node) { + let result = ""; + const items = sortMappingItems(state, node.items); + for (const { key, value } of items) { + let pairBuffer = ""; + if (result !== "") pairBuffer += `,${!state.flowSkipCommaSpace ? " " : ""}`; + const keyText = writeNode(state, level, key, {}); + const explicitPair = keyText.length > 1024; + if (explicitPair) pairBuffer += "? "; + else if (state.quoteFlowKeys) pairBuffer += "\""; + const valueText = writeNode(state, level, value, {}); + const sep = state.flowSkipColonSpace || valueText === "" ? "" : " "; + pairBuffer += `${keyText}${state.quoteFlowKeys && !explicitPair ? "\"" : ""}:${sep}${valueText}`; + result += pairBuffer; + } + const pad = state.flowBracketPadding && result !== "" ? " " : ""; + return `{${pad}${result}${pad}}`; +} +function sortKeyValue(key) { + return key.kind === "scalar" ? key.value : key; +} +function sortMappingItems(state, items) { + if (!state.sortKeys) return items; + const copy = items.slice(); + if (state.sortKeys === true) copy.sort((a, b) => { + const x = sortKeyValue(a.key); + const y = sortKeyValue(b.key); + if (x < y) return -1; + if (x > y) return 1; + return 0; + }); + else { + const fn = state.sortKeys; + copy.sort((a, b) => fn(sortKeyValue(a.key), sortKeyValue(b.key))); + } + return copy; +} +function writeBlockMapping(state, level, node, compact) { + let result = ""; + const items = sortMappingItems(state, node.items); + for (let index = 0, length = items.length; index < length; index += 1) { + let pairBuffer = ""; + if (!compact || result !== "") pairBuffer += generateNextLine(state, level); + const { key, value } = items[index]; + const keyIsBlock = (key.kind === "mapping" || key.kind === "sequence") && !key.style.flow && key.items.length !== 0 || key.kind === "scalar" && (key.style.literal || key.style.folded); + const keyText = keyIsBlock ? writeNode(state, level + 1, key, { + block: true, + compact: true, + isblockseq: !cannotBeCompact(state, key, level + 1) + }) : writeNode(state, level + 1, key, { + block: true, + compact: true, + iskey: true + }); + const keyHasLineBreak = key.kind === "scalar" && key.value.indexOf("\n") !== -1; + const explicitPair = keyIsBlock || keyHasLineBreak || keyText.length > 1024; + if (explicitPair) if (keyText && CHAR_LINE_FEED === keyText.charCodeAt(0)) pairBuffer += "?"; + else pairBuffer += "? "; + pairBuffer += keyText; + if (explicitPair) pairBuffer += generateNextLine(state, level); + const valueText = writeNode(state, level + 1, value, { + block: true, + compact: explicitPair, + isblockseq: explicitPair && !cannotBeCompact(state, value, level + 1) + }); + const keyIsBareProps = key.kind === "scalar" && key.value === "" && keyText !== "" && keyText.charCodeAt(keyText.length - 1) !== CHAR_SINGLE_QUOTE && keyText.charCodeAt(keyText.length - 1) !== CHAR_DOUBLE_QUOTE; + const keyColonSep = !explicitPair && (key.kind === "alias" || keyIsBareProps) ? " " : ""; + if (valueText === "" || CHAR_LINE_FEED === valueText.charCodeAt(0)) pairBuffer += `${keyColonSep}:`; + else pairBuffer += `${keyColonSep}: `; + pairBuffer += valueText; + result += pairBuffer; + } + return result; +} +function cannotBeCompact(state, node, level) { + return node.style.tagged || node.anchor !== void 0 || state.indent < 2 && level > 0; +} +function writeNode(state, level, node, ctx) { + if (node.kind === "alias") return `*${node.anchor}`; + const { block = false, iskey = false, isblockseq = false } = ctx; + let compact = ctx.compact ?? false; + const hasAnchor = node.anchor !== void 0; + if (cannotBeCompact(state, node, level)) compact = false; + let body; + let shouldPrintTag = node.style.tagged; + const useBlockCollection = block && (node.kind === "mapping" || node.kind === "sequence") && !node.style.flow && node.items.length !== 0; + if (node.kind === "mapping") if (useBlockCollection) body = writeBlockMapping(state, level, node, compact); + else body = writeFlowMapping(state, level, node); + else if (node.kind === "sequence") if (useBlockCollection) if (state.seqNoIndent && !isblockseq && level > 0) body = writeBlockSequence(state, level - 1, node, compact); + else body = writeBlockSequence(state, level, node, compact); + else body = writeFlowSequence(state, level, node); + else { + const layout = scalarLayout(state, level); + const style = resolveScalarStyle(state, node, layout, iskey, block); + body = renderScalarStyle(node.value, style, layout); + shouldPrintTag = node.style.tagged || style !== STYLE_PLAIN && node.tag !== state.defaultScalarTagName; + } + if (useBlockCollection && compact && level > 0 && state.indent > 2) body = `${" ".repeat(state.indent - 2)}${body}`; + if (shouldPrintTag || hasAnchor) { + const props = []; + const tag = shouldPrintTag ? nodeTagShort(node) : null; + const anchor = hasAnchor ? `&${node.anchor}` : null; + if (state.tagBeforeAnchor) { + if (tag !== null) props.push(tag); + if (anchor !== null) props.push(anchor); + } else { + if (anchor !== null) props.push(anchor); + if (tag !== null) props.push(tag); } - state.tag = _tag; - state.dump = _result || "{}"; - } - function detectType(state, object, explicit) { - const typeList = explicit ? state.explicitTypes : state.implicitTypes; - for (let index = 0, length = typeList.length; index < length; index += 1) { - const type = typeList[index]; - if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === "object" && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) { - if (explicit) if (type.multi && type.representName) state.tag = type.representName(object); - else state.tag = type.tag; - else state.tag = "?"; - if (type.represent) { - const style = state.styleMap[type.tag] || type.defaultStyle; - let _result; - if (_toString.call(type.represent) === "[object Function]") _result = type.represent(object, style); - else if (_hasOwnProperty.call(type.represent, style)) _result = type.represent[style](object, style); - else throw new YAMLException("!<" + type.tag + "> tag resolver accepts not \"" + style + "\" style"); - state.dump = _result; - } - return true; - } + const sep = body === "" || body.charCodeAt(0) === CHAR_LINE_FEED ? "" : " "; + body = `${props.join(" ")}${sep}${body}`; + } + return body; +} +function rootStartsOwnLine(node) { + return (node.kind === "sequence" || node.kind === "mapping") && !node.style.flow && node.items.length !== 0 && !node.style.tagged && node.anchor === void 0; +} +function isOpenEnded(node) { + let leaf = node; + while ((leaf.kind === "sequence" || leaf.kind === "mapping") && !leaf.style.flow && leaf.items.length !== 0) leaf = leaf.kind === "sequence" ? leaf.items[leaf.items.length - 1] : leaf.items[leaf.items.length - 1].value; + if (leaf.kind !== "scalar" || !(leaf.style.literal || leaf.style.folded)) return false; + const { value } = leaf; + return value.endsWith("\n\n") || value === "\n"; +} +function writeDocumentDirectives(doc) { + let result = ""; + for (const directive of doc.directives) { + if (directive.kind === "yaml") { + result += `%YAML ${directive.version}\n`; + continue; } - return false; + const { handle, prefix } = directive; + result += `%TAG ${handle} ${prefix}\n`; } - function writeNode(state, level, object, block, compact, iskey, isblockseq) { - state.tag = null; - state.dump = object; - if (!detectType(state, object, false)) detectType(state, object, true); - const type = _toString.call(state.dump); - const inblock = block; - if (block) block = state.flowLevel < 0 || state.flowLevel > level; - const objectOrArray = type === "[object Object]" || type === "[object Array]"; - let duplicateIndex; - let duplicate; - if (objectOrArray) { - duplicateIndex = state.duplicates.indexOf(object); - duplicate = duplicateIndex !== -1; - } - if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) compact = false; - if (duplicate && state.usedDuplicates[duplicateIndex]) state.dump = "*ref_" + duplicateIndex; - else { - if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) state.usedDuplicates[duplicateIndex] = true; - if (type === "[object Object]") if (block && Object.keys(state.dump).length !== 0) { - writeBlockMapping(state, level, state.dump, compact); - if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump; - } else { - writeFlowMapping(state, level, state.dump); - if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump; + return result; +} +function present(documents, options) { + const state = createPresenterState(options); + let result = ""; + let previousEnded = false; + for (let index = 0; index < documents.length; index += 1) { + const doc = documents[index]; + const directives = writeDocumentDirectives(doc); + const hasDirectives = directives !== ""; + const marker = doc.explicitStart || hasDirectives || index > 0 && !previousEnded; + result += directives; + if (doc.contents === null) { + if (marker) result += "---\n"; + } else if (marker) { + const body = writeNode(state, 0, doc.contents, { + block: true, + compact: true + }); + const sep = body === "" ? "" : hasDirectives || rootStartsOwnLine(doc.contents) ? "\n" : " "; + result += `---${sep}${body}\n`; + } else result += writeNode(state, 0, doc.contents, { + block: true, + compact: true + }) + "\n"; + previousEnded = doc.explicitEnd || doc.contents !== null && isOpenEnded(doc.contents); + if (previousEnded) result += "...\n"; + } + return result; +} +//#endregion +//#region src/dump.ts +var DEFAULT_DUMP_SCHEMA = YAML11_SCHEMA.withTags({ + ...intYaml11Tag, + resolve: (source, isExplicit, tagName) => { + const result = intYaml11Tag.resolve(source, isExplicit, tagName); + return result === NOT_RESOLVED ? intCoreTag.resolve(source, isExplicit, tagName) : result; + } +}, { + ...floatYaml11Tag, + resolve: (source, isExplicit, tagName) => { + const result = floatYaml11Tag.resolve(source, isExplicit, tagName); + return result === NOT_RESOLVED ? floatCoreTag.resolve(source, isExplicit, tagName) : result; + } +}); +var DEFAULT_DUMP_OPTIONS = { + ...DEFAULT_PRESENTER_OPTIONS, + schema: DEFAULT_DUMP_SCHEMA, + skipInvalid: false, + noRefs: false, + flowLevel: -1, + transform: () => {} +}; +function dump(input, options = {}) { + const opts = { + ...DEFAULT_DUMP_OPTIONS, + ...options + }; + const documents = jsToAst(input, opts.schema, { + noRefs: opts.noRefs, + skipInvalid: opts.skipInvalid + }); + if (opts.flowLevel >= 0) visit(documents, (node, ctx) => { + if (ctx.depth < opts.flowLevel) return; + node.style.flow = true; + return VISIT_SKIP; + }); + opts.transform(documents); + return present(documents, { + ...js_yaml_pick(opts, Object.keys(DEFAULT_PRESENTER_OPTIONS)), + schema: opts.schema + }); +} +//#endregion +//#region src/ast/from_events.ts +var NO_RANGE = (/* unused pure expression or super */ null && (-1)); +function eventPosition(event) { + if ("tagStart" in event && event.tagStart !== NO_RANGE) return event.tagStart; + if ("anchorStart" in event && event.anchorStart !== NO_RANGE) return event.anchorStart; + if ("valueStart" in event && event.valueStart !== NO_RANGE) return event.valueStart; + if ("start" in event) return event.start; + return 0; +} +function rawTag(state, event) { + return event.tagStart === NO_RANGE ? "" : state.source.slice(event.tagStart, event.tagEnd); +} +function anchorName(state, event) { + return event.anchorStart === NO_RANGE ? void 0 : state.source.slice(event.anchorStart, event.anchorEnd); +} +function implicitScalarTagName(state, source) { + const { schema } = state; + const candidates = schema.implicitScalarByFirstChar.get(source.charAt(0)) ?? schema.implicitScalarAnyFirstChar; + for (const tag of candidates) if (tag.resolve(source, false, tag.tagName) !== NOT_RESOLVED) return tag.tagName; + return schema.defaultScalarTag.tagName; +} +function buildScalar(state, event) { + const value = getScalarValue(state.source, event); + const raw = rawTag(state, event); + const style = new Style(); + switch (event.style) { + case 2: + style.singleQuoted = true; + break; + case 3: + style.doubleQuoted = true; + break; + case 4: + style.literal = true; + break; + case 5: + style.folded = true; + break; + } + let tag; + if (raw !== "") { + style.tagged = true; + tag = raw; + } else if (event.style === 1) tag = implicitScalarTagName(state, value); + else tag = state.schema.defaultScalarTag.tagName; + return { + kind: "scalar", + tag, + style, + anchor: anchorName(state, event), + value + }; +} +function buildCollection(state, event, defaultTagName) { + const raw = rawTag(state, event); + const style = new Style(); + if (event.style === 2) style.flow = true; + let tag; + if (raw === "") tag = defaultTagName; + else { + tag = raw; + style.tagged = true; + } + return { + tag, + style, + anchor: anchorName(state, event) + }; +} +function addNode(state, node) { + const frame = state.frames[state.frames.length - 1]; + if (frame.kind === "document") frame.doc.contents = node; + else if (frame.kind === "sequence") frame.node.items.push(node); + else if (frame.key) { + frame.node.items.push({ + key: frame.key, + value: node + }); + frame.key = null; + } else frame.key = node; +} +function eventsToAst(events, options) { + const state = { + source: options.source, + schema: options.schema, + eventIndex: 0, + position: 0, + frames: [], + documents: [] + }; + while (state.eventIndex < events.length) { + const event = events[state.eventIndex++]; + state.position = eventPosition(event); + switch (event.type) { + case 1: { + const doc = { + contents: null, + explicitStart: event.explicitStart, + explicitEnd: event.explicitEnd, + directives: event.directives + }; + state.frames.push({ + kind: "document", + doc + }); + break; } - else if (type === "[object Array]") if (block && state.dump.length !== 0) { - if (state.noArrayIndent && !isblockseq && level > 0) writeBlockSequence(state, level - 1, state.dump, compact); - else writeBlockSequence(state, level, state.dump, compact); - if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump; - } else { - writeFlowSequence(state, level, state.dump); - if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump; + case 4: + addNode(state, buildScalar(state, event)); + break; + case 2: { + const { tag, style, anchor } = buildCollection(state, event, "tag:yaml.org,2002:seq"); + const node = { + kind: "sequence", + tag, + style, + anchor, + items: [] + }; + state.frames.push({ + kind: "sequence", + node + }); + break; } - else if (type === "[object String]") { - if (state.tag !== "?") writeScalar(state, state.dump, level, iskey, inblock); - } else if (type === "[object Undefined]") return false; - else { - if (state.skipInvalid) return false; - throw new YAMLException("unacceptable kind of an object to dump " + type); + case 3: { + const { tag, style, anchor } = buildCollection(state, event, "tag:yaml.org,2002:map"); + const node = { + kind: "mapping", + tag, + style, + anchor, + items: [] + }; + state.frames.push({ + kind: "mapping", + node, + key: null + }); + break; } - if (state.tag !== null && state.tag !== "?") { - let tagStr = encodeURI(state.tag[0] === "!" ? state.tag.slice(1) : state.tag).replace(/!/g, "%21"); - if (state.tag[0] === "!") tagStr = "!" + tagStr; - else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") tagStr = "!!" + tagStr.slice(18); - else tagStr = "!<" + tagStr + ">"; - state.dump = tagStr + " " + state.dump; + case 5: { + const name = state.source.slice(event.anchorStart, event.anchorEnd); + addNode(state, { + kind: "alias", + tag: "", + style: new Style(), + anchor: name + }); + break; } - } - return true; - } - function getDuplicateReferences(object, state) { - const objects = []; - const duplicatesIndexes = []; - inspectNode(object, objects, duplicatesIndexes); - const length = duplicatesIndexes.length; - for (let index = 0; index < length; index += 1) state.duplicates.push(objects[duplicatesIndexes[index]]); - state.usedDuplicates = new Array(length); - } - function inspectNode(object, objects, duplicatesIndexes) { - if (object !== null && typeof object === "object") { - const index = objects.indexOf(object); - if (index !== -1) { - if (duplicatesIndexes.indexOf(index) === -1) duplicatesIndexes.push(index); - } else { - objects.push(object); - if (Array.isArray(object)) for (let i = 0, length = object.length; i < length; i += 1) inspectNode(object[i], objects, duplicatesIndexes); - else { - const objectKeyList = Object.keys(object); - for (let i = 0, length = objectKeyList.length; i < length; i += 1) inspectNode(object[objectKeyList[i]], objects, duplicatesIndexes); - } + case 6: { + const frame = state.frames.pop(); + if (frame.kind === "document") state.documents.push(frame.doc); + else addNode(state, frame.node); + break; } } } - function dump(input, options) { - options = options || {}; - const state = new State(options); - if (!state.noRefs) getDuplicateReferences(input, state); - let value = input; - if (state.replacer) value = state.replacer.call({ "": value }, "", value); - if (writeNode(state, 0, value, true, true)) return state.dump + "\n"; - return ""; - } - module.exports.dump = dump; -})); -//#endregion -//#region lib/index_vite_proxy.tmp.mjs -var import_js_yaml = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => { - var loader = require_loader(); - var dumper = require_dumper(); - function renamed(from, to) { - return function() { - throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default."); - }; - } - module.exports.Type = require_type(); - module.exports.Schema = require_schema(); - module.exports.FAILSAFE_SCHEMA = require_failsafe(); - module.exports.JSON_SCHEMA = require_json(); - module.exports.CORE_SCHEMA = require_core(); - module.exports.DEFAULT_SCHEMA = require_default(); - module.exports.load = loader.load; - module.exports.loadAll = loader.loadAll; - module.exports.dump = dumper.dump; - module.exports.YAMLException = require_exception(); - module.exports.types = { - binary: require_binary(), - float: require_float(), - map: require_map(), - null: require_null(), - pairs: require_pairs(), - set: require_set(), - timestamp: require_timestamp(), - bool: require_bool(), - int: require_int(), - merge: require_merge(), - omap: require_omap(), - seq: require_seq(), - str: require_str() - }; - module.exports.safeLoad = renamed("safeLoad", "load"); - module.exports.safeLoadAll = renamed("safeLoadAll", "loadAll"); - module.exports.safeDump = renamed("safeDump", "dump"); -})))(), 1); -var { Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump } = import_js_yaml.default; -var index_vite_proxy_tmp_default = import_js_yaml.default; + return state.documents; +} //#endregion @@ -57673,7 +58387,7 @@ async function fetchCurrentVersion(git, type, files, defaultBranch, versionPrope } case BUILD_TYPE.HELM: { const content = await getFileFromDefaultBranch(git, files.chart, defaultBranch); - const parsed = index_vite_proxy_tmp_default.load(content); + const parsed = load(content); if (!parsed || !parsed.version) { throw new Error(`Version not found in ${files.chart}`); }