+ lastFixInfo = fixInfo;
+ });
+ fixInfos = fixInfos.filter((fixInfo) => fixInfo.lineNumber);
+ let lastLineIndex = -1;
+ let lastEditIndex = -1;
+ fixInfos.forEach((fixInfo) => {
+ const { lineNumber, editColumn, deleteCount } = fixInfo;
+ const lineIndex = lineNumber - 1;
+ const editIndex = editColumn - 1;
+ if (lineIndex !== lastLineIndex || deleteCount === -1 || editIndex + deleteCount <= lastEditIndex - (deleteCount > 0 ? 0 : 1)) {
+ lines[lineIndex] = applyFix2(lines[lineIndex], fixInfo, lineEnding);
+ }
+ lastLineIndex = lineIndex;
+ lastEditIndex = editIndex;
+ });
+ return lines.filter((line) => line !== null).join(lineEnding);
+ };
+ }
+});
+
+// node_modules/ini/ini.js
+var require_ini = __commonJS({
+ "node_modules/ini/ini.js"(exports) {
+ exports.parse = exports.decode = decode;
+ exports.stringify = exports.encode = encode;
+ exports.safe = safe;
+ exports.unsafe = unsafe;
+ var eol = typeof process !== "undefined" && process.platform === "win32" ? "\r\n" : "\n";
+ function encode(obj, opt) {
+ var children = [];
+ var out = "";
+ if (typeof opt === "string") {
+ opt = {
+ section: opt,
+ whitespace: false
+ };
+ } else {
+ opt = opt || Object.create(null);
+ opt.whitespace = opt.whitespace === true;
+ }
+ var separator = opt.whitespace ? " = " : "=";
+ Object.keys(obj).forEach(function(k, _, __) {
+ var val = obj[k];
+ if (val && Array.isArray(val)) {
+ val.forEach(function(item) {
+ out += safe(k + "[]") + separator + safe(item) + "\n";
+ });
+ } else if (val && typeof val === "object")
+ children.push(k);
+ else
+ out += safe(k) + separator + safe(val) + eol;
+ });
+ if (opt.section && out.length)
+ out = "[" + safe(opt.section) + "]" + eol + out;
+ children.forEach(function(k, _, __) {
+ var nk = dotSplit(k).join("\\.");
+ var section = (opt.section ? opt.section + "." : "") + nk;
+ var child = encode(obj[k], {
+ section,
+ whitespace: opt.whitespace
+ });
+ if (out.length && child.length)
+ out += eol;
+ out += child;
+ });
+ return out;
+ }
+ function dotSplit(str2) {
+ return str2.replace(/\1/g, "\ 2LITERAL\\1LITERAL\ 2").replace(/\\\./g, "\ 1").split(/\./).map(function(part) {
+ return part.replace(/\1/g, "\\.").replace(/\2LITERAL\\1LITERAL\2/g, "\ 1");
+ });
+ }
+ function decode(str2) {
+ var out = Object.create(null);
+ var p = out;
+ var section = null;
+ var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
+ var lines = str2.split(/[\r\n]+/g);
+ lines.forEach(function(line, _, __) {
+ if (!line || line.match(/^\s*[;#]/))
+ return;
+ var match = line.match(re);
+ if (!match)
+ return;
+ if (match[1] !== void 0) {
+ section = unsafe(match[1]);
+ if (section === "__proto__") {
+ p = Object.create(null);
+ return;
+ }
+ p = out[section] = out[section] || Object.create(null);
+ return;
+ }
+ var key = unsafe(match[2]);
+ if (key === "__proto__")
+ return;
+ var value = match[3] ? unsafe(match[4]) : true;
+ switch (value) {
+ case "true":
+ case "false":
+ case "null":
+ value = JSON.parse(value);
+ }
+ if (key.length > 2 && key.slice(-2) === "[]") {
+ key = key.substring(0, key.length - 2);
+ if (key === "__proto__")
+ return;
+ if (!p[key])
+ p[key] = [];
+ else if (!Array.isArray(p[key]))
+ p[key] = [p[key]];
+ }
+ if (Array.isArray(p[key]))
+ p[key].push(value);
+ else
+ p[key] = value;
+ });
+ Object.keys(out).filter(function(k, _, __) {
+ if (!out[k] || typeof out[k] !== "object" || Array.isArray(out[k]))
+ return false;
+ var parts = dotSplit(k);
+ var p2 = out;
+ var l = parts.pop();
+ var nl = l.replace(/\\\./g, ".");
+ parts.forEach(function(part, _2, __2) {
+ if (part === "__proto__")
+ return;
+ if (!p2[part] || typeof p2[part] !== "object")
+ p2[part] = Object.create(null);
+ p2 = p2[part];
+ });
+ if (p2 === out && nl === l)
+ return false;
+ p2[nl] = out[k];
+ return true;
+ }).forEach(function(del, _, __) {
+ delete out[del];
+ });
+ return out;
+ }
+ function isQuoted(val) {
+ return val.charAt(0) === '"' && val.slice(-1) === '"' || val.charAt(0) === "'" && val.slice(-1) === "'";
+ }
+ function safe(val) {
+ return typeof val !== "string" || val.match(/[=\r\n]/) || val.match(/^\[/) || val.length > 1 && isQuoted(val) || val !== val.trim() ? JSON.stringify(val) : val.replace(/;/g, "\\;").replace(/#/g, "\\#");
+ }
+ function unsafe(val, doUnesc) {
+ val = (val || "").trim();
+ if (isQuoted(val)) {
+ if (val.charAt(0) === "'")
+ val = val.substr(1, val.length - 2);
+ try {
+ val = JSON.parse(val);
+ } catch (_) {
+ }
+ } else {
+ var esc = false;
+ var unesc = "";
+ for (var i = 0, l = val.length; i < l; i++) {
+ var c = val.charAt(i);
+ if (esc) {
+ if ("\\;#".indexOf(c) !== -1)
+ unesc += c;
+ else
+ unesc += "\\" + c;
+ esc = false;
+ } else if (";#".indexOf(c) !== -1)
+ break;
+ else if (c === "\\")
+ esc = true;
+ else
+ unesc += c;
+ }
+ if (esc)
+ unesc += "\\";
+ return unesc.trim();
+ }
+ return val;
+ }
+ }
+});
+
+// node_modules/rc/node_modules/strip-json-comments/index.js
+var require_strip_json_comments = __commonJS({
+ "node_modules/rc/node_modules/strip-json-comments/index.js"(exports, module2) {
+ "use strict";
+ var singleComment = 1;
+ var multiComment = 2;
+ function stripWithoutWhitespace() {
+ return "";
+ }
+ function stripWithWhitespace(str2, start, end) {
+ return str2.slice(start, end).replace(/\S/g, " ");
+ }
+ module2.exports = function(str2, opts) {
+ opts = opts || {};
+ var currentChar;
+ var nextChar;
+ var insideString = false;
+ var insideComment = false;
+ var offset = 0;
+ var ret = "";
+ var strip = opts.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
+ for (var i = 0; i < str2.length; i++) {
+ currentChar = str2[i];
+ nextChar = str2[i + 1];
+ if (!insideComment && currentChar === '"') {
+ var escaped = str2[i - 1] === "\\" && str2[i - 2] !== "\\";
+ if (!escaped) {
+ insideString = !insideString;
+ }
+ }
+ if (insideString) {
+ continue;
+ }
+ if (!insideComment && currentChar + nextChar === "//") {
+ ret += str2.slice(offset, i);
+ offset = i;
+ insideComment = singleComment;
+ i++;
+ } else if (insideComment === singleComment && currentChar + nextChar === "\r\n") {
+ i++;
+ insideComment = false;
+ ret += strip(str2, offset, i);
+ offset = i;
+ continue;
+ } else if (insideComment === singleComment && currentChar === "\n") {
+ insideComment = false;
+ ret += strip(str2, offset, i);
+ offset = i;
+ } else if (!insideComment && currentChar + nextChar === "/*") {
+ ret += str2.slice(offset, i);
+ offset = i;
+ insideComment = multiComment;
+ i++;
+ continue;
+ } else if (insideComment === multiComment && currentChar + nextChar === "*/") {
+ i++;
+ insideComment = false;
+ ret += strip(str2, offset, i + 1);
+ offset = i + 1;
+ continue;
+ }
+ }
+ return ret + (insideComment ? strip(str2.substr(offset)) : str2.substr(offset));
+ };
+ }
+});
+
+// node_modules/rc/lib/utils.js
+var require_utils2 = __commonJS({
+ "node_modules/rc/lib/utils.js"(exports) {
+ "use strict";
+ var fs2 = require("fs");
+ var ini = require_ini();
+ var path2 = require("path");
+ var stripJsonComments = require_strip_json_comments();
+ var parse = exports.parse = function(content) {
+ if (/^\s*{/.test(content))
+ return JSON.parse(stripJsonComments(content));
+ return ini.parse(content);
+ };
+ var file = exports.file = function() {
+ var args = [].slice.call(arguments).filter(function(arg) {
+ return arg != null;
+ });
+ for (var i in args)
+ if (typeof args[i] !== "string")
+ return;
+ var file2 = path2.join.apply(null, args);
+ var content;
+ try {
+ return fs2.readFileSync(file2, "utf-8");
+ } catch (err) {
+ return;
+ }
+ };
+ var json2 = exports.json = function() {
+ var content = file.apply(null, arguments);
+ return content ? parse(content) : null;
+ };
+ var env = exports.env = function(prefix, env2) {
+ env2 = env2 || process.env;
+ var obj = {};
+ var l = prefix.length;
+ for (var k in env2) {
+ if (k.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
+ var keypath = k.substring(l).split("__");
+ var _emptyStringIndex;
+ while ((_emptyStringIndex = keypath.indexOf("")) > -1) {
+ keypath.splice(_emptyStringIndex, 1);
+ }
+ var cursor = obj;
+ keypath.forEach(function _buildSubObj(_subkey, i) {
+ if (!_subkey || typeof cursor !== "object")
+ return;
+ if (i === keypath.length - 1)
+ cursor[_subkey] = env2[k];
+ if (cursor[_subkey] === void 0)
+ cursor[_subkey] = {};
+ cursor = cursor[_subkey];
+ });
+ }
+ }
+ return obj;
+ };
+ var find = exports.find = function() {
+ var rel = path2.join.apply(null, [].slice.call(arguments));
+ function find2(start, rel2) {
+ var file2 = path2.join(start, rel2);
+ try {
+ fs2.statSync(file2);
+ return file2;
+ } catch (err) {
+ if (path2.dirname(start) !== start)
+ return find2(path2.dirname(start), rel2);
+ }
+ }
+ return find2(process.cwd(), rel);
+ };
+ }
+});
+
+// node_modules/minimist/index.js
+var require_minimist = __commonJS({
+ "node_modules/minimist/index.js"(exports, module2) {
+ module2.exports = function(args, opts) {
+ if (!opts)
+ opts = {};
+ var flags = { bools: {}, strings: {}, unknownFn: null };
+ if (typeof opts["unknown"] === "function") {
+ flags.unknownFn = opts["unknown"];
+ }
+ if (typeof opts["boolean"] === "boolean" && opts["boolean"]) {
+ flags.allBools = true;
+ } else {
+ [].concat(opts["boolean"]).filter(Boolean).forEach(function(key2) {
+ flags.bools[key2] = true;
+ });
+ }
+ var aliases = {};
+ Object.keys(opts.alias || {}).forEach(function(key2) {
+ aliases[key2] = [].concat(opts.alias[key2]);
+ aliases[key2].forEach(function(x) {
+ aliases[x] = [key2].concat(aliases[key2].filter(function(y) {
+ return x !== y;
+ }));
+ });
+ });
+ [].concat(opts.string).filter(Boolean).forEach(function(key2) {
+ flags.strings[key2] = true;
+ if (aliases[key2]) {
+ flags.strings[aliases[key2]] = true;
+ }
+ });
+ var defaults = opts["default"] || {};
+ var argv = { _: [] };
+ Object.keys(flags.bools).forEach(function(key2) {
+ setArg(key2, defaults[key2] === void 0 ? false : defaults[key2]);
+ });
+ var notFlags = [];
+ if (args.indexOf("--") !== -1) {
+ notFlags = args.slice(args.indexOf("--") + 1);
+ args = args.slice(0, args.indexOf("--"));
+ }
+ function argDefined(key2, arg2) {
+ return flags.allBools && /^--[^=]+$/.test(arg2) || flags.strings[key2] || flags.bools[key2] || aliases[key2];
+ }
+ function setArg(key2, val, arg2) {
+ if (arg2 && flags.unknownFn && !argDefined(key2, arg2)) {
+ if (flags.unknownFn(arg2) === false)
+ return;
+ }
+ var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
+ setKey(argv, key2.split("."), value2);
+ (aliases[key2] || []).forEach(function(x) {
+ setKey(argv, x.split("."), value2);
+ });
+ }
+ function setKey(obj, keys, value2) {
+ var o = obj;
+ for (var i2 = 0; i2 < keys.length - 1; i2++) {
+ var key2 = keys[i2];
+ if (key2 === "__proto__")
+ return;
+ if (o[key2] === void 0)
+ o[key2] = {};
+ if (o[key2] === Object.prototype || o[key2] === Number.prototype || o[key2] === String.prototype)
+ o[key2] = {};
+ if (o[key2] === Array.prototype)
+ o[key2] = [];
+ o = o[key2];
+ }
+ var key2 = keys[keys.length - 1];
+ if (key2 === "__proto__")
+ return;
+ if (o === Object.prototype || o === Number.prototype || o === String.prototype)
+ o = {};
+ if (o === Array.prototype)
+ o = [];
+ if (o[key2] === void 0 || flags.bools[key2] || typeof o[key2] === "boolean") {
+ o[key2] = value2;
+ } else if (Array.isArray(o[key2])) {
+ o[key2].push(value2);
+ } else {
+ o[key2] = [o[key2], value2];
+ }
+ }
+ function aliasIsBoolean(key2) {
+ return aliases[key2].some(function(x) {
+ return flags.bools[x];
+ });
+ }
+ for (var i = 0; i < args.length; i++) {
+ var arg = args[i];
+ if (/^--.+=/.test(arg)) {
+ var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+ var key = m[1];
+ var value = m[2];
+ if (flags.bools[key]) {
+ value = value !== "false";
+ }
+ setArg(key, value, arg);
+ } else if (/^--no-.+/.test(arg)) {
+ var key = arg.match(/^--no-(.+)/)[1];
+ setArg(key, false, arg);
+ } else if (/^--.+/.test(arg)) {
+ var key = arg.match(/^--(.+)/)[1];
+ var next = args[i + 1];
+ if (next !== void 0 && !/^-/.test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+ setArg(key, next, arg);
+ i++;
+ } else if (/^(true|false)$/.test(next)) {
+ setArg(key, next === "true", arg);
+ i++;
+ } else {
+ setArg(key, flags.strings[key] ? "" : true, arg);
+ }
+ } else if (/^-[^-]+/.test(arg)) {
+ var letters = arg.slice(1, -1).split("");
+ var broken = false;
+ for (var j = 0; j < letters.length; j++) {
+ var next = arg.slice(j + 2);
+ if (next === "-") {
+ setArg(letters[j], next, arg);
+ continue;
+ }
+ if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+ setArg(letters[j], next.split("=")[1], arg);
+ broken = true;
+ break;
+ }
+ if (/[A-Za-z]/.test(letters[j]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+ setArg(letters[j], next, arg);
+ broken = true;
+ break;
+ }
+ if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+ setArg(letters[j], arg.slice(j + 2), arg);
+ broken = true;
+ break;
+ } else {
+ setArg(letters[j], flags.strings[letters[j]] ? "" : true, arg);
+ }
+ }
+ var key = arg.slice(-1)[0];
+ if (!broken && key !== "-") {
+ if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1]) && !flags.bools[key] && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+ setArg(key, args[i + 1], arg);
+ i++;
+ } else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
+ setArg(key, args[i + 1] === "true", arg);
+ i++;
+ } else {
+ setArg(key, flags.strings[key] ? "" : true, arg);
+ }
+ }
+ } else {
+ if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+ argv._.push(flags.strings["_"] || !isNumber(arg) ? arg : Number(arg));
+ }
+ if (opts.stopEarly) {
+ argv._.push.apply(argv._, args.slice(i + 1));
+ break;
+ }
+ }
+ }
+ Object.keys(defaults).forEach(function(key2) {
+ if (!hasKey(argv, key2.split("."))) {
+ setKey(argv, key2.split("."), defaults[key2]);
+ (aliases[key2] || []).forEach(function(x) {
+ setKey(argv, x.split("."), defaults[key2]);
+ });
+ }
+ });
+ if (opts["--"]) {
+ argv["--"] = new Array();
+ notFlags.forEach(function(key2) {
+ argv["--"].push(key2);
+ });
+ } else {
+ notFlags.forEach(function(key2) {
+ argv._.push(key2);
+ });
+ }
+ return argv;
+ };
+ function hasKey(obj, keys) {
+ var o = obj;
+ keys.slice(0, -1).forEach(function(key2) {
+ o = o[key2] || {};
+ });
+ var key = keys[keys.length - 1];
+ return key in o;
+ }
+ function isNumber(x) {
+ if (typeof x === "number")
+ return true;
+ if (/^0x[0-9a-f]+$/i.test(x))
+ return true;
+ return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+ }
+ }
+});
+
+// node_modules/rc/index.js
+var require_rc = __commonJS({
+ "node_modules/rc/index.js"(exports, module2) {
+ var cc = require_utils2();
+ var join = require("path").join;
+ var deepExtend = require_deep_extend();
+ var etc = "/etc";
+ var win = process.platform === "win32";
+ var home = win ? process.env.USERPROFILE : process.env.HOME;
+ module2.exports = function(name, defaults, argv, parse) {
+ if (typeof name !== "string")
+ throw new Error("rc(name): name *must* be string");
+ if (!argv)
+ argv = require_minimist()(process.argv.slice(2));
+ defaults = (typeof defaults === "string" ? cc.json(defaults) : defaults) || {};
+ parse = parse || cc.parse;
+ var env = cc.env(name + "_");
+ var configs = [defaults];
+ var configFiles = [];
+ function addConfigFile(file) {
+ if (configFiles.indexOf(file) >= 0)
+ return;
+ var fileConfig = cc.file(file);
+ if (fileConfig) {
+ configs.push(parse(fileConfig));
+ configFiles.push(file);
+ }
+ }
+ if (!win)
+ [
+ join(etc, name, "config"),
+ join(etc, name + "rc")
+ ].forEach(addConfigFile);
+ if (home)
+ [
+ join(home, ".config", name, "config"),
+ join(home, ".config", name),
+ join(home, "." + name, "config"),
+ join(home, "." + name + "rc")
+ ].forEach(addConfigFile);
+ addConfigFile(cc.find("." + name + "rc"));
+ if (env.config)
+ addConfigFile(env.config);
+ if (argv.config)
+ addConfigFile(argv.config);
+ return deepExtend.apply(null, configs.concat([
+ env,
+ argv,
+ configFiles.length ? { configs: configFiles, config: configFiles[configFiles.length - 1] } : void 0
+ ]));
+ };
+ }
+});
+
+// src/index.ts
+__export(exports, {
+ activate: () => activate
+});
+var import_coc2 = __toModule(require("coc.nvim"));
+
+// src/engine.ts
+var import_coc = __toModule(require("coc.nvim"));
+var import_deep_extend = __toModule(require_deep_extend());
+var import_fs = __toModule(require("fs"));
+
+// node_modules/js-yaml/dist/js-yaml.mjs
+function isNothing(subject) {
+ return typeof subject === "undefined" || subject === null;
+}
+function isObject(subject) {
+ return typeof subject === "object" && subject !== null;
+}
+function toArray(sequence) {
+ if (Array.isArray(sequence))
+ return sequence;
+ else if (isNothing(sequence))
+ return [];
+ return [sequence];
+}
+function extend(target, source) {
+ var index, length, key, sourceKeys;
+ if (source) {
+ sourceKeys = Object.keys(source);
+ for (index = 0, length = sourceKeys.length; index < length; index += 1) {
+ key = sourceKeys[index];
+ target[key] = source[key];
+ }
+ }
+ return target;
+}
+function repeat(string, count) {
+ var result = "", cycle;
+ for (cycle = 0; cycle < count; cycle += 1) {
+ result += string;
+ }
+ return result;
+}
+function isNegativeZero(number) {
+ return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
+}
+var isNothing_1 = isNothing;
+var isObject_1 = isObject;
+var toArray_1 = toArray;
+var repeat_1 = repeat;
+var isNegativeZero_1 = isNegativeZero;
+var extend_1 = extend;
+var common = {
+ isNothing: isNothing_1,
+ isObject: isObject_1,
+ toArray: toArray_1,
+ repeat: repeat_1,
+ isNegativeZero: isNegativeZero_1,
+ extend: extend_1
+};
+function formatError(exception2, compact) {
+ var where = "", message = exception2.reason || "(unknown reason)";
+ if (!exception2.mark)
+ return message;
+ if (exception2.mark.name) {
+ where += 'in "' + exception2.mark.name + '" ';
+ }
+ where += "(" + (exception2.mark.line + 1) + ":" + (exception2.mark.column + 1) + ")";
+ if (!compact && exception2.mark.snippet) {
+ where += "\n\n" + exception2.mark.snippet;
+ }
+ return message + " " + where;
+}
+function YAMLException$1(reason, mark) {
+ Error.call(this);
+ this.name = "YAMLException";
+ this.reason = reason;
+ this.mark = mark;
+ this.message = formatError(this, false);
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, this.constructor);
+ } else {
+ this.stack = new Error().stack || "";
+ }
+}
+YAMLException$1.prototype = Object.create(Error.prototype);
+YAMLException$1.prototype.constructor = YAMLException$1;
+YAMLException$1.prototype.toString = function toString(compact) {
+ return this.name + ": " + formatError(this, compact);
+};
+var exception = YAMLException$1;
+function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
+ var head = "";
+ var tail = "";
+ var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
+ if (position - lineStart > maxHalfLength) {
+ head = " ... ";
+ lineStart = position - maxHalfLength + head.length;
+ }
+ if (lineEnd - position > maxHalfLength) {
+ tail = " ...";
+ lineEnd = position + maxHalfLength - tail.length;
+ }
+ return {
+ str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "\u2192") + 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;
+ var re = /\r?\n|\r|\0/g;
+ var lineStarts = [0];
+ var lineEnds = [];
+ var match;
+ var foundLineNo = -1;
+ while (match = re.exec(mark.buffer)) {
+ lineEnds.push(match.index);
+ lineStarts.push(match.index + match[0].length);
+ if (mark.position <= match.index && foundLineNo < 0) {
+ foundLineNo = lineStarts.length - 2;
+ }
+ }
+ if (foundLineNo < 0)
+ foundLineNo = lineStarts.length - 1;
+ var result = "", i, line;
+ var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
+ var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
+ for (i = 1; i <= options.linesBefore; i++) {
+ if (foundLineNo - i < 0)
+ break;
+ line = getLine(mark.buffer, lineStarts[foundLineNo - i], lineEnds[foundLineNo - i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), maxLineLength);
+ result = common.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line.str + "\n" + result;
+ }
+ line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
+ result += common.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + "\n";
+ result += common.repeat("-", options.indent + lineNoLength + 3 + line.pos) + "^\n";
+ for (i = 1; i <= options.linesAfter; i++) {
+ if (foundLineNo + i >= lineEnds.length)
+ break;
+ line = getLine(mark.buffer, lineStarts[foundLineNo + i], lineEnds[foundLineNo + i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), maxLineLength);
+ result += common.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line.str + "\n";
+ }
+ return result.replace(/\n$/, "");
+}
+var snippet = makeSnippet;
+var TYPE_CONSTRUCTOR_OPTIONS = [
+ "kind",
+ "multi",
+ "resolve",
+ "construct",
+ "instanceOf",
+ "predicate",
+ "represent",
+ "representName",
+ "defaultStyle",
+ "styleAliases"
+];
+var YAML_NODE_KINDS = [
+ "scalar",
+ "sequence",
+ "mapping"
+];
+function compileStyleAliases(map2) {
+ var result = {};
+ if (map2 !== null) {
+ Object.keys(map2).forEach(function(style) {
+ map2[style].forEach(function(alias) {
+ result[String(alias)] = style;
+ });
+ });
+ }
+ return result;
+}
+function Type$1(tag, options) {
+ options = options || {};
+ Object.keys(options).forEach(function(name) {
+ if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
+ throw new exception('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
+ }
+ });
+ this.options = options;
+ this.tag = tag;
+ this.kind = options["kind"] || null;
+ this.resolve = options["resolve"] || function() {
+ return true;
+ };
+ this.construct = options["construct"] || function(data) {
+ return data;
+ };
+ this.instanceOf = options["instanceOf"] || null;
+ this.predicate = options["predicate"] || null;
+ this.represent = options["represent"] || null;
+ this.representName = options["representName"] || null;
+ this.defaultStyle = options["defaultStyle"] || null;
+ this.multi = options["multi"] || false;
+ this.styleAliases = compileStyleAliases(options["styleAliases"] || null);
+ if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
+ throw new exception('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
+ }
+}
+var type = Type$1;
+function compileList(schema2, name) {
+ var result = [];
+ schema2[name].forEach(function(currentType) {
+ var newIndex = result.length;
+ result.forEach(function(previousType, previousIndex) {
+ if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) {
+ newIndex = previousIndex;
+ }
+ });
+ result[newIndex] = currentType;
+ });
+ return result;
+}
+function compileMap() {
+ var result = {
+ scalar: {},
+ sequence: {},
+ mapping: {},
+ fallback: {},
+ multi: {
+ scalar: [],
+ sequence: [],
+ mapping: [],
+ fallback: []
+ }
+ }, index, length;
+ function collectType(type2) {
+ if (type2.multi) {
+ result.multi[type2.kind].push(type2);
+ result.multi["fallback"].push(type2);
+ } else {
+ result[type2.kind][type2.tag] = result["fallback"][type2.tag] = type2;
+ }
+ }
+ for (index = 0, length = arguments.length; index < length; index += 1) {
+ arguments[index].forEach(collectType);
+ }
+ return result;
+}
+function Schema$1(definition) {
+ return this.extend(definition);
+}
+Schema$1.prototype.extend = function extend2(definition) {
+ var implicit = [];
+ var explicit = [];
+ if (definition instanceof type) {
+ explicit.push(definition);
+ } else if (Array.isArray(definition)) {
+ explicit = explicit.concat(definition);
+ } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
+ if (definition.implicit)
+ implicit = implicit.concat(definition.implicit);
+ if (definition.explicit)
+ explicit = explicit.concat(definition.explicit);
+ } else {
+ throw new exception("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
+ }
+ implicit.forEach(function(type$1) {
+ if (!(type$1 instanceof type)) {
+ throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+ }
+ if (type$1.loadKind && type$1.loadKind !== "scalar") {
+ throw new exception("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
+ }
+ if (type$1.multi) {
+ throw new exception("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.");
+ }
+ });
+ explicit.forEach(function(type$1) {
+ if (!(type$1 instanceof type)) {
+ throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+ }
+ });
+ var result = Object.create(Schema$1.prototype);
+ result.implicit = (this.implicit || []).concat(implicit);
+ result.explicit = (this.explicit || []).concat(explicit);
+ result.compiledImplicit = compileList(result, "implicit");
+ result.compiledExplicit = compileList(result, "explicit");
+ result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit);
+ return result;
+};
+var schema = Schema$1;
+var str = new type("tag:yaml.org,2002:str", {
+ kind: "scalar",
+ construct: function(data) {
+ return data !== null ? data : "";
+ }
+});
+var seq = new type("tag:yaml.org,2002:seq", {
+ kind: "sequence",
+ construct: function(data) {
+ return data !== null ? data : [];
+ }
+});
+var map = new type("tag:yaml.org,2002:map", {
+ kind: "mapping",
+ construct: function(data) {
+ return data !== null ? data : {};
+ }
+});
+var failsafe = new schema({
+ explicit: [
+ str,
+ seq,
+ map
+ ]
+});
+function resolveYamlNull(data) {
+ if (data === null)
+ return true;
+ var max = data.length;
+ return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL");
+}
+function constructYamlNull() {
+ return null;
+}
+function isNull(object) {
+ return object === null;
+}
+var _null = new type("tag:yaml.org,2002:null", {
+ kind: "scalar",
+ resolve: resolveYamlNull,
+ construct: constructYamlNull,
+ predicate: isNull,
+ represent: {
+ canonical: function() {
+ return "~";
+ },
+ lowercase: function() {
+ return "null";
+ },
+ uppercase: function() {
+ return "NULL";
+ },
+ camelcase: function() {
+ return "Null";
+ },
+ empty: function() {
+ return "";
+ }
+ },
+ defaultStyle: "lowercase"
+});
+function resolveYamlBoolean(data) {
+ if (data === null)
+ return false;
+ var max = data.length;
+ return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE");
+}
+function constructYamlBoolean(data) {
+ return data === "true" || data === "True" || data === "TRUE";
+}
+function isBoolean(object) {
+ return Object.prototype.toString.call(object) === "[object Boolean]";
+}
+var bool = new type("tag:yaml.org,2002:bool", {
+ kind: "scalar",
+ resolve: resolveYamlBoolean,
+ construct: constructYamlBoolean,
+ predicate: isBoolean,
+ represent: {
+ lowercase: function(object) {
+ return object ? "true" : "false";
+ },
+ uppercase: function(object) {
+ return object ? "TRUE" : "FALSE";
+ },
+ camelcase: function(object) {
+ return object ? "True" : "False";
+ }
+ },
+ defaultStyle: "lowercase"
+});
+function isHexCode(c) {
+ return 48 <= c && c <= 57 || 65 <= c && c <= 70 || 97 <= c && c <= 102;
+}
+function isOctCode(c) {
+ return 48 <= c && c <= 55;
+}
+function isDecCode(c) {
+ return 48 <= c && c <= 57;
+}
+function resolveYamlInteger(data) {
+ if (data === null)
+ return false;
+ var max = data.length, index = 0, hasDigits = false, ch;
+ if (!max)
+ return false;
+ ch = data[index];
+ if (ch === "-" || ch === "+") {
+ ch = data[++index];
+ }
+ if (ch === "0") {
+ if (index + 1 === max)
+ return true;
+ ch = data[++index];
+ if (ch === "b") {
+ index++;
+ for (; index < max; index++) {
+ ch = data[index];
+ if (ch === "_")
+ continue;
+ if (ch !== "0" && ch !== "1")
+ return false;
+ hasDigits = true;
+ }
+ return hasDigits && ch !== "_";
+ }
+ if (ch === "x") {
+ index++;
+ for (; index < max; index++) {
+ ch = data[index];
+ if (ch === "_")
+ continue;
+ if (!isHexCode(data.charCodeAt(index)))
+ return false;
+ hasDigits = true;
+ }
+ return hasDigits && ch !== "_";
+ }
+ if (ch === "o") {
+ index++;
+ for (; index < max; index++) {
+ ch = data[index];
+ if (ch === "_")
+ continue;
+ if (!isOctCode(data.charCodeAt(index)))
+ return false;
+ hasDigits = true;
+ }
+ return hasDigits && ch !== "_";
+ }
+ }
+ if (ch === "_")
+ return false;
+ for (; index < max; index++) {
+ ch = data[index];
+ if (ch === "_")
+ continue;
+ if (!isDecCode(data.charCodeAt(index))) {
+ return false;
+ }
+ hasDigits = true;
+ }
+ if (!hasDigits || ch === "_")
+ return false;
+ return true;
+}
+function constructYamlInteger(data) {
+ var value = data, sign = 1, ch;
+ if (value.indexOf("_") !== -1) {
+ value = value.replace(/_/g, "");
+ }
+ ch = value[0];
+ if (ch === "-" || ch === "+") {
+ if (ch === "-")
+ sign = -1;
+ value = value.slice(1);
+ ch = value[0];
+ }
+ if (value === "0")
+ return 0;
+ if (ch === "0") {
+ if (value[1] === "b")
+ return sign * parseInt(value.slice(2), 2);
+ if (value[1] === "x")
+ return sign * parseInt(value.slice(2), 16);
+ if (value[1] === "o")
+ return sign * parseInt(value.slice(2), 8);
+ }
+ return sign * parseInt(value, 10);
+}
+function isInteger(object) {
+ return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 === 0 && !common.isNegativeZero(object));
+}
+var int = new type("tag:yaml.org,2002:int", {
+ kind: "scalar",
+ resolve: resolveYamlInteger,
+ construct: constructYamlInteger,
+ predicate: isInteger,
+ represent: {
+ binary: function(obj) {
+ return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
+ },
+ octal: function(obj) {
+ return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1);
+ },
+ decimal: function(obj) {
+ return obj.toString(10);
+ },
+ 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"]
+ }
+});
+var YAML_FLOAT_PATTERN = new RegExp("^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+function resolveYamlFloat(data) {
+ if (data === null)
+ return false;
+ if (!YAML_FLOAT_PATTERN.test(data) || data[data.length - 1] === "_") {
+ return false;
+ }
+ return true;
+}
+function constructYamlFloat(data) {
+ var value, sign;
+ value = data.replace(/_/g, "").toLowerCase();
+ sign = value[0] === "-" ? -1 : 1;
+ if ("+-".indexOf(value[0]) >= 0) {
+ value = value.slice(1);
+ }
+ if (value === ".inf") {
+ return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+ } else if (value === ".nan") {
+ return NaN;
+ }
+ return sign * parseFloat(value, 10);
+}
+var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+function representYamlFloat(object, style) {
+ var res;
+ if (isNaN(object)) {
+ switch (style) {
+ case "lowercase":
+ return ".nan";
+ case "uppercase":
+ return ".NAN";
+ case "camelcase":
+ return ".NaN";
+ }
+ } else if (Number.POSITIVE_INFINITY === object) {
+ switch (style) {
+ case "lowercase":
+ return ".inf";
+ case "uppercase":
+ return ".INF";
+ case "camelcase":
+ return ".Inf";
+ }
+ } else if (Number.NEGATIVE_INFINITY === object) {
+ switch (style) {
+ case "lowercase":
+ return "-.inf";
+ case "uppercase":
+ return "-.INF";
+ case "camelcase":
+ return "-.Inf";
+ }
+ } else if (common.isNegativeZero(object)) {
+ return "-0.0";
+ }
+ res = object.toString(10);
+ return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
+}
+function isFloat(object) {
+ return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object));
+}
+var float = new type("tag:yaml.org,2002:float", {
+ kind: "scalar",
+ resolve: resolveYamlFloat,
+ construct: constructYamlFloat,
+ predicate: isFloat,
+ represent: representYamlFloat,
+ defaultStyle: "lowercase"
+});
+var json = failsafe.extend({
+ implicit: [
+ _null,
+ bool,
+ int,
+ float
+ ]
+});
+var core = json;
+var YAML_DATE_REGEXP = new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
+var YAML_TIMESTAMP_REGEXP = new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
+function resolveYamlTimestamp(data) {
+ if (data === null)
+ return false;
+ if (YAML_DATE_REGEXP.exec(data) !== null)
+ return true;
+ if (YAML_TIMESTAMP_REGEXP.exec(data) !== null)
+ return true;
+ return false;
+}
+function constructYamlTimestamp(data) {
+ var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date;
+ match = YAML_DATE_REGEXP.exec(data);
+ if (match === null)
+ match = YAML_TIMESTAMP_REGEXP.exec(data);
+ if (match === null)
+ throw new Error("Date resolve error");
+ year = +match[1];
+ month = +match[2] - 1;
+ day = +match[3];
+ if (!match[4]) {
+ return new Date(Date.UTC(year, month, day));
+ }
+ hour = +match[4];
+ minute = +match[5];
+ second = +match[6];
+ if (match[7]) {
+ fraction = match[7].slice(0, 3);
+ while (fraction.length < 3) {
+ fraction += "0";
+ }
+ fraction = +fraction;
+ }
+ if (match[9]) {
+ tz_hour = +match[10];
+ tz_minute = +(match[11] || 0);
+ delta = (tz_hour * 60 + tz_minute) * 6e4;
+ if (match[9] === "-")
+ delta = -delta;
+ }
+ date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+ if (delta)
+ date.setTime(date.getTime() - delta);
+ return date;
+}
+function representYamlTimestamp(object) {
+ return object.toISOString();
+}
+var timestamp = new type("tag:yaml.org,2002:timestamp", {
+ kind: "scalar",
+ resolve: resolveYamlTimestamp,
+ construct: constructYamlTimestamp,
+ instanceOf: Date,
+ represent: representYamlTimestamp
+});
+function resolveYamlMerge(data) {
+ return data === "<<" || data === null;
+}
+var merge = new type("tag:yaml.org,2002:merge", {
+ kind: "scalar",
+ resolve: resolveYamlMerge
+});
+var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
+function resolveYamlBinary(data) {
+ if (data === null)
+ return false;
+ var code, idx, bitlen = 0, max = data.length, map2 = BASE64_MAP;
+ for (idx = 0; idx < max; idx++) {
+ code = map2.indexOf(data.charAt(idx));
+ if (code > 64)
+ continue;
+ if (code < 0)
+ return false;
+ bitlen += 6;
+ }
+ return bitlen % 8 === 0;
+}
+function constructYamlBinary(data) {
+ var idx, tailbits, input = data.replace(/[\r\n=]/g, ""), max = input.length, map2 = BASE64_MAP, bits = 0, result = [];
+ for (idx = 0; idx < max; idx++) {
+ if (idx % 4 === 0 && idx) {
+ result.push(bits >> 16 & 255);
+ result.push(bits >> 8 & 255);
+ result.push(bits & 255);
+ }
+ bits = bits << 6 | map2.indexOf(input.charAt(idx));
+ }
+ tailbits = max % 4 * 6;
+ if (tailbits === 0) {
+ result.push(bits >> 16 & 255);
+ result.push(bits >> 8 & 255);
+ result.push(bits & 255);
+ } else if (tailbits === 18) {
+ result.push(bits >> 10 & 255);
+ result.push(bits >> 2 & 255);
+ } else if (tailbits === 12) {
+ result.push(bits >> 4 & 255);
+ }
+ return new Uint8Array(result);
+}
+function representYamlBinary(object) {
+ var result = "", bits = 0, idx, tail, max = object.length, map2 = BASE64_MAP;
+ for (idx = 0; idx < max; idx++) {
+ if (idx % 3 === 0 && idx) {
+ result += map2[bits >> 18 & 63];
+ result += map2[bits >> 12 & 63];
+ result += map2[bits >> 6 & 63];
+ result += map2[bits & 63];
+ }
+ bits = (bits << 8) + object[idx];
+ }
+ tail = max % 3;
+ if (tail === 0) {
+ result += map2[bits >> 18 & 63];
+ result += map2[bits >> 12 & 63];
+ result += map2[bits >> 6 & 63];
+ result += map2[bits & 63];
+ } else if (tail === 2) {
+ result += map2[bits >> 10 & 63];
+ result += map2[bits >> 4 & 63];
+ result += map2[bits << 2 & 63];
+ result += map2[64];
+ } else if (tail === 1) {
+ result += map2[bits >> 2 & 63];
+ result += map2[bits << 4 & 63];
+ result += map2[64];
+ result += map2[64];
+ }
+ return result;
+}
+function isBinary(obj) {
+ return Object.prototype.toString.call(obj) === "[object Uint8Array]";
+}
+var binary = new type("tag:yaml.org,2002:binary", {
+ kind: "scalar",
+ resolve: resolveYamlBinary,
+ construct: constructYamlBinary,
+ predicate: isBinary,
+ represent: representYamlBinary
+});
+var _hasOwnProperty$3 = Object.prototype.hasOwnProperty;
+var _toString$2 = Object.prototype.toString;
+function resolveYamlOmap(data) {
+ if (data === null)
+ return true;
+ var objectKeys = [], index, length, pair, pairKey, pairHasKey, object = data;
+ for (index = 0, length = object.length; index < length; index += 1) {
+ pair = object[index];
+ pairHasKey = false;
+ if (_toString$2.call(pair) !== "[object Object]")
+ return false;
+ for (pairKey in pair) {
+ if (_hasOwnProperty$3.call(pair, pairKey)) {
+ if (!pairHasKey)
+ pairHasKey = true;
+ else
+ return false;
+ }
+ }
+ if (!pairHasKey)
+ return false;
+ if (objectKeys.indexOf(pairKey) === -1)
+ objectKeys.push(pairKey);
+ else
+ return false;
+ }
+ return true;
+}
+function constructYamlOmap(data) {
+ return data !== null ? data : [];
+}
+var omap = new type("tag:yaml.org,2002:omap", {
+ kind: "sequence",
+ resolve: resolveYamlOmap,
+ construct: constructYamlOmap
+});
+var _toString$1 = Object.prototype.toString;
+function resolveYamlPairs(data) {
+ if (data === null)
+ return true;
+ var index, length, pair, keys, result, object = data;
+ result = new Array(object.length);
+ for (index = 0, length = object.length; index < length; index += 1) {
+ pair = object[index];
+ if (_toString$1.call(pair) !== "[object Object]")
+ return false;
+ keys = Object.keys(pair);
+ if (keys.length !== 1)
+ return false;
+ result[index] = [keys[0], pair[keys[0]]];
+ }
+ return true;
+}
+function constructYamlPairs(data) {
+ if (data === null)
+ return [];
+ var index, length, pair, keys, result, object = data;
+ result = new Array(object.length);
+ for (index = 0, length = object.length; index < length; index += 1) {
+ pair = object[index];
+ keys = Object.keys(pair);
+ result[index] = [keys[0], pair[keys[0]]];
+ }
+ return result;
+}
+var pairs = new type("tag:yaml.org,2002:pairs", {
+ kind: "sequence",
+ resolve: resolveYamlPairs,
+ construct: constructYamlPairs
+});
+var _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
+function resolveYamlSet(data) {
+ if (data === null)
+ return true;
+ var key, object = data;
+ for (key in object) {
+ if (_hasOwnProperty$2.call(object, key)) {
+ if (object[key] !== null)
+ return false;
+ }
+ }
+ return true;
+}
+function constructYamlSet(data) {
+ return data !== null ? data : {};
+}
+var set = new type("tag:yaml.org,2002:set", {
+ kind: "mapping",
+ resolve: resolveYamlSet,
+ construct: constructYamlSet
+});
+var _default = core.extend({
+ implicit: [
+ timestamp,
+ merge
+ ],
+ explicit: [
+ binary,
+ omap,
+ pairs,
+ set
+ ]
+});
+var _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+var CONTEXT_FLOW_IN = 1;
+var CONTEXT_FLOW_OUT = 2;
+var CONTEXT_BLOCK_IN = 3;
+var CONTEXT_BLOCK_OUT = 4;
+var CHOMPING_CLIP = 1;
+var CHOMPING_STRIP = 2;
+var CHOMPING_KEEP = 3;
+var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
+var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
+var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+function _class(obj) {
+ return Object.prototype.toString.call(obj);
+}
+function is_EOL(c) {
+ return c === 10 || c === 13;
+}
+function is_WHITE_SPACE(c) {
+ return c === 9 || c === 32;
+}
+function is_WS_OR_EOL(c) {
+ return c === 9 || c === 32 || c === 10 || c === 13;
+}
+function is_FLOW_INDICATOR(c) {
+ return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
+}
+function fromHexCode(c) {
+ var lc;
+ if (48 <= c && c <= 57) {
+ return c - 48;
+ }
+ lc = c | 32;
+ if (97 <= lc && lc <= 102) {
+ return lc - 97 + 10;
+ }
+ return -1;
+}
+function escapedHexLen(c) {
+ if (c === 120) {
+ return 2;
+ }
+ if (c === 117) {
+ return 4;
+ }
+ if (c === 85) {
+ return 8;
+ }
+ return 0;
+}
+function fromDecimalCode(c) {
+ if (48 <= c && c <= 57) {
+ return c - 48;
+ }
+ return -1;
+}
+function simpleEscapeSequence(c) {
+ return c === 48 ? "\0" : c === 97 ? "\x07" : c === 98 ? "\b" : c === 116 ? " " : c === 9 ? " " : c === 110 ? "\n" : c === 118 ? "\v" : c === 102 ? "\f" : c === 114 ? "\r" : c === 101 ? "\e" : c === 32 ? " " : c === 34 ? '"' : c === 47 ? "/" : c === 92 ? "\\" : c === 78 ? "\x85" : c === 95 ? "\xA0" : c === 76 ? "\u2028" : c === 80 ? "\u2029" : "";
+}
+function charFromCodepoint(c) {
+ if (c <= 65535) {
+ return String.fromCharCode(c);
+ }
+ return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320);
+}
+var simpleEscapeCheck = new Array(256);
+var simpleEscapeMap = new Array(256);
+for (i = 0; i < 256; i++) {
+ simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
+ simpleEscapeMap[i] = simpleEscapeSequence(i);
+}
+var i;
+function State$1(input, options) {
+ this.input = input;
+ this.filename = options["filename"] || null;
+ this.schema = options["schema"] || _default;
+ this.onWarning = options["onWarning"] || null;
+ this.legacy = options["legacy"] || false;
+ this.json = options["json"] || false;
+ this.listener = options["listener"] || null;
+ this.implicitTypes = this.schema.compiledImplicit;
+ this.typeMap = this.schema.compiledTypeMap;
+ this.length = input.length;
+ this.position = 0;
+ this.line = 0;
+ this.lineStart = 0;
+ this.lineIndent = 0;
+ this.firstTabInLine = -1;
+ this.documents = [];
+}
+function generateError(state, message) {
+ var mark = {
+ name: state.filename,
+ buffer: state.input.slice(0, -1),
+ position: state.position,
+ line: state.line,
+ column: state.position - state.lineStart
+ };
+ mark.snippet = snippet(mark);
+ return new exception(message, mark);
+}
+function throwError(state, message) {
+ throw generateError(state, message);
+}
+function throwWarning(state, message) {
+ if (state.onWarning) {
+ state.onWarning.call(null, generateError(state, message));
+ }
+}
+var directiveHandlers = {
+ YAML: function handleYamlDirective(state, name, args) {
+ var match, major, minor;
+ if (state.version !== null) {
+ throwError(state, "duplication of %YAML directive");
+ }
+ if (args.length !== 1) {
+ throwError(state, "YAML directive accepts exactly one argument");
+ }
+ match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+ if (match === null) {
+ throwError(state, "ill-formed argument of the YAML directive");
+ }
+ major = parseInt(match[1], 10);
+ minor = parseInt(match[2], 10);
+ if (major !== 1) {
+ throwError(state, "unacceptable YAML version of the document");
+ }
+ state.version = args[0];
+ state.checkLineBreaks = minor < 2;
+ if (minor !== 1 && minor !== 2) {
+ throwWarning(state, "unsupported YAML version of the document");
+ }
+ },
+ TAG: function handleTagDirective(state, name, args) {
+ var handle, prefix;
+ if (args.length !== 2) {
+ throwError(state, "TAG directive accepts exactly two arguments");
+ }
+ handle = args[0];
+ prefix = args[1];
+ if (!PATTERN_TAG_HANDLE.test(handle)) {
+ throwError(state, "ill-formed tag handle (first argument) of the TAG directive");
+ }
+ if (_hasOwnProperty$1.call(state.tagMap, handle)) {
+ throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
+ }
+ if (!PATTERN_TAG_URI.test(prefix)) {
+ throwError(state, "ill-formed tag prefix (second argument) of the TAG directive");
+ }
+ try {
+ prefix = decodeURIComponent(prefix);
+ } catch (err) {
+ throwError(state, "tag prefix is malformed: " + prefix);
+ }
+ state.tagMap[handle] = prefix;
+ }
+};
+function captureSegment(state, start, end, checkJson) {
+ var _position, _length, _character, _result;
+ if (start < end) {
+ _result = state.input.slice(start, end);
+ if (checkJson) {
+ for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
+ _character = _result.charCodeAt(_position);
+ if (!(_character === 9 || 32 <= _character && _character <= 1114111)) {
+ throwError(state, "expected valid JSON character");
+ }
+ }
+ } else if (PATTERN_NON_PRINTABLE.test(_result)) {
+ throwError(state, "the stream contains non-printable characters");
+ }
+ state.result += _result;
+ }
+}
+function mergeMappings(state, destination, source, overridableKeys) {
+ var sourceKeys, key, index, quantity;
+ if (!common.isObject(source)) {
+ throwError(state, "cannot merge mappings; the provided source object is unacceptable");
+ }
+ sourceKeys = Object.keys(source);
+ for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
+ key = sourceKeys[index];
+ if (!_hasOwnProperty$1.call(destination, key)) {
+ destination[key] = source[key];
+ overridableKeys[key] = true;
+ }
+ }
+}
+function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) {
+ var index, quantity;
+ if (Array.isArray(keyNode)) {
+ keyNode = Array.prototype.slice.call(keyNode);
+ for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
+ if (Array.isArray(keyNode[index])) {
+ throwError(state, "nested arrays are not supported inside keys");
+ }
+ if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") {
+ keyNode[index] = "[object Object]";
+ }
+ }
+ }
+ if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") {
+ keyNode = "[object Object]";
+ }
+ keyNode = String(keyNode);
+ if (_result === null) {
+ _result = {};
+ }
+ if (keyTag === "tag:yaml.org,2002:merge") {
+ if (Array.isArray(valueNode)) {
+ for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
+ mergeMappings(state, _result, valueNode[index], overridableKeys);
+ }
+ } else {
+ mergeMappings(state, _result, valueNode, overridableKeys);
+ }
+ } else {
+ if (!state.json && !_hasOwnProperty$1.call(overridableKeys, keyNode) && _hasOwnProperty$1.call(_result, keyNode)) {
+ state.line = startLine || state.line;
+ state.lineStart = startLineStart || state.lineStart;
+ state.position = startPos || state.position;
+ throwError(state, "duplicated mapping key");
+ }
+ if (keyNode === "__proto__") {
+ Object.defineProperty(_result, keyNode, {
+ configurable: true,
+ enumerable: true,
+ writable: true,
+ value: valueNode
+ });
+ } else {
+ _result[keyNode] = valueNode;
+ }
+ delete overridableKeys[keyNode];
+ }
+ return _result;
+}
+function readLineBreak(state) {
+ var ch;
+ ch = state.input.charCodeAt(state.position);
+ if (ch === 10) {
+ state.position++;
+ } else if (ch === 13) {
+ state.position++;
+ if (state.input.charCodeAt(state.position) === 10) {
+ state.position++;
+ }
+ } else {
+ throwError(state, "a line break is expected");
+ }
+ state.line += 1;
+ state.lineStart = state.position;
+ state.firstTabInLine = -1;
+}
+function skipSeparationSpace(state, allowComments, checkIndent) {
+ var lineBreaks = 0, ch = state.input.charCodeAt(state.position);
+ while (ch !== 0) {
+ while (is_WHITE_SPACE(ch)) {
+ if (ch === 9 && state.firstTabInLine === -1) {
+ state.firstTabInLine = state.position;
+ }
+ ch = state.input.charCodeAt(++state.position);
+ }
+ if (allowComments && ch === 35) {
+ do {
+ ch = state.input.charCodeAt(++state.position);
+ } while (ch !== 10 && ch !== 13 && ch !== 0);
+ }
+ if (is_EOL(ch)) {
+ readLineBreak(state);
+ ch = state.input.charCodeAt(state.position);
+ lineBreaks++;
+ state.lineIndent = 0;
+ while (ch === 32) {
+ state.lineIndent++;
+ ch = state.input.charCodeAt(++state.position);
+ }
+ } else {
+ break;
+ }
+ }
+ if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
+ throwWarning(state, "deficient indentation");
+ }
+ return lineBreaks;
+}
+function testDocumentSeparator(state) {
+ var _position = state.position, ch;
+ ch = state.input.charCodeAt(_position);
+ if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
+ _position += 3;
+ ch = state.input.charCodeAt(_position);
+ if (ch === 0 || is_WS_OR_EOL(ch)) {
+ return true;
+ }
+ }
+ return false;
+}
+function writeFoldedLines(state, count) {
+ if (count === 1) {
+ state.result += " ";
+ } else if (count > 1) {
+ state.result += common.repeat("\n", count - 1);
+ }
+}
+function readPlainScalar(state, nodeIndent, withinFlowCollection) {
+ var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state.kind, _result = state.result, ch;
+ ch = state.input.charCodeAt(state.position);
+ if (is_WS_OR_EOL(ch) || is_FLOW_INDICATOR(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) {
+ return false;
+ }
+ if (ch === 63 || ch === 45) {
+ following = state.input.charCodeAt(state.position + 1);
+ if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
+ return false;
+ }
+ }
+ state.kind = "scalar";
+ state.result = "";
+ captureStart = captureEnd = state.position;
+ hasPendingContent = false;
+ while (ch !== 0) {
+ if (ch === 58) {
+ following = state.input.charCodeAt(state.position + 1);
+ if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
+ break;
+ }
+ } else if (ch === 35) {
+ preceding = state.input.charCodeAt(state.position - 1);
+ if (is_WS_OR_EOL(preceding)) {
+ break;
+ }
+ } else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && is_FLOW_INDICATOR(ch)) {
+ break;
+ } else if (is_EOL(ch)) {
+ _line = state.line;
+ _lineStart = state.lineStart;
+ _lineIndent = state.lineIndent;
+ skipSeparationSpace(state, false, -1);
+ if (state.lineIndent >= nodeIndent) {
+ hasPendingContent = true;
+ ch = state.input.charCodeAt(state.position);
+ continue;
+ } else {
+ state.position = captureEnd;
+ state.line = _line;
+ state.lineStart = _lineStart;
+ state.lineIndent = _lineIndent;
+ break;
+ }
+ }
+ if (hasPendingContent) {
+ captureSegment(state, captureStart, captureEnd, false);
+ writeFoldedLines(state, state.line - _line);
+ captureStart = captureEnd = state.position;
+ hasPendingContent = false;
+ }
+ if (!is_WHITE_SPACE(ch)) {
+ captureEnd = state.position + 1;
+ }
+ ch = state.input.charCodeAt(++state.position);
+ }
+ captureSegment(state, captureStart, captureEnd, false);
+ if (state.result) {
+ return true;
+ }
+ state.kind = _kind;
+ state.result = _result;
+ return false;
+}
+function readSingleQuotedScalar(state, nodeIndent) {
+ var ch, captureStart, captureEnd;
+ ch = state.input.charCodeAt(state.position);
+ if (ch !== 39) {
+ return false;
+ }
+ state.kind = "scalar";
+ state.result = "";
+ state.position++;
+ captureStart = captureEnd = state.position;
+ while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+ if (ch === 39) {
+ captureSegment(state, captureStart, state.position, true);
+ ch = state.input.charCodeAt(++state.position);
+ if (ch === 39) {
+ captureStart = state.position;
+ state.position++;
+ captureEnd = state.position;
+ } else {
+ return true;
+ }
+ } else if (is_EOL(ch)) {
+ captureSegment(state, captureStart, captureEnd, true);
+ writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+ captureStart = captureEnd = state.position;
+ } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
+ throwError(state, "unexpected end of the document within a single quoted scalar");
+ } else {
+ state.position++;
+ captureEnd = state.position;
+ }
+ }
+ throwError(state, "unexpected end of the stream within a single quoted scalar");
+}
+function readDoubleQuotedScalar(state, nodeIndent) {
+ var captureStart, captureEnd, hexLength, hexResult, tmp, ch;
+ ch = state.input.charCodeAt(state.position);
+ if (ch !== 34) {
+ return false;
+ }
+ state.kind = "scalar";
+ state.result = "";
+ state.position++;
+ captureStart = captureEnd = state.position;
+ while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+ if (ch === 34) {
+ captureSegment(state, captureStart, state.position, true);
+ state.position++;
+ return true;
+ } else if (ch === 92) {
+ captureSegment(state, captureStart, state.position, true);
+ ch = state.input.charCodeAt(++state.position);
+ if (is_EOL(ch)) {
+ skipSeparationSpace(state, false, nodeIndent);
+ } else if (ch < 256 && simpleEscapeCheck[ch]) {
+ state.result += simpleEscapeMap[ch];
+ state.position++;
+ } else if ((tmp = escapedHexLen(ch)) > 0) {
+ hexLength = tmp;
+ hexResult = 0;
+ for (; hexLength > 0; hexLength--) {
+ ch = state.input.charCodeAt(++state.position);
+ if ((tmp = fromHexCode(ch)) >= 0) {
+ hexResult = (hexResult << 4) + tmp;
+ } else {
+ throwError(state, "expected hexadecimal character");
+ }
+ }
+ state.result += charFromCodepoint(hexResult);
+ state.position++;
+ } else {
+ throwError(state, "unknown escape sequence");
+ }
+ captureStart = captureEnd = state.position;
+ } else if (is_EOL(ch)) {
+ captureSegment(state, captureStart, captureEnd, true);
+ writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+ captureStart = captureEnd = state.position;
+ } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
+ throwError(state, "unexpected end of the document within a double quoted scalar");
+ } else {
+ state.position++;
+ captureEnd = state.position;
+ }
+ }
+ throwError(state, "unexpected end of the stream within a double quoted scalar");
+}
+function readFlowCollection(state, nodeIndent) {
+ var readNext = true, _line, _lineStart, _pos, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = Object.create(null), keyNode, keyTag, valueNode, ch;
+ ch = state.input.charCodeAt(state.position);
+ if (ch === 91) {
+ terminator = 93;
+ isMapping = false;
+ _result = [];
+ } else if (ch === 123) {
+ terminator = 125;
+ isMapping = true;
+ _result = {};
+ } else {
+ return false;
+ }
+ if (state.anchor !== null) {
+ state.anchorMap[state.anchor] = _result;
+ }
+ ch = state.input.charCodeAt(++state.position);
+ while (ch !== 0) {
+ skipSeparationSpace(state, true, nodeIndent);
+ ch = state.input.charCodeAt(state.position);
+ if (ch === terminator) {
+ state.position++;
+ state.tag = _tag;
+ state.anchor = _anchor;
+ state.kind = isMapping ? "mapping" : "sequence";
+ state.result = _result;
+ return true;
+ } else if (!readNext) {
+ throwError(state, "missed comma between flow collection entries");
+ } else if (ch === 44) {
+ throwError(state, "expected the node content, but found ','");
+ }
+ keyTag = keyNode = valueNode = null;
+ isPair = isExplicitPair = false;
+ if (ch === 63) {
+ following = state.input.charCodeAt(state.position + 1);
+ if (is_WS_OR_EOL(following)) {
+ isPair = isExplicitPair = true;
+ 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) {
+ var captureStart, folding, chomping = CHOMPING_CLIP, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch;
+ ch = state.input.charCodeAt(state.position);
+ if (ch === 124) {
+ folding = false;
+ } else if (ch === 62) {
+ folding = true;
+ } else {
+ return false;
+ }
+ state.kind = "scalar";
+ state.result = "";
+ while (ch !== 0) {
+ ch = state.input.charCodeAt(++state.position);
+ if (ch === 43 || ch === 45) {
+ if (CHOMPING_CLIP === chomping) {
+ chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP;
+ } else {
+ throwError(state, "repeat of a chomping mode identifier");
+ }
+ } else if ((tmp = fromDecimalCode(ch)) >= 0) {
+ if (tmp === 0) {
+ throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
+ } else if (!detectedIndent) {
+ textIndent = nodeIndent + tmp - 1;
+ detectedIndent = true;
+ } else {
+ throwError(state, "repeat of an indentation width identifier");
+ }
+ } else {
+ break;
+ }
+ }
+ if (is_WHITE_SPACE(ch)) {
+ do {
+ ch = state.input.charCodeAt(++state.position);
+ } while (is_WHITE_SPACE(ch));
+ if (ch === 35) {
+ do {
+ ch = state.input.charCodeAt(++state.position);
+ } while (!is_EOL(ch) && ch !== 0);
+ }
+ }
+ while (ch !== 0) {
+ readLineBreak(state);
+ state.lineIndent = 0;
+ ch = state.input.charCodeAt(state.position);
+ while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) {
+ state.lineIndent++;
+ ch = state.input.charCodeAt(++state.position);
+ }
+ if (!detectedIndent && state.lineIndent > textIndent) {
+ textIndent = state.lineIndent;
+ }
+ if (is_EOL(ch)) {
+ emptyLines++;
+ continue;
+ }
+ if (state.lineIndent < textIndent) {
+ if (chomping === CHOMPING_KEEP) {
+ state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+ } else if (chomping === CHOMPING_CLIP) {
+ if (didReadContent) {
+ state.result += "\n";