From 6f78fa1f2044c53a301d95379df916817c0a3ff3 Mon Sep 17 00:00:00 2001 From: chris Date: Tue, 24 May 2022 14:29:22 +0800 Subject: [PATCH] Update show main.js --- .gitignore | 2 +- main.js | 14931 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 14932 insertions(+), 1 deletion(-) create mode 100644 main.js diff --git a/.gitignore b/.gitignore index e09a007..b5b913d 100644 --- a/.gitignore +++ b/.gitignore @@ -10,7 +10,7 @@ node_modules # Don't include the compiled main.js file in the repo. # They should be uploaded to GitHub releases instead. -main.js +# main.js # Exclude sourcemaps *.map diff --git a/main.js b/main.js new file mode 100644 index 0000000..bdb7c6e --- /dev/null +++ b/main.js @@ -0,0 +1,14931 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ + +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __markAsModule = (target) => __defProp(target, "__esModule", { value: true }); +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + __markAsModule(target); + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __reExport = (target, module2, desc) => { + if (module2 && typeof module2 === "object" || typeof module2 === "function") { + for (let key of __getOwnPropNames(module2)) + if (!__hasOwnProp.call(target, key) && key !== "default") + __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable }); + } + return target; +}; +var __toModule = (module2) => { + return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2); +}; +var __async = (__this, __arguments, generator) => { + return new Promise((resolve, reject) => { + var fulfilled = (value) => { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + }; + var rejected = (value) => { + try { + step(generator.throw(value)); + } catch (e) { + reject(e); + } + }; + var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected); + step((generator = generator.apply(__this, __arguments)).next()); + }); +}; + +// node_modules/bail/index.js +var require_bail = __commonJS({ + "node_modules/bail/index.js"(exports, module2) { + "use strict"; + module2.exports = bail; + function bail(err) { + if (err) { + throw err; + } + } + } +}); + +// node_modules/is-buffer/index.js +var require_is_buffer = __commonJS({ + "node_modules/is-buffer/index.js"(exports, module2) { + module2.exports = function isBuffer(obj) { + return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj); + }; + } +}); + +// node_modules/extend/index.js +var require_extend = __commonJS({ + "node_modules/extend/index.js"(exports, module2) { + "use strict"; + var hasOwn = Object.prototype.hasOwnProperty; + var toStr = Object.prototype.toString; + var defineProperty = Object.defineProperty; + var gOPD = Object.getOwnPropertyDescriptor; + var isArray = function isArray2(arr) { + if (typeof Array.isArray === "function") { + return Array.isArray(arr); + } + return toStr.call(arr) === "[object Array]"; + }; + var isPlainObject = function isPlainObject2(obj) { + if (!obj || toStr.call(obj) !== "[object Object]") { + return false; + } + var hasOwnConstructor = hasOwn.call(obj, "constructor"); + var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, "isPrototypeOf"); + if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { + return false; + } + var key; + for (key in obj) { + } + return typeof key === "undefined" || hasOwn.call(obj, key); + }; + var setProperty = function setProperty2(target, options) { + if (defineProperty && options.name === "__proto__") { + defineProperty(target, options.name, { + enumerable: true, + configurable: true, + value: options.newValue, + writable: true + }); + } else { + target[options.name] = options.newValue; + } + }; + var getProperty = function getProperty2(obj, name) { + if (name === "__proto__") { + if (!hasOwn.call(obj, name)) { + return void 0; + } else if (gOPD) { + return gOPD(obj, name).value; + } + } + return obj[name]; + }; + module2.exports = function extend() { + var options, name, src, copy, copyIsArray, clone; + var target = arguments[0]; + var i = 1; + var length = arguments.length; + var deep = false; + if (typeof target === "boolean") { + deep = target; + target = arguments[1] || {}; + i = 2; + } + if (target == null || typeof target !== "object" && typeof target !== "function") { + target = {}; + } + for (; i < length; ++i) { + options = arguments[i]; + if (options != null) { + for (name in options) { + src = getProperty(target, name); + copy = getProperty(options, name); + if (target !== copy) { + if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { + if (copyIsArray) { + copyIsArray = false; + clone = src && isArray(src) ? src : []; + } else { + clone = src && isPlainObject(src) ? src : {}; + } + setProperty(target, { name, newValue: extend(deep, clone, copy) }); + } else if (typeof copy !== "undefined") { + setProperty(target, { name, newValue: copy }); + } + } + } + } + } + return target; + }; + } +}); + +// node_modules/is-plain-obj/index.js +var require_is_plain_obj = __commonJS({ + "node_modules/is-plain-obj/index.js"(exports, module2) { + "use strict"; + module2.exports = (value) => { + if (Object.prototype.toString.call(value) !== "[object Object]") { + return false; + } + const prototype = Object.getPrototypeOf(value); + return prototype === null || prototype === Object.prototype; + }; + } +}); + +// node_modules/trough/wrap.js +var require_wrap = __commonJS({ + "node_modules/trough/wrap.js"(exports, module2) { + "use strict"; + var slice = [].slice; + module2.exports = wrap; + function wrap(fn, callback) { + var invoked; + return wrapped; + function wrapped() { + var params = slice.call(arguments, 0); + var callback2 = fn.length > params.length; + var result; + if (callback2) { + params.push(done); + } + try { + result = fn.apply(null, params); + } catch (error) { + if (callback2 && invoked) { + throw error; + } + return done(error); + } + if (!callback2) { + if (result && typeof result.then === "function") { + result.then(then, done); + } else if (result instanceof Error) { + done(result); + } else { + then(result); + } + } + } + function done() { + if (!invoked) { + invoked = true; + callback.apply(null, arguments); + } + } + function then(value) { + done(null, value); + } + } + } +}); + +// node_modules/trough/index.js +var require_trough = __commonJS({ + "node_modules/trough/index.js"(exports, module2) { + "use strict"; + var wrap = require_wrap(); + module2.exports = trough; + trough.wrap = wrap; + var slice = [].slice; + function trough() { + var fns = []; + var middleware = {}; + middleware.run = run; + middleware.use = use; + return middleware; + function run() { + var index = -1; + var input = slice.call(arguments, 0, -1); + var done = arguments[arguments.length - 1]; + if (typeof done !== "function") { + throw new Error("Expected function as last argument, not " + done); + } + next.apply(null, [null].concat(input)); + function next(err) { + var fn = fns[++index]; + var params = slice.call(arguments, 0); + var values = params.slice(1); + var length = input.length; + var pos = -1; + if (err) { + done(err); + return; + } + while (++pos < length) { + if (values[pos] === null || values[pos] === void 0) { + values[pos] = input[pos]; + } + } + input = values; + if (fn) { + wrap(fn, next).apply(null, input); + } else { + done.apply(null, [null].concat(input)); + } + } + } + function use(fn) { + if (typeof fn !== "function") { + throw new Error("Expected `fn` to be a function, not " + fn); + } + fns.push(fn); + return middleware; + } + } + } +}); + +// node_modules/unist-util-stringify-position/index.js +var require_unist_util_stringify_position = __commonJS({ + "node_modules/unist-util-stringify-position/index.js"(exports, module2) { + "use strict"; + var own = {}.hasOwnProperty; + module2.exports = stringify4; + function stringify4(value) { + if (!value || typeof value !== "object") { + return ""; + } + if (own.call(value, "position") || own.call(value, "type")) { + return position(value.position); + } + if (own.call(value, "start") || own.call(value, "end")) { + return position(value); + } + if (own.call(value, "line") || own.call(value, "column")) { + return point(value); + } + return ""; + } + function point(point2) { + if (!point2 || typeof point2 !== "object") { + point2 = {}; + } + return index(point2.line) + ":" + index(point2.column); + } + function position(pos) { + if (!pos || typeof pos !== "object") { + pos = {}; + } + return point(pos.start) + "-" + point(pos.end); + } + function index(value) { + return value && typeof value === "number" ? value : 1; + } + } +}); + +// node_modules/vfile-message/index.js +var require_vfile_message = __commonJS({ + "node_modules/vfile-message/index.js"(exports, module2) { + "use strict"; + var stringify4 = require_unist_util_stringify_position(); + module2.exports = VMessage; + function VMessagePrototype() { + } + VMessagePrototype.prototype = Error.prototype; + VMessage.prototype = new VMessagePrototype(); + var proto = VMessage.prototype; + proto.file = ""; + proto.name = ""; + proto.reason = ""; + proto.message = ""; + proto.stack = ""; + proto.fatal = null; + proto.column = null; + proto.line = null; + function VMessage(reason, position, origin) { + var parts; + var range; + var location; + if (typeof position === "string") { + origin = position; + position = null; + } + parts = parseOrigin(origin); + range = stringify4(position) || "1:1"; + location = { + start: { line: null, column: null }, + end: { line: null, column: null } + }; + if (position && position.position) { + position = position.position; + } + if (position) { + if (position.start) { + location = position; + position = position.start; + } else { + location.start = position; + } + } + if (reason.stack) { + this.stack = reason.stack; + reason = reason.message; + } + this.message = reason; + this.name = range; + this.reason = reason; + this.line = position ? position.line : null; + this.column = position ? position.column : null; + this.location = location; + this.source = parts[0]; + this.ruleId = parts[1]; + } + function parseOrigin(origin) { + var result = [null, null]; + var index; + if (typeof origin === "string") { + index = origin.indexOf(":"); + if (index === -1) { + result[1] = origin; + } else { + result[0] = origin.slice(0, index); + result[1] = origin.slice(index + 1); + } + } + return result; + } + } +}); + +// node_modules/vfile/lib/minpath.browser.js +var require_minpath_browser = __commonJS({ + "node_modules/vfile/lib/minpath.browser.js"(exports) { + "use strict"; + exports.basename = basename; + exports.dirname = dirname; + exports.extname = extname; + exports.join = join2; + exports.sep = "/"; + function basename(path, ext) { + var start = 0; + var end = -1; + var index; + var firstNonSlashEnd; + var seenNonSlash; + var extIndex; + if (ext !== void 0 && typeof ext !== "string") { + throw new TypeError('"ext" argument must be a string'); + } + assertPath(path); + index = path.length; + if (ext === void 0 || !ext.length || ext.length > path.length) { + while (index--) { + if (path.charCodeAt(index) === 47) { + if (seenNonSlash) { + start = index + 1; + break; + } + } else if (end < 0) { + seenNonSlash = true; + end = index + 1; + } + } + return end < 0 ? "" : path.slice(start, end); + } + if (ext === path) { + return ""; + } + firstNonSlashEnd = -1; + extIndex = ext.length - 1; + while (index--) { + if (path.charCodeAt(index) === 47) { + if (seenNonSlash) { + start = index + 1; + break; + } + } else { + if (firstNonSlashEnd < 0) { + seenNonSlash = true; + firstNonSlashEnd = index + 1; + } + if (extIndex > -1) { + if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) { + if (extIndex < 0) { + end = index; + } + } else { + extIndex = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) { + end = firstNonSlashEnd; + } else if (end < 0) { + end = path.length; + } + return path.slice(start, end); + } + function dirname(path) { + var end; + var unmatchedSlash; + var index; + assertPath(path); + if (!path.length) { + return "."; + } + end = -1; + index = path.length; + while (--index) { + if (path.charCodeAt(index) === 47) { + if (unmatchedSlash) { + end = index; + break; + } + } else if (!unmatchedSlash) { + unmatchedSlash = true; + } + } + return end < 0 ? path.charCodeAt(0) === 47 ? "/" : "." : end === 1 && path.charCodeAt(0) === 47 ? "//" : path.slice(0, end); + } + function extname(path) { + var startDot = -1; + var startPart = 0; + var end = -1; + var preDotState = 0; + var unmatchedSlash; + var code; + var index; + assertPath(path); + index = path.length; + while (index--) { + code = path.charCodeAt(index); + if (code === 47) { + if (unmatchedSlash) { + startPart = index + 1; + break; + } + continue; + } + if (end < 0) { + unmatchedSlash = true; + end = index + 1; + } + if (code === 46) { + if (startDot < 0) { + startDot = index; + } else if (preDotState !== 1) { + preDotState = 1; + } + } else if (startDot > -1) { + preDotState = -1; + } + } + if (startDot < 0 || end < 0 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path.slice(startDot, end); + } + function join2() { + var index = -1; + var joined; + while (++index < arguments.length) { + assertPath(arguments[index]); + if (arguments[index]) { + joined = joined === void 0 ? arguments[index] : joined + "/" + arguments[index]; + } + } + return joined === void 0 ? "." : normalize(joined); + } + function normalize(path) { + var absolute; + var value; + assertPath(path); + absolute = path.charCodeAt(0) === 47; + value = normalizeString(path, !absolute); + if (!value.length && !absolute) { + value = "."; + } + if (value.length && path.charCodeAt(path.length - 1) === 47) { + value += "/"; + } + return absolute ? "/" + value : value; + } + function normalizeString(path, allowAboveRoot) { + var result = ""; + var lastSegmentLength = 0; + var lastSlash = -1; + var dots = 0; + var index = -1; + var code; + var lastSlashIndex; + while (++index <= path.length) { + if (index < path.length) { + code = path.charCodeAt(index); + } else if (code === 47) { + break; + } else { + code = 47; + } + if (code === 47) { + if (lastSlash === index - 1 || dots === 1) { + } else if (lastSlash !== index - 1 && dots === 2) { + if (result.length < 2 || lastSegmentLength !== 2 || result.charCodeAt(result.length - 1) !== 46 || result.charCodeAt(result.length - 2) !== 46) { + if (result.length > 2) { + lastSlashIndex = result.lastIndexOf("/"); + if (lastSlashIndex !== result.length - 1) { + if (lastSlashIndex < 0) { + result = ""; + lastSegmentLength = 0; + } else { + result = result.slice(0, lastSlashIndex); + lastSegmentLength = result.length - 1 - result.lastIndexOf("/"); + } + lastSlash = index; + dots = 0; + continue; + } + } else if (result.length) { + result = ""; + lastSegmentLength = 0; + lastSlash = index; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + result = result.length ? result + "/.." : ".."; + lastSegmentLength = 2; + } + } else { + if (result.length) { + result += "/" + path.slice(lastSlash + 1, index); + } else { + result = path.slice(lastSlash + 1, index); + } + lastSegmentLength = index - lastSlash - 1; + } + lastSlash = index; + dots = 0; + } else if (code === 46 && dots > -1) { + dots++; + } else { + dots = -1; + } + } + return result; + } + function assertPath(path) { + if (typeof path !== "string") { + throw new TypeError("Path must be a string. Received " + JSON.stringify(path)); + } + } + } +}); + +// node_modules/vfile/lib/minproc.browser.js +var require_minproc_browser = __commonJS({ + "node_modules/vfile/lib/minproc.browser.js"(exports) { + "use strict"; + exports.cwd = cwd; + function cwd() { + return "/"; + } + } +}); + +// node_modules/vfile/lib/core.js +var require_core = __commonJS({ + "node_modules/vfile/lib/core.js"(exports, module2) { + "use strict"; + var p = require_minpath_browser(); + var proc = require_minproc_browser(); + var buffer = require_is_buffer(); + module2.exports = VFile; + var own = {}.hasOwnProperty; + var order = ["history", "path", "basename", "stem", "extname", "dirname"]; + VFile.prototype.toString = toString; + Object.defineProperty(VFile.prototype, "path", { get: getPath, set: setPath }); + Object.defineProperty(VFile.prototype, "dirname", { + get: getDirname, + set: setDirname + }); + Object.defineProperty(VFile.prototype, "basename", { + get: getBasename, + set: setBasename + }); + Object.defineProperty(VFile.prototype, "extname", { + get: getExtname, + set: setExtname + }); + Object.defineProperty(VFile.prototype, "stem", { get: getStem, set: setStem }); + function VFile(options) { + var prop; + var index; + if (!options) { + options = {}; + } else if (typeof options === "string" || buffer(options)) { + options = { contents: options }; + } else if ("message" in options && "messages" in options) { + return options; + } + if (!(this instanceof VFile)) { + return new VFile(options); + } + this.data = {}; + this.messages = []; + this.history = []; + this.cwd = proc.cwd(); + index = -1; + while (++index < order.length) { + prop = order[index]; + if (own.call(options, prop)) { + this[prop] = options[prop]; + } + } + for (prop in options) { + if (order.indexOf(prop) < 0) { + this[prop] = options[prop]; + } + } + } + function getPath() { + return this.history[this.history.length - 1]; + } + function setPath(path) { + assertNonEmpty(path, "path"); + if (this.path !== path) { + this.history.push(path); + } + } + function getDirname() { + return typeof this.path === "string" ? p.dirname(this.path) : void 0; + } + function setDirname(dirname) { + assertPath(this.path, "dirname"); + this.path = p.join(dirname || "", this.basename); + } + function getBasename() { + return typeof this.path === "string" ? p.basename(this.path) : void 0; + } + function setBasename(basename) { + assertNonEmpty(basename, "basename"); + assertPart(basename, "basename"); + this.path = p.join(this.dirname || "", basename); + } + function getExtname() { + return typeof this.path === "string" ? p.extname(this.path) : void 0; + } + function setExtname(extname) { + assertPart(extname, "extname"); + assertPath(this.path, "extname"); + if (extname) { + if (extname.charCodeAt(0) !== 46) { + throw new Error("`extname` must start with `.`"); + } + if (extname.indexOf(".", 1) > -1) { + throw new Error("`extname` cannot contain multiple dots"); + } + } + this.path = p.join(this.dirname, this.stem + (extname || "")); + } + function getStem() { + return typeof this.path === "string" ? p.basename(this.path, this.extname) : void 0; + } + function setStem(stem) { + assertNonEmpty(stem, "stem"); + assertPart(stem, "stem"); + this.path = p.join(this.dirname || "", stem + (this.extname || "")); + } + function toString(encoding) { + return (this.contents || "").toString(encoding); + } + function assertPart(part, name) { + if (part && part.indexOf(p.sep) > -1) { + throw new Error("`" + name + "` cannot be a path: did not expect `" + p.sep + "`"); + } + } + function assertNonEmpty(part, name) { + if (!part) { + throw new Error("`" + name + "` cannot be empty"); + } + } + function assertPath(path, name) { + if (!path) { + throw new Error("Setting `" + name + "` requires `path` to be set too"); + } + } + } +}); + +// node_modules/vfile/lib/index.js +var require_lib = __commonJS({ + "node_modules/vfile/lib/index.js"(exports, module2) { + "use strict"; + var VMessage = require_vfile_message(); + var VFile = require_core(); + module2.exports = VFile; + VFile.prototype.message = message; + VFile.prototype.info = info; + VFile.prototype.fail = fail; + function message(reason, position, origin) { + var message2 = new VMessage(reason, position, origin); + if (this.path) { + message2.name = this.path + ":" + message2.name; + message2.file = this.path; + } + message2.fatal = false; + this.messages.push(message2); + return message2; + } + function fail() { + var message2 = this.message.apply(this, arguments); + message2.fatal = true; + throw message2; + } + function info() { + var message2 = this.message.apply(this, arguments); + message2.fatal = null; + return message2; + } + } +}); + +// node_modules/vfile/index.js +var require_vfile = __commonJS({ + "node_modules/vfile/index.js"(exports, module2) { + "use strict"; + module2.exports = require_lib(); + } +}); + +// node_modules/unified/index.js +var require_unified = __commonJS({ + "node_modules/unified/index.js"(exports, module2) { + "use strict"; + var bail = require_bail(); + var buffer = require_is_buffer(); + var extend = require_extend(); + var plain = require_is_plain_obj(); + var trough = require_trough(); + var vfile = require_vfile(); + module2.exports = unified().freeze(); + var slice = [].slice; + var own = {}.hasOwnProperty; + var pipeline = trough().use(pipelineParse).use(pipelineRun).use(pipelineStringify); + function pipelineParse(p, ctx) { + ctx.tree = p.parse(ctx.file); + } + function pipelineRun(p, ctx, next) { + p.run(ctx.tree, ctx.file, done); + function done(error, tree, file) { + if (error) { + next(error); + } else { + ctx.tree = tree; + ctx.file = file; + next(); + } + } + } + function pipelineStringify(p, ctx) { + var result = p.stringify(ctx.tree, ctx.file); + if (result === void 0 || result === null) { + } else if (typeof result === "string" || buffer(result)) { + if ("value" in ctx.file) { + ctx.file.value = result; + } + ctx.file.contents = result; + } else { + ctx.file.result = result; + } + } + function unified() { + var attachers = []; + var transformers = trough(); + var namespace = {}; + var freezeIndex = -1; + var frozen; + processor.data = data; + processor.freeze = freeze; + processor.attachers = attachers; + processor.use = use; + processor.parse = parse3; + processor.stringify = stringify4; + processor.run = run; + processor.runSync = runSync; + processor.process = process2; + processor.processSync = processSync; + return processor; + function processor() { + var destination = unified(); + var index = -1; + while (++index < attachers.length) { + destination.use.apply(null, attachers[index]); + } + destination.data(extend(true, {}, namespace)); + return destination; + } + function freeze() { + var values; + var transformer; + if (frozen) { + return processor; + } + while (++freezeIndex < attachers.length) { + values = attachers[freezeIndex]; + if (values[1] === false) { + continue; + } + if (values[1] === true) { + values[1] = void 0; + } + transformer = values[0].apply(processor, values.slice(1)); + if (typeof transformer === "function") { + transformers.use(transformer); + } + } + frozen = true; + freezeIndex = Infinity; + return processor; + } + function data(key, value) { + if (typeof key === "string") { + if (arguments.length === 2) { + assertUnfrozen("data", frozen); + namespace[key] = value; + return processor; + } + return own.call(namespace, key) && namespace[key] || null; + } + if (key) { + assertUnfrozen("data", frozen); + namespace = key; + return processor; + } + return namespace; + } + function use(value) { + var settings; + assertUnfrozen("use", frozen); + if (value === null || value === void 0) { + } else if (typeof value === "function") { + addPlugin.apply(null, arguments); + } else if (typeof value === "object") { + if ("length" in value) { + addList(value); + } else { + addPreset(value); + } + } else { + throw new Error("Expected usable value, not `" + value + "`"); + } + if (settings) { + namespace.settings = extend(namespace.settings || {}, settings); + } + return processor; + function addPreset(result) { + addList(result.plugins); + if (result.settings) { + settings = extend(settings || {}, result.settings); + } + } + function add(value2) { + if (typeof value2 === "function") { + addPlugin(value2); + } else if (typeof value2 === "object") { + if ("length" in value2) { + addPlugin.apply(null, value2); + } else { + addPreset(value2); + } + } else { + throw new Error("Expected usable value, not `" + value2 + "`"); + } + } + function addList(plugins) { + var index = -1; + if (plugins === null || plugins === void 0) { + } else if (typeof plugins === "object" && "length" in plugins) { + while (++index < plugins.length) { + add(plugins[index]); + } + } else { + throw new Error("Expected a list of plugins, not `" + plugins + "`"); + } + } + function addPlugin(plugin, value2) { + var entry = find(plugin); + if (entry) { + if (plain(entry[1]) && plain(value2)) { + value2 = extend(true, entry[1], value2); + } + entry[1] = value2; + } else { + attachers.push(slice.call(arguments)); + } + } + } + function find(plugin) { + var index = -1; + while (++index < attachers.length) { + if (attachers[index][0] === plugin) { + return attachers[index]; + } + } + } + function parse3(doc) { + var file = vfile(doc); + var Parser2; + freeze(); + Parser2 = processor.Parser; + assertParser("parse", Parser2); + if (newable(Parser2, "parse")) { + return new Parser2(String(file), file).parse(); + } + return Parser2(String(file), file); + } + function run(node, file, cb) { + assertNode(node); + freeze(); + if (!cb && typeof file === "function") { + cb = file; + file = null; + } + if (!cb) { + return new Promise(executor); + } + executor(null, cb); + function executor(resolve, reject) { + transformers.run(node, vfile(file), done); + function done(error, tree, file2) { + tree = tree || node; + if (error) { + reject(error); + } else if (resolve) { + resolve(tree); + } else { + cb(null, tree, file2); + } + } + } + } + function runSync(node, file) { + var result; + var complete; + run(node, file, done); + assertDone("runSync", "run", complete); + return result; + function done(error, tree) { + complete = true; + result = tree; + bail(error); + } + } + function stringify4(node, doc) { + var file = vfile(doc); + var Compiler; + freeze(); + Compiler = processor.Compiler; + assertCompiler("stringify", Compiler); + assertNode(node); + if (newable(Compiler, "compile")) { + return new Compiler(node, file).compile(); + } + return Compiler(node, file); + } + function process2(doc, cb) { + freeze(); + assertParser("process", processor.Parser); + assertCompiler("process", processor.Compiler); + if (!cb) { + return new Promise(executor); + } + executor(null, cb); + function executor(resolve, reject) { + var file = vfile(doc); + pipeline.run(processor, { file }, done); + function done(error) { + if (error) { + reject(error); + } else if (resolve) { + resolve(file); + } else { + cb(null, file); + } + } + } + } + function processSync(doc) { + var file; + var complete; + freeze(); + assertParser("processSync", processor.Parser); + assertCompiler("processSync", processor.Compiler); + file = vfile(doc); + process2(file, done); + assertDone("processSync", "process", complete); + return file; + function done(error) { + complete = true; + bail(error); + } + } + } + function newable(value, name) { + return typeof value === "function" && value.prototype && (keys(value.prototype) || name in value.prototype); + } + function keys(value) { + var key; + for (key in value) { + return true; + } + return false; + } + function assertParser(name, Parser2) { + if (typeof Parser2 !== "function") { + throw new Error("Cannot `" + name + "` without `Parser`"); + } + } + function assertCompiler(name, Compiler) { + if (typeof Compiler !== "function") { + throw new Error("Cannot `" + name + "` without `Compiler`"); + } + } + function assertUnfrozen(name, frozen) { + if (frozen) { + throw new Error("Cannot invoke `" + name + "` on a frozen processor.\nCreate a new processor first, by invoking it: use `processor()` instead of `processor`."); + } + } + function assertNode(node) { + if (!node || typeof node.type !== "string") { + throw new Error("Expected node, got `" + node + "`"); + } + } + function assertDone(name, asyncName, complete) { + if (!complete) { + throw new Error("`" + name + "` finished async. Use `" + asyncName + "` instead"); + } + } + } +}); + +// node_modules/mdast-util-to-string/index.js +var require_mdast_util_to_string = __commonJS({ + "node_modules/mdast-util-to-string/index.js"(exports, module2) { + "use strict"; + module2.exports = toString; + function toString(node) { + return node && (node.value || node.alt || node.title || "children" in node && all(node.children) || "length" in node && all(node)) || ""; + } + function all(values) { + var result = []; + var index = -1; + while (++index < values.length) { + result[index] = toString(values[index]); + } + return result.join(""); + } + } +}); + +// node_modules/micromark/dist/constant/assign.js +var require_assign = __commonJS({ + "node_modules/micromark/dist/constant/assign.js"(exports, module2) { + "use strict"; + var assign = Object.assign; + module2.exports = assign; + } +}); + +// node_modules/micromark/dist/constant/has-own-property.js +var require_has_own_property = __commonJS({ + "node_modules/micromark/dist/constant/has-own-property.js"(exports, module2) { + "use strict"; + var own = {}.hasOwnProperty; + module2.exports = own; + } +}); + +// node_modules/micromark/dist/util/normalize-identifier.js +var require_normalize_identifier = __commonJS({ + "node_modules/micromark/dist/util/normalize-identifier.js"(exports, module2) { + "use strict"; + function normalizeIdentifier(value) { + return value.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase(); + } + module2.exports = normalizeIdentifier; + } +}); + +// node_modules/micromark/dist/constant/from-char-code.js +var require_from_char_code = __commonJS({ + "node_modules/micromark/dist/constant/from-char-code.js"(exports, module2) { + "use strict"; + var fromCharCode = String.fromCharCode; + module2.exports = fromCharCode; + } +}); + +// node_modules/micromark/dist/util/safe-from-int.js +var require_safe_from_int = __commonJS({ + "node_modules/micromark/dist/util/safe-from-int.js"(exports, module2) { + "use strict"; + var fromCharCode = require_from_char_code(); + function safeFromInt(value, base) { + var code = parseInt(value, base); + if (code < 9 || code === 11 || code > 13 && code < 32 || code > 126 && code < 160 || code > 55295 && code < 57344 || code > 64975 && code < 65008 || (code & 65535) === 65535 || (code & 65535) === 65534 || code > 1114111) { + return "\uFFFD"; + } + return fromCharCode(code); + } + module2.exports = safeFromInt; + } +}); + +// node_modules/micromark/dist/character/markdown-line-ending.js +var require_markdown_line_ending = __commonJS({ + "node_modules/micromark/dist/character/markdown-line-ending.js"(exports, module2) { + "use strict"; + function markdownLineEnding(code) { + return code < -2; + } + module2.exports = markdownLineEnding; + } +}); + +// node_modules/micromark/dist/character/markdown-space.js +var require_markdown_space = __commonJS({ + "node_modules/micromark/dist/character/markdown-space.js"(exports, module2) { + "use strict"; + function markdownSpace(code) { + return code === -2 || code === -1 || code === 32; + } + module2.exports = markdownSpace; + } +}); + +// node_modules/micromark/dist/tokenize/factory-space.js +var require_factory_space = __commonJS({ + "node_modules/micromark/dist/tokenize/factory-space.js"(exports, module2) { + "use strict"; + var markdownSpace = require_markdown_space(); + function spaceFactory(effects, ok, type, max) { + var limit = max ? max - 1 : Infinity; + var size = 0; + return start; + function start(code) { + if (markdownSpace(code)) { + effects.enter(type); + return prefix(code); + } + return ok(code); + } + function prefix(code) { + if (markdownSpace(code) && size++ < limit) { + effects.consume(code); + return prefix; + } + effects.exit(type); + return ok(code); + } + } + module2.exports = spaceFactory; + } +}); + +// node_modules/micromark/dist/initialize/content.js +var require_content = __commonJS({ + "node_modules/micromark/dist/initialize/content.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var markdownLineEnding = require_markdown_line_ending(); + var factorySpace = require_factory_space(); + var tokenize = initializeContent; + function initializeContent(effects) { + var contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial); + var previous; + return contentStart; + function afterContentStartConstruct(code) { + if (code === null) { + effects.consume(code); + return; + } + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + return factorySpace(effects, contentStart, "linePrefix"); + } + function paragraphInitial(code) { + effects.enter("paragraph"); + return lineStart(code); + } + function lineStart(code) { + var token = effects.enter("chunkText", { + contentType: "text", + previous + }); + if (previous) { + previous.next = token; + } + previous = token; + return data(code); + } + function data(code) { + if (code === null) { + effects.exit("chunkText"); + effects.exit("paragraph"); + effects.consume(code); + return; + } + if (markdownLineEnding(code)) { + effects.consume(code); + effects.exit("chunkText"); + return lineStart; + } + effects.consume(code); + return data; + } + } + exports.tokenize = tokenize; + } +}); + +// node_modules/micromark/dist/tokenize/partial-blank-line.js +var require_partial_blank_line = __commonJS({ + "node_modules/micromark/dist/tokenize/partial-blank-line.js"(exports, module2) { + "use strict"; + var markdownLineEnding = require_markdown_line_ending(); + var factorySpace = require_factory_space(); + var partialBlankLine = { + tokenize: tokenizePartialBlankLine, + partial: true + }; + function tokenizePartialBlankLine(effects, ok, nok) { + return factorySpace(effects, afterWhitespace, "linePrefix"); + function afterWhitespace(code) { + return code === null || markdownLineEnding(code) ? ok(code) : nok(code); + } + } + module2.exports = partialBlankLine; + } +}); + +// node_modules/micromark/dist/initialize/document.js +var require_document = __commonJS({ + "node_modules/micromark/dist/initialize/document.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var markdownLineEnding = require_markdown_line_ending(); + var factorySpace = require_factory_space(); + var partialBlankLine = require_partial_blank_line(); + var tokenize = initializeDocument; + var containerConstruct = { + tokenize: tokenizeContainer + }; + var lazyFlowConstruct = { + tokenize: tokenizeLazyFlow + }; + function initializeDocument(effects) { + var self = this; + var stack = []; + var continued = 0; + var inspectConstruct = { + tokenize: tokenizeInspect, + partial: true + }; + var inspectResult; + var childFlow; + var childToken; + return start; + function start(code) { + if (continued < stack.length) { + self.containerState = stack[continued][1]; + return effects.attempt(stack[continued][0].continuation, documentContinue, documentContinued)(code); + } + return documentContinued(code); + } + function documentContinue(code) { + continued++; + return start(code); + } + function documentContinued(code) { + if (inspectResult && inspectResult.flowContinue) { + return flowStart(code); + } + self.interrupt = childFlow && childFlow.currentConstruct && childFlow.currentConstruct.interruptible; + self.containerState = {}; + return effects.attempt(containerConstruct, containerContinue, flowStart)(code); + } + function containerContinue(code) { + stack.push([self.currentConstruct, self.containerState]); + self.containerState = void 0; + return documentContinued(code); + } + function flowStart(code) { + if (code === null) { + exitContainers(0, true); + effects.consume(code); + return; + } + childFlow = childFlow || self.parser.flow(self.now()); + effects.enter("chunkFlow", { + contentType: "flow", + previous: childToken, + _tokenizer: childFlow + }); + return flowContinue(code); + } + function flowContinue(code) { + if (code === null) { + continueFlow(effects.exit("chunkFlow")); + return flowStart(code); + } + if (markdownLineEnding(code)) { + effects.consume(code); + continueFlow(effects.exit("chunkFlow")); + return effects.check(inspectConstruct, documentAfterPeek); + } + effects.consume(code); + return flowContinue; + } + function documentAfterPeek(code) { + exitContainers(inspectResult.continued, inspectResult && inspectResult.flowEnd); + continued = 0; + return start(code); + } + function continueFlow(token) { + if (childToken) + childToken.next = token; + childToken = token; + childFlow.lazy = inspectResult && inspectResult.lazy; + childFlow.defineSkip(token.start); + childFlow.write(self.sliceStream(token)); + } + function exitContainers(size, end) { + var index = stack.length; + if (childFlow && end) { + childFlow.write([null]); + childToken = childFlow = void 0; + } + while (index-- > size) { + self.containerState = stack[index][1]; + stack[index][0].exit.call(self, effects); + } + stack.length = size; + } + function tokenizeInspect(effects2, ok) { + var subcontinued = 0; + inspectResult = {}; + return inspectStart; + function inspectStart(code) { + if (subcontinued < stack.length) { + self.containerState = stack[subcontinued][1]; + return effects2.attempt(stack[subcontinued][0].continuation, inspectContinue, inspectLess)(code); + } + if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) { + inspectResult.flowContinue = true; + return inspectDone(code); + } + self.interrupt = childFlow.currentConstruct && childFlow.currentConstruct.interruptible; + self.containerState = {}; + return effects2.attempt(containerConstruct, inspectFlowEnd, inspectDone)(code); + } + function inspectContinue(code) { + subcontinued++; + return self.containerState._closeFlow ? inspectFlowEnd(code) : inspectStart(code); + } + function inspectLess(code) { + if (childFlow.currentConstruct && childFlow.currentConstruct.lazy) { + self.containerState = {}; + return effects2.attempt(containerConstruct, inspectFlowEnd, effects2.attempt(lazyFlowConstruct, inspectFlowEnd, effects2.check(partialBlankLine, inspectFlowEnd, inspectLazy)))(code); + } + return inspectFlowEnd(code); + } + function inspectLazy(code) { + subcontinued = stack.length; + inspectResult.lazy = true; + inspectResult.flowContinue = true; + return inspectDone(code); + } + function inspectFlowEnd(code) { + inspectResult.flowEnd = true; + return inspectDone(code); + } + function inspectDone(code) { + inspectResult.continued = subcontinued; + self.interrupt = self.containerState = void 0; + return ok(code); + } + } + } + function tokenizeContainer(effects, ok, nok) { + return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), "linePrefix", this.parser.constructs.disable.null.indexOf("codeIndented") > -1 ? void 0 : 4); + } + function tokenizeLazyFlow(effects, ok, nok) { + return factorySpace(effects, effects.lazy(this.parser.constructs.flow, ok, nok), "linePrefix", this.parser.constructs.disable.null.indexOf("codeIndented") > -1 ? void 0 : 4); + } + exports.tokenize = tokenize; + } +}); + +// node_modules/micromark/dist/util/size-chunks.js +var require_size_chunks = __commonJS({ + "node_modules/micromark/dist/util/size-chunks.js"(exports, module2) { + "use strict"; + function sizeChunks(chunks) { + var index = -1; + var size = 0; + while (++index < chunks.length) { + size += typeof chunks[index] === "string" ? chunks[index].length : 1; + } + return size; + } + module2.exports = sizeChunks; + } +}); + +// node_modules/micromark/dist/util/prefix-size.js +var require_prefix_size = __commonJS({ + "node_modules/micromark/dist/util/prefix-size.js"(exports, module2) { + "use strict"; + var sizeChunks = require_size_chunks(); + function prefixSize(events, type) { + var tail = events[events.length - 1]; + if (!tail || tail[1].type !== type) + return 0; + return sizeChunks(tail[2].sliceStream(tail[1])); + } + module2.exports = prefixSize; + } +}); + +// node_modules/micromark/dist/constant/splice.js +var require_splice = __commonJS({ + "node_modules/micromark/dist/constant/splice.js"(exports, module2) { + "use strict"; + var splice = [].splice; + module2.exports = splice; + } +}); + +// node_modules/micromark/dist/util/chunked-splice.js +var require_chunked_splice = __commonJS({ + "node_modules/micromark/dist/util/chunked-splice.js"(exports, module2) { + "use strict"; + var splice = require_splice(); + function chunkedSplice(list, start, remove, items) { + var end = list.length; + var chunkStart = 0; + var parameters; + if (start < 0) { + start = -start > end ? 0 : end + start; + } else { + start = start > end ? end : start; + } + remove = remove > 0 ? remove : 0; + if (items.length < 1e4) { + parameters = Array.from(items); + parameters.unshift(start, remove); + splice.apply(list, parameters); + } else { + if (remove) + splice.apply(list, [start, remove]); + while (chunkStart < items.length) { + parameters = items.slice(chunkStart, chunkStart + 1e4); + parameters.unshift(start, 0); + splice.apply(list, parameters); + chunkStart += 1e4; + start += 1e4; + } + } + } + module2.exports = chunkedSplice; + } +}); + +// node_modules/micromark/dist/util/shallow.js +var require_shallow = __commonJS({ + "node_modules/micromark/dist/util/shallow.js"(exports, module2) { + "use strict"; + var assign = require_assign(); + function shallow(object) { + return assign({}, object); + } + module2.exports = shallow; + } +}); + +// node_modules/micromark/dist/util/subtokenize.js +var require_subtokenize = __commonJS({ + "node_modules/micromark/dist/util/subtokenize.js"(exports, module2) { + "use strict"; + var assign = require_assign(); + var chunkedSplice = require_chunked_splice(); + var shallow = require_shallow(); + function subtokenize(events) { + var jumps = {}; + var index = -1; + var event; + var lineIndex; + var otherIndex; + var otherEvent; + var parameters; + var subevents; + var more; + while (++index < events.length) { + while (index in jumps) { + index = jumps[index]; + } + event = events[index]; + if (index && event[1].type === "chunkFlow" && events[index - 1][1].type === "listItemPrefix") { + subevents = event[1]._tokenizer.events; + otherIndex = 0; + if (otherIndex < subevents.length && subevents[otherIndex][1].type === "lineEndingBlank") { + otherIndex += 2; + } + if (otherIndex < subevents.length && subevents[otherIndex][1].type === "content") { + while (++otherIndex < subevents.length) { + if (subevents[otherIndex][1].type === "content") { + break; + } + if (subevents[otherIndex][1].type === "chunkText") { + subevents[otherIndex][1].isInFirstContentOfListItem = true; + otherIndex++; + } + } + } + } + if (event[0] === "enter") { + if (event[1].contentType) { + assign(jumps, subcontent(events, index)); + index = jumps[index]; + more = true; + } + } else if (event[1]._container || event[1]._movePreviousLineEndings) { + otherIndex = index; + lineIndex = void 0; + while (otherIndex--) { + otherEvent = events[otherIndex]; + if (otherEvent[1].type === "lineEnding" || otherEvent[1].type === "lineEndingBlank") { + if (otherEvent[0] === "enter") { + if (lineIndex) { + events[lineIndex][1].type = "lineEndingBlank"; + } + otherEvent[1].type = "lineEnding"; + lineIndex = otherIndex; + } + } else { + break; + } + } + if (lineIndex) { + event[1].end = shallow(events[lineIndex][1].start); + parameters = events.slice(lineIndex, index); + parameters.unshift(event); + chunkedSplice(events, lineIndex, index - lineIndex + 1, parameters); + } + } + } + return !more; + } + function subcontent(events, eventIndex) { + var token = events[eventIndex][1]; + var context = events[eventIndex][2]; + var startPosition = eventIndex - 1; + var startPositions = []; + var tokenizer = token._tokenizer || context.parser[token.contentType](token.start); + var childEvents = tokenizer.events; + var jumps = []; + var gaps = {}; + var stream; + var previous; + var index; + var entered; + var end; + var adjust; + while (token) { + while (events[++startPosition][1] !== token) { + } + startPositions.push(startPosition); + if (!token._tokenizer) { + stream = context.sliceStream(token); + if (!token.next) { + stream.push(null); + } + if (previous) { + tokenizer.defineSkip(token.start); + } + if (token.isInFirstContentOfListItem) { + tokenizer._gfmTasklistFirstContentOfListItem = true; + } + tokenizer.write(stream); + if (token.isInFirstContentOfListItem) { + tokenizer._gfmTasklistFirstContentOfListItem = void 0; + } + } + previous = token; + token = token.next; + } + token = previous; + index = childEvents.length; + while (index--) { + if (childEvents[index][0] === "enter") { + entered = true; + } else if (entered && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) { + add(childEvents.slice(index + 1, end)); + token._tokenizer = token.next = void 0; + token = token.previous; + end = index + 1; + } + } + tokenizer.events = token._tokenizer = token.next = void 0; + add(childEvents.slice(0, end)); + index = -1; + adjust = 0; + while (++index < jumps.length) { + gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]; + adjust += jumps[index][1] - jumps[index][0] - 1; + } + return gaps; + function add(slice) { + var start = startPositions.pop(); + jumps.unshift([start, start + slice.length - 1]); + chunkedSplice(events, start, 2, slice); + } + } + module2.exports = subtokenize; + } +}); + +// node_modules/micromark/dist/tokenize/content.js +var require_content2 = __commonJS({ + "node_modules/micromark/dist/tokenize/content.js"(exports, module2) { + "use strict"; + var markdownLineEnding = require_markdown_line_ending(); + var prefixSize = require_prefix_size(); + var subtokenize = require_subtokenize(); + var factorySpace = require_factory_space(); + var content = { + tokenize: tokenizeContent, + resolve: resolveContent, + interruptible: true, + lazy: true + }; + var continuationConstruct = { + tokenize: tokenizeContinuation, + partial: true + }; + function resolveContent(events) { + subtokenize(events); + return events; + } + function tokenizeContent(effects, ok) { + var previous; + return start; + function start(code) { + effects.enter("content"); + previous = effects.enter("chunkContent", { + contentType: "content" + }); + return data(code); + } + function data(code) { + if (code === null) { + return contentEnd(code); + } + if (markdownLineEnding(code)) { + return effects.check(continuationConstruct, contentContinue, contentEnd)(code); + } + effects.consume(code); + return data; + } + function contentEnd(code) { + effects.exit("chunkContent"); + effects.exit("content"); + return ok(code); + } + function contentContinue(code) { + effects.consume(code); + effects.exit("chunkContent"); + previous = previous.next = effects.enter("chunkContent", { + contentType: "content", + previous + }); + return data; + } + } + function tokenizeContinuation(effects, ok, nok) { + var self = this; + return startLookahead; + function startLookahead(code) { + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + return factorySpace(effects, prefixed, "linePrefix"); + } + function prefixed(code) { + if (code === null || markdownLineEnding(code)) { + return nok(code); + } + if (self.parser.constructs.disable.null.indexOf("codeIndented") > -1 || prefixSize(self.events, "linePrefix") < 4) { + return effects.interrupt(self.parser.constructs.flow, nok, ok)(code); + } + return ok(code); + } + } + module2.exports = content; + } +}); + +// node_modules/micromark/dist/initialize/flow.js +var require_flow = __commonJS({ + "node_modules/micromark/dist/initialize/flow.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var content = require_content2(); + var factorySpace = require_factory_space(); + var partialBlankLine = require_partial_blank_line(); + var tokenize = initializeFlow; + function initializeFlow(effects) { + var self = this; + var initial = effects.attempt(partialBlankLine, atBlankEnding, effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), "linePrefix"))); + return initial; + function atBlankEnding(code) { + if (code === null) { + effects.consume(code); + return; + } + effects.enter("lineEndingBlank"); + effects.consume(code); + effects.exit("lineEndingBlank"); + self.currentConstruct = void 0; + return initial; + } + function afterConstruct(code) { + if (code === null) { + effects.consume(code); + return; + } + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + self.currentConstruct = void 0; + return initial; + } + } + exports.tokenize = tokenize; + } +}); + +// node_modules/micromark/dist/initialize/text.js +var require_text = __commonJS({ + "node_modules/micromark/dist/initialize/text.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var assign = require_assign(); + var shallow = require_shallow(); + var text = initializeFactory("text"); + var string2 = initializeFactory("string"); + var resolver = { + resolveAll: createResolver() + }; + function initializeFactory(field) { + return { + tokenize: initializeText, + resolveAll: createResolver(field === "text" ? resolveAllLineSuffixes : void 0) + }; + function initializeText(effects) { + var self = this; + var constructs = this.parser.constructs[field]; + var text2 = effects.attempt(constructs, start, notText); + return start; + function start(code) { + return atBreak(code) ? text2(code) : notText(code); + } + function notText(code) { + if (code === null) { + effects.consume(code); + return; + } + effects.enter("data"); + effects.consume(code); + return data; + } + function data(code) { + if (atBreak(code)) { + effects.exit("data"); + return text2(code); + } + effects.consume(code); + return data; + } + function atBreak(code) { + var list = constructs[code]; + var index = -1; + if (code === null) { + return true; + } + if (list) { + while (++index < list.length) { + if (!list[index].previous || list[index].previous.call(self, self.previous)) { + return true; + } + } + } + } + } + } + function createResolver(extraResolver) { + return resolveAllText; + function resolveAllText(events, context) { + var index = -1; + var enter; + while (++index <= events.length) { + if (enter === void 0) { + if (events[index] && events[index][1].type === "data") { + enter = index; + index++; + } + } else if (!events[index] || events[index][1].type !== "data") { + if (index !== enter + 2) { + events[enter][1].end = events[index - 1][1].end; + events.splice(enter + 2, index - enter - 2); + index = enter + 2; + } + enter = void 0; + } + } + return extraResolver ? extraResolver(events, context) : events; + } + } + function resolveAllLineSuffixes(events, context) { + var eventIndex = -1; + var chunks; + var data; + var chunk; + var index; + var bufferIndex; + var size; + var tabs; + var token; + while (++eventIndex <= events.length) { + if ((eventIndex === events.length || events[eventIndex][1].type === "lineEnding") && events[eventIndex - 1][1].type === "data") { + data = events[eventIndex - 1][1]; + chunks = context.sliceStream(data); + index = chunks.length; + bufferIndex = -1; + size = 0; + tabs = void 0; + while (index--) { + chunk = chunks[index]; + if (typeof chunk === "string") { + bufferIndex = chunk.length; + while (chunk.charCodeAt(bufferIndex - 1) === 32) { + size++; + bufferIndex--; + } + if (bufferIndex) + break; + bufferIndex = -1; + } else if (chunk === -2) { + tabs = true; + size++; + } else if (chunk === -1) + ; + else { + index++; + break; + } + } + if (size) { + token = { + type: eventIndex === events.length || tabs || size < 2 ? "lineSuffix" : "hardBreakTrailing", + start: { + line: data.end.line, + column: data.end.column - size, + offset: data.end.offset - size, + _index: data.start._index + index, + _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex + }, + end: shallow(data.end) + }; + data.end = shallow(token.start); + if (data.start.offset === data.end.offset) { + assign(data, token); + } else { + events.splice(eventIndex, 0, ["enter", token, context], ["exit", token, context]); + eventIndex += 2; + } + } + eventIndex++; + } + } + return events; + } + exports.resolver = resolver; + exports.string = string2; + exports.text = text; + } +}); + +// node_modules/micromark/dist/util/miniflat.js +var require_miniflat = __commonJS({ + "node_modules/micromark/dist/util/miniflat.js"(exports, module2) { + "use strict"; + function miniflat(value) { + return value === null || value === void 0 ? [] : "length" in value ? value : [value]; + } + module2.exports = miniflat; + } +}); + +// node_modules/micromark/dist/util/combine-extensions.js +var require_combine_extensions = __commonJS({ + "node_modules/micromark/dist/util/combine-extensions.js"(exports, module2) { + "use strict"; + var hasOwnProperty = require_has_own_property(); + var chunkedSplice = require_chunked_splice(); + var miniflat = require_miniflat(); + function combineExtensions(extensions) { + var all = {}; + var index = -1; + while (++index < extensions.length) { + extension(all, extensions[index]); + } + return all; + } + function extension(all, extension2) { + var hook; + var left; + var right; + var code; + for (hook in extension2) { + left = hasOwnProperty.call(all, hook) ? all[hook] : all[hook] = {}; + right = extension2[hook]; + for (code in right) { + left[code] = constructs(miniflat(right[code]), hasOwnProperty.call(left, code) ? left[code] : []); + } + } + } + function constructs(list, existing) { + var index = -1; + var before = []; + while (++index < list.length) { + ; + (list[index].add === "after" ? existing : before).push(list[index]); + } + chunkedSplice(existing, 0, 0, before); + return existing; + } + module2.exports = combineExtensions; + } +}); + +// node_modules/micromark/dist/util/chunked-push.js +var require_chunked_push = __commonJS({ + "node_modules/micromark/dist/util/chunked-push.js"(exports, module2) { + "use strict"; + var chunkedSplice = require_chunked_splice(); + function chunkedPush(list, items) { + if (list.length) { + chunkedSplice(list, list.length, 0, items); + return list; + } + return items; + } + module2.exports = chunkedPush; + } +}); + +// node_modules/micromark/dist/util/resolve-all.js +var require_resolve_all = __commonJS({ + "node_modules/micromark/dist/util/resolve-all.js"(exports, module2) { + "use strict"; + function resolveAll(constructs, events, context) { + var called = []; + var index = -1; + var resolve; + while (++index < constructs.length) { + resolve = constructs[index].resolveAll; + if (resolve && called.indexOf(resolve) < 0) { + events = resolve(events, context); + called.push(resolve); + } + } + return events; + } + module2.exports = resolveAll; + } +}); + +// node_modules/micromark/dist/util/serialize-chunks.js +var require_serialize_chunks = __commonJS({ + "node_modules/micromark/dist/util/serialize-chunks.js"(exports, module2) { + "use strict"; + var fromCharCode = require_from_char_code(); + function serializeChunks(chunks) { + var index = -1; + var result = []; + var chunk; + var value; + var atTab; + while (++index < chunks.length) { + chunk = chunks[index]; + if (typeof chunk === "string") { + value = chunk; + } else if (chunk === -5) { + value = "\r"; + } else if (chunk === -4) { + value = "\n"; + } else if (chunk === -3) { + value = "\r\n"; + } else if (chunk === -2) { + value = " "; + } else if (chunk === -1) { + if (atTab) + continue; + value = " "; + } else { + value = fromCharCode(chunk); + } + atTab = chunk === -2; + result.push(value); + } + return result.join(""); + } + module2.exports = serializeChunks; + } +}); + +// node_modules/micromark/dist/util/slice-chunks.js +var require_slice_chunks = __commonJS({ + "node_modules/micromark/dist/util/slice-chunks.js"(exports, module2) { + "use strict"; + function sliceChunks(chunks, token) { + var startIndex = token.start._index; + var startBufferIndex = token.start._bufferIndex; + var endIndex = token.end._index; + var endBufferIndex = token.end._bufferIndex; + var view; + if (startIndex === endIndex) { + view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]; + } else { + view = chunks.slice(startIndex, endIndex); + if (startBufferIndex > -1) { + view[0] = view[0].slice(startBufferIndex); + } + if (endBufferIndex > 0) { + view.push(chunks[endIndex].slice(0, endBufferIndex)); + } + } + return view; + } + module2.exports = sliceChunks; + } +}); + +// node_modules/micromark/dist/util/create-tokenizer.js +var require_create_tokenizer = __commonJS({ + "node_modules/micromark/dist/util/create-tokenizer.js"(exports, module2) { + "use strict"; + var assign = require_assign(); + var markdownLineEnding = require_markdown_line_ending(); + var chunkedPush = require_chunked_push(); + var chunkedSplice = require_chunked_splice(); + var miniflat = require_miniflat(); + var resolveAll = require_resolve_all(); + var serializeChunks = require_serialize_chunks(); + var shallow = require_shallow(); + var sliceChunks = require_slice_chunks(); + function createTokenizer(parser, initialize, from) { + var point = from ? shallow(from) : { + line: 1, + column: 1, + offset: 0 + }; + var columnStart = {}; + var resolveAllConstructs = []; + var chunks = []; + var stack = []; + var effects = { + consume, + enter, + exit, + attempt: constructFactory(onsuccessfulconstruct), + check: constructFactory(onsuccessfulcheck), + interrupt: constructFactory(onsuccessfulcheck, { + interrupt: true + }), + lazy: constructFactory(onsuccessfulcheck, { + lazy: true + }) + }; + var context = { + previous: null, + events: [], + parser, + sliceStream, + sliceSerialize, + now, + defineSkip: skip, + write + }; + var state = initialize.tokenize.call(context, effects); + if (initialize.resolveAll) { + resolveAllConstructs.push(initialize); + } + point._index = 0; + point._bufferIndex = -1; + return context; + function write(slice) { + chunks = chunkedPush(chunks, slice); + main(); + if (chunks[chunks.length - 1] !== null) { + return []; + } + addResult(initialize, 0); + context.events = resolveAll(resolveAllConstructs, context.events, context); + return context.events; + } + function sliceSerialize(token) { + return serializeChunks(sliceStream(token)); + } + function sliceStream(token) { + return sliceChunks(chunks, token); + } + function now() { + return shallow(point); + } + function skip(value) { + columnStart[value.line] = value.column; + accountForPotentialSkip(); + } + function main() { + var chunkIndex; + var chunk; + while (point._index < chunks.length) { + chunk = chunks[point._index]; + if (typeof chunk === "string") { + chunkIndex = point._index; + if (point._bufferIndex < 0) { + point._bufferIndex = 0; + } + while (point._index === chunkIndex && point._bufferIndex < chunk.length) { + go(chunk.charCodeAt(point._bufferIndex)); + } + } else { + go(chunk); + } + } + } + function go(code) { + state = state(code); + } + function consume(code) { + if (markdownLineEnding(code)) { + point.line++; + point.column = 1; + point.offset += code === -3 ? 2 : 1; + accountForPotentialSkip(); + } else if (code !== -1) { + point.column++; + point.offset++; + } + if (point._bufferIndex < 0) { + point._index++; + } else { + point._bufferIndex++; + if (point._bufferIndex === chunks[point._index].length) { + point._bufferIndex = -1; + point._index++; + } + } + context.previous = code; + } + function enter(type, fields) { + var token = fields || {}; + token.type = type; + token.start = now(); + context.events.push(["enter", token, context]); + stack.push(token); + return token; + } + function exit(type) { + var token = stack.pop(); + token.end = now(); + context.events.push(["exit", token, context]); + return token; + } + function onsuccessfulconstruct(construct, info) { + addResult(construct, info.from); + } + function onsuccessfulcheck(construct, info) { + info.restore(); + } + function constructFactory(onreturn, fields) { + return hook; + function hook(constructs, returnState, bogusState) { + var listOfConstructs; + var constructIndex; + var currentConstruct; + var info; + return constructs.tokenize || "length" in constructs ? handleListOfConstructs(miniflat(constructs)) : handleMapOfConstructs; + function handleMapOfConstructs(code) { + if (code in constructs || null in constructs) { + return handleListOfConstructs(constructs.null ? miniflat(constructs[code]).concat(miniflat(constructs.null)) : constructs[code])(code); + } + return bogusState(code); + } + function handleListOfConstructs(list) { + listOfConstructs = list; + constructIndex = 0; + return handleConstruct(list[constructIndex]); + } + function handleConstruct(construct) { + return start; + function start(code) { + info = store(); + currentConstruct = construct; + if (!construct.partial) { + context.currentConstruct = construct; + } + if (construct.name && context.parser.constructs.disable.null.indexOf(construct.name) > -1) { + return nok(); + } + return construct.tokenize.call(fields ? assign({}, context, fields) : context, effects, ok, nok)(code); + } + } + function ok(code) { + onreturn(currentConstruct, info); + return returnState; + } + function nok(code) { + info.restore(); + if (++constructIndex < listOfConstructs.length) { + return handleConstruct(listOfConstructs[constructIndex]); + } + return bogusState; + } + } + } + function addResult(construct, from2) { + if (construct.resolveAll && resolveAllConstructs.indexOf(construct) < 0) { + resolveAllConstructs.push(construct); + } + if (construct.resolve) { + chunkedSplice(context.events, from2, context.events.length - from2, construct.resolve(context.events.slice(from2), context)); + } + if (construct.resolveTo) { + context.events = construct.resolveTo(context.events, context); + } + } + function store() { + var startPoint = now(); + var startPrevious = context.previous; + var startCurrentConstruct = context.currentConstruct; + var startEventsIndex = context.events.length; + var startStack = Array.from(stack); + return { + restore, + from: startEventsIndex + }; + function restore() { + point = startPoint; + context.previous = startPrevious; + context.currentConstruct = startCurrentConstruct; + context.events.length = startEventsIndex; + stack = startStack; + accountForPotentialSkip(); + } + } + function accountForPotentialSkip() { + if (point.line in columnStart && point.column < 2) { + point.column = columnStart[point.line]; + point.offset += columnStart[point.line] - 1; + } + } + } + module2.exports = createTokenizer; + } +}); + +// node_modules/micromark/dist/character/markdown-line-ending-or-space.js +var require_markdown_line_ending_or_space = __commonJS({ + "node_modules/micromark/dist/character/markdown-line-ending-or-space.js"(exports, module2) { + "use strict"; + function markdownLineEndingOrSpace(code) { + return code < 0 || code === 32; + } + module2.exports = markdownLineEndingOrSpace; + } +}); + +// node_modules/micromark/dist/constant/unicode-punctuation-regex.js +var require_unicode_punctuation_regex = __commonJS({ + "node_modules/micromark/dist/constant/unicode-punctuation-regex.js"(exports, module2) { + "use strict"; + var unicodePunctuation = /[!-\/:-@\[-`\{-~\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]/; + module2.exports = unicodePunctuation; + } +}); + +// node_modules/micromark/dist/util/regex-check.js +var require_regex_check = __commonJS({ + "node_modules/micromark/dist/util/regex-check.js"(exports, module2) { + "use strict"; + var fromCharCode = require_from_char_code(); + function regexCheck(regex) { + return check; + function check(code) { + return regex.test(fromCharCode(code)); + } + } + module2.exports = regexCheck; + } +}); + +// node_modules/micromark/dist/character/unicode-punctuation.js +var require_unicode_punctuation = __commonJS({ + "node_modules/micromark/dist/character/unicode-punctuation.js"(exports, module2) { + "use strict"; + var unicodePunctuationRegex = require_unicode_punctuation_regex(); + var regexCheck = require_regex_check(); + var unicodePunctuation = regexCheck(unicodePunctuationRegex); + module2.exports = unicodePunctuation; + } +}); + +// node_modules/micromark/dist/character/unicode-whitespace.js +var require_unicode_whitespace = __commonJS({ + "node_modules/micromark/dist/character/unicode-whitespace.js"(exports, module2) { + "use strict"; + var regexCheck = require_regex_check(); + var unicodeWhitespace = regexCheck(/\s/); + module2.exports = unicodeWhitespace; + } +}); + +// node_modules/micromark/dist/util/classify-character.js +var require_classify_character = __commonJS({ + "node_modules/micromark/dist/util/classify-character.js"(exports, module2) { + "use strict"; + var markdownLineEndingOrSpace = require_markdown_line_ending_or_space(); + var unicodePunctuation = require_unicode_punctuation(); + var unicodeWhitespace = require_unicode_whitespace(); + function classifyCharacter(code) { + if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) { + return 1; + } + if (unicodePunctuation(code)) { + return 2; + } + } + module2.exports = classifyCharacter; + } +}); + +// node_modules/micromark/dist/util/move-point.js +var require_move_point = __commonJS({ + "node_modules/micromark/dist/util/move-point.js"(exports, module2) { + "use strict"; + function movePoint(point, offset) { + point.column += offset; + point.offset += offset; + point._bufferIndex += offset; + return point; + } + module2.exports = movePoint; + } +}); + +// node_modules/micromark/dist/tokenize/attention.js +var require_attention = __commonJS({ + "node_modules/micromark/dist/tokenize/attention.js"(exports, module2) { + "use strict"; + var chunkedPush = require_chunked_push(); + var chunkedSplice = require_chunked_splice(); + var classifyCharacter = require_classify_character(); + var movePoint = require_move_point(); + var resolveAll = require_resolve_all(); + var shallow = require_shallow(); + var attention = { + name: "attention", + tokenize: tokenizeAttention, + resolveAll: resolveAllAttention + }; + function resolveAllAttention(events, context) { + var index = -1; + var open; + var group; + var text; + var openingSequence; + var closingSequence; + var use; + var nextEvents; + var offset; + while (++index < events.length) { + if (events[index][0] === "enter" && events[index][1].type === "attentionSequence" && events[index][1]._close) { + open = index; + while (open--) { + if (events[open][0] === "exit" && events[open][1].type === "attentionSequence" && events[open][1]._open && context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) { + if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) { + continue; + } + use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1; + openingSequence = { + type: use > 1 ? "strongSequence" : "emphasisSequence", + start: movePoint(shallow(events[open][1].end), -use), + end: shallow(events[open][1].end) + }; + closingSequence = { + type: use > 1 ? "strongSequence" : "emphasisSequence", + start: shallow(events[index][1].start), + end: movePoint(shallow(events[index][1].start), use) + }; + text = { + type: use > 1 ? "strongText" : "emphasisText", + start: shallow(events[open][1].end), + end: shallow(events[index][1].start) + }; + group = { + type: use > 1 ? "strong" : "emphasis", + start: shallow(openingSequence.start), + end: shallow(closingSequence.end) + }; + events[open][1].end = shallow(openingSequence.start); + events[index][1].start = shallow(closingSequence.end); + nextEvents = []; + if (events[open][1].end.offset - events[open][1].start.offset) { + nextEvents = chunkedPush(nextEvents, [ + ["enter", events[open][1], context], + ["exit", events[open][1], context] + ]); + } + nextEvents = chunkedPush(nextEvents, [ + ["enter", group, context], + ["enter", openingSequence, context], + ["exit", openingSequence, context], + ["enter", text, context] + ]); + nextEvents = chunkedPush(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context)); + nextEvents = chunkedPush(nextEvents, [ + ["exit", text, context], + ["enter", closingSequence, context], + ["exit", closingSequence, context], + ["exit", group, context] + ]); + if (events[index][1].end.offset - events[index][1].start.offset) { + offset = 2; + nextEvents = chunkedPush(nextEvents, [ + ["enter", events[index][1], context], + ["exit", events[index][1], context] + ]); + } else { + offset = 0; + } + chunkedSplice(events, open - 1, index - open + 3, nextEvents); + index = open + nextEvents.length - offset - 2; + break; + } + } + } + } + index = -1; + while (++index < events.length) { + if (events[index][1].type === "attentionSequence") { + events[index][1].type = "data"; + } + } + return events; + } + function tokenizeAttention(effects, ok) { + var before = classifyCharacter(this.previous); + var marker; + return start; + function start(code) { + effects.enter("attentionSequence"); + marker = code; + return sequence(code); + } + function sequence(code) { + var token; + var after; + var open; + var close; + if (code === marker) { + effects.consume(code); + return sequence; + } + token = effects.exit("attentionSequence"); + after = classifyCharacter(code); + open = !after || after === 2 && before; + close = !before || before === 2 && after; + token._open = marker === 42 ? open : open && (before || !close); + token._close = marker === 42 ? close : close && (after || !open); + return ok(code); + } + } + module2.exports = attention; + } +}); + +// node_modules/micromark/dist/character/ascii-alpha.js +var require_ascii_alpha = __commonJS({ + "node_modules/micromark/dist/character/ascii-alpha.js"(exports, module2) { + "use strict"; + var regexCheck = require_regex_check(); + var asciiAlpha = regexCheck(/[A-Za-z]/); + module2.exports = asciiAlpha; + } +}); + +// node_modules/micromark/dist/character/ascii-alphanumeric.js +var require_ascii_alphanumeric = __commonJS({ + "node_modules/micromark/dist/character/ascii-alphanumeric.js"(exports, module2) { + "use strict"; + var regexCheck = require_regex_check(); + var asciiAlphanumeric = regexCheck(/[\dA-Za-z]/); + module2.exports = asciiAlphanumeric; + } +}); + +// node_modules/micromark/dist/character/ascii-atext.js +var require_ascii_atext = __commonJS({ + "node_modules/micromark/dist/character/ascii-atext.js"(exports, module2) { + "use strict"; + var regexCheck = require_regex_check(); + var asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/); + module2.exports = asciiAtext; + } +}); + +// node_modules/micromark/dist/character/ascii-control.js +var require_ascii_control = __commonJS({ + "node_modules/micromark/dist/character/ascii-control.js"(exports, module2) { + "use strict"; + function asciiControl(code) { + return code < 32 || code === 127; + } + module2.exports = asciiControl; + } +}); + +// node_modules/micromark/dist/tokenize/autolink.js +var require_autolink = __commonJS({ + "node_modules/micromark/dist/tokenize/autolink.js"(exports, module2) { + "use strict"; + var asciiAlpha = require_ascii_alpha(); + var asciiAlphanumeric = require_ascii_alphanumeric(); + var asciiAtext = require_ascii_atext(); + var asciiControl = require_ascii_control(); + var autolink = { + name: "autolink", + tokenize: tokenizeAutolink + }; + function tokenizeAutolink(effects, ok, nok) { + var size = 1; + return start; + function start(code) { + effects.enter("autolink"); + effects.enter("autolinkMarker"); + effects.consume(code); + effects.exit("autolinkMarker"); + effects.enter("autolinkProtocol"); + return open; + } + function open(code) { + if (asciiAlpha(code)) { + effects.consume(code); + return schemeOrEmailAtext; + } + return asciiAtext(code) ? emailAtext(code) : nok(code); + } + function schemeOrEmailAtext(code) { + return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code) ? schemeInsideOrEmailAtext(code) : emailAtext(code); + } + function schemeInsideOrEmailAtext(code) { + if (code === 58) { + effects.consume(code); + return urlInside; + } + if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) { + effects.consume(code); + return schemeInsideOrEmailAtext; + } + return emailAtext(code); + } + function urlInside(code) { + if (code === 62) { + effects.exit("autolinkProtocol"); + return end(code); + } + if (code === 32 || code === 60 || asciiControl(code)) { + return nok(code); + } + effects.consume(code); + return urlInside; + } + function emailAtext(code) { + if (code === 64) { + effects.consume(code); + size = 0; + return emailAtSignOrDot; + } + if (asciiAtext(code)) { + effects.consume(code); + return emailAtext; + } + return nok(code); + } + function emailAtSignOrDot(code) { + return asciiAlphanumeric(code) ? emailLabel(code) : nok(code); + } + function emailLabel(code) { + if (code === 46) { + effects.consume(code); + size = 0; + return emailAtSignOrDot; + } + if (code === 62) { + effects.exit("autolinkProtocol").type = "autolinkEmail"; + return end(code); + } + return emailValue(code); + } + function emailValue(code) { + if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) { + effects.consume(code); + return code === 45 ? emailValue : emailLabel; + } + return nok(code); + } + function end(code) { + effects.enter("autolinkMarker"); + effects.consume(code); + effects.exit("autolinkMarker"); + effects.exit("autolink"); + return ok; + } + } + module2.exports = autolink; + } +}); + +// node_modules/micromark/dist/tokenize/block-quote.js +var require_block_quote = __commonJS({ + "node_modules/micromark/dist/tokenize/block-quote.js"(exports, module2) { + "use strict"; + var markdownSpace = require_markdown_space(); + var factorySpace = require_factory_space(); + var blockQuote = { + name: "blockQuote", + tokenize: tokenizeBlockQuoteStart, + continuation: { + tokenize: tokenizeBlockQuoteContinuation + }, + exit + }; + function tokenizeBlockQuoteStart(effects, ok, nok) { + var self = this; + return start; + function start(code) { + if (code === 62) { + if (!self.containerState.open) { + effects.enter("blockQuote", { + _container: true + }); + self.containerState.open = true; + } + effects.enter("blockQuotePrefix"); + effects.enter("blockQuoteMarker"); + effects.consume(code); + effects.exit("blockQuoteMarker"); + return after; + } + return nok(code); + } + function after(code) { + if (markdownSpace(code)) { + effects.enter("blockQuotePrefixWhitespace"); + effects.consume(code); + effects.exit("blockQuotePrefixWhitespace"); + effects.exit("blockQuotePrefix"); + return ok; + } + effects.exit("blockQuotePrefix"); + return ok(code); + } + } + function tokenizeBlockQuoteContinuation(effects, ok, nok) { + return factorySpace(effects, effects.attempt(blockQuote, ok, nok), "linePrefix", this.parser.constructs.disable.null.indexOf("codeIndented") > -1 ? void 0 : 4); + } + function exit(effects) { + effects.exit("blockQuote"); + } + module2.exports = blockQuote; + } +}); + +// node_modules/micromark/dist/character/ascii-punctuation.js +var require_ascii_punctuation = __commonJS({ + "node_modules/micromark/dist/character/ascii-punctuation.js"(exports, module2) { + "use strict"; + var regexCheck = require_regex_check(); + var asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/); + module2.exports = asciiPunctuation; + } +}); + +// node_modules/micromark/dist/tokenize/character-escape.js +var require_character_escape = __commonJS({ + "node_modules/micromark/dist/tokenize/character-escape.js"(exports, module2) { + "use strict"; + var asciiPunctuation = require_ascii_punctuation(); + var characterEscape = { + name: "characterEscape", + tokenize: tokenizeCharacterEscape + }; + function tokenizeCharacterEscape(effects, ok, nok) { + return start; + function start(code) { + effects.enter("characterEscape"); + effects.enter("escapeMarker"); + effects.consume(code); + effects.exit("escapeMarker"); + return open; + } + function open(code) { + if (asciiPunctuation(code)) { + effects.enter("characterEscapeValue"); + effects.consume(code); + effects.exit("characterEscapeValue"); + effects.exit("characterEscape"); + return ok; + } + return nok(code); + } + } + module2.exports = characterEscape; + } +}); + +// node_modules/parse-entities/decode-entity.browser.js +var require_decode_entity_browser = __commonJS({ + "node_modules/parse-entities/decode-entity.browser.js"(exports, module2) { + "use strict"; + var el; + var semicolon = 59; + module2.exports = decodeEntity; + function decodeEntity(characters) { + var entity = "&" + characters + ";"; + var char; + el = el || document.createElement("i"); + el.innerHTML = entity; + char = el.textContent; + if (char.charCodeAt(char.length - 1) === semicolon && characters !== "semi") { + return false; + } + return char === entity ? false : char; + } + } +}); + +// node_modules/micromark/dist/character/ascii-digit.js +var require_ascii_digit = __commonJS({ + "node_modules/micromark/dist/character/ascii-digit.js"(exports, module2) { + "use strict"; + var regexCheck = require_regex_check(); + var asciiDigit = regexCheck(/\d/); + module2.exports = asciiDigit; + } +}); + +// node_modules/micromark/dist/character/ascii-hex-digit.js +var require_ascii_hex_digit = __commonJS({ + "node_modules/micromark/dist/character/ascii-hex-digit.js"(exports, module2) { + "use strict"; + var regexCheck = require_regex_check(); + var asciiHexDigit = regexCheck(/[\dA-Fa-f]/); + module2.exports = asciiHexDigit; + } +}); + +// node_modules/micromark/dist/tokenize/character-reference.js +var require_character_reference = __commonJS({ + "node_modules/micromark/dist/tokenize/character-reference.js"(exports, module2) { + "use strict"; + var decodeEntity = require_decode_entity_browser(); + var asciiAlphanumeric = require_ascii_alphanumeric(); + var asciiDigit = require_ascii_digit(); + var asciiHexDigit = require_ascii_hex_digit(); + function _interopDefaultLegacy(e) { + return e && typeof e === "object" && "default" in e ? e : { default: e }; + } + var decodeEntity__default = /* @__PURE__ */ _interopDefaultLegacy(decodeEntity); + var characterReference = { + name: "characterReference", + tokenize: tokenizeCharacterReference + }; + function tokenizeCharacterReference(effects, ok, nok) { + var self = this; + var size = 0; + var max; + var test; + return start; + function start(code) { + effects.enter("characterReference"); + effects.enter("characterReferenceMarker"); + effects.consume(code); + effects.exit("characterReferenceMarker"); + return open; + } + function open(code) { + if (code === 35) { + effects.enter("characterReferenceMarkerNumeric"); + effects.consume(code); + effects.exit("characterReferenceMarkerNumeric"); + return numeric; + } + effects.enter("characterReferenceValue"); + max = 31; + test = asciiAlphanumeric; + return value(code); + } + function numeric(code) { + if (code === 88 || code === 120) { + effects.enter("characterReferenceMarkerHexadecimal"); + effects.consume(code); + effects.exit("characterReferenceMarkerHexadecimal"); + effects.enter("characterReferenceValue"); + max = 6; + test = asciiHexDigit; + return value; + } + effects.enter("characterReferenceValue"); + max = 7; + test = asciiDigit; + return value(code); + } + function value(code) { + var token; + if (code === 59 && size) { + token = effects.exit("characterReferenceValue"); + if (test === asciiAlphanumeric && !decodeEntity__default["default"](self.sliceSerialize(token))) { + return nok(code); + } + effects.enter("characterReferenceMarker"); + effects.consume(code); + effects.exit("characterReferenceMarker"); + effects.exit("characterReference"); + return ok; + } + if (test(code) && size++ < max) { + effects.consume(code); + return value; + } + return nok(code); + } + } + module2.exports = characterReference; + } +}); + +// node_modules/micromark/dist/tokenize/code-fenced.js +var require_code_fenced = __commonJS({ + "node_modules/micromark/dist/tokenize/code-fenced.js"(exports, module2) { + "use strict"; + var markdownLineEnding = require_markdown_line_ending(); + var markdownLineEndingOrSpace = require_markdown_line_ending_or_space(); + var prefixSize = require_prefix_size(); + var factorySpace = require_factory_space(); + var codeFenced = { + name: "codeFenced", + tokenize: tokenizeCodeFenced, + concrete: true + }; + function tokenizeCodeFenced(effects, ok, nok) { + var self = this; + var closingFenceConstruct = { + tokenize: tokenizeClosingFence, + partial: true + }; + var initialPrefix = prefixSize(this.events, "linePrefix"); + var sizeOpen = 0; + var marker; + return start; + function start(code) { + effects.enter("codeFenced"); + effects.enter("codeFencedFence"); + effects.enter("codeFencedFenceSequence"); + marker = code; + return sequenceOpen(code); + } + function sequenceOpen(code) { + if (code === marker) { + effects.consume(code); + sizeOpen++; + return sequenceOpen; + } + effects.exit("codeFencedFenceSequence"); + return sizeOpen < 3 ? nok(code) : factorySpace(effects, infoOpen, "whitespace")(code); + } + function infoOpen(code) { + if (code === null || markdownLineEnding(code)) { + return openAfter(code); + } + effects.enter("codeFencedFenceInfo"); + effects.enter("chunkString", { + contentType: "string" + }); + return info(code); + } + function info(code) { + if (code === null || markdownLineEndingOrSpace(code)) { + effects.exit("chunkString"); + effects.exit("codeFencedFenceInfo"); + return factorySpace(effects, infoAfter, "whitespace")(code); + } + if (code === 96 && code === marker) + return nok(code); + effects.consume(code); + return info; + } + function infoAfter(code) { + if (code === null || markdownLineEnding(code)) { + return openAfter(code); + } + effects.enter("codeFencedFenceMeta"); + effects.enter("chunkString", { + contentType: "string" + }); + return meta(code); + } + function meta(code) { + if (code === null || markdownLineEnding(code)) { + effects.exit("chunkString"); + effects.exit("codeFencedFenceMeta"); + return openAfter(code); + } + if (code === 96 && code === marker) + return nok(code); + effects.consume(code); + return meta; + } + function openAfter(code) { + effects.exit("codeFencedFence"); + return self.interrupt ? ok(code) : content(code); + } + function content(code) { + if (code === null) { + return after(code); + } + if (markdownLineEnding(code)) { + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + return effects.attempt(closingFenceConstruct, after, initialPrefix ? factorySpace(effects, content, "linePrefix", initialPrefix + 1) : content); + } + effects.enter("codeFlowValue"); + return contentContinue(code); + } + function contentContinue(code) { + if (code === null || markdownLineEnding(code)) { + effects.exit("codeFlowValue"); + return content(code); + } + effects.consume(code); + return contentContinue; + } + function after(code) { + effects.exit("codeFenced"); + return ok(code); + } + function tokenizeClosingFence(effects2, ok2, nok2) { + var size = 0; + return factorySpace(effects2, closingSequenceStart, "linePrefix", this.parser.constructs.disable.null.indexOf("codeIndented") > -1 ? void 0 : 4); + function closingSequenceStart(code) { + effects2.enter("codeFencedFence"); + effects2.enter("codeFencedFenceSequence"); + return closingSequence(code); + } + function closingSequence(code) { + if (code === marker) { + effects2.consume(code); + size++; + return closingSequence; + } + if (size < sizeOpen) + return nok2(code); + effects2.exit("codeFencedFenceSequence"); + return factorySpace(effects2, closingSequenceEnd, "whitespace")(code); + } + function closingSequenceEnd(code) { + if (code === null || markdownLineEnding(code)) { + effects2.exit("codeFencedFence"); + return ok2(code); + } + return nok2(code); + } + } + } + module2.exports = codeFenced; + } +}); + +// node_modules/micromark/dist/tokenize/code-indented.js +var require_code_indented = __commonJS({ + "node_modules/micromark/dist/tokenize/code-indented.js"(exports, module2) { + "use strict"; + var markdownLineEnding = require_markdown_line_ending(); + var chunkedSplice = require_chunked_splice(); + var prefixSize = require_prefix_size(); + var factorySpace = require_factory_space(); + var codeIndented = { + name: "codeIndented", + tokenize: tokenizeCodeIndented, + resolve: resolveCodeIndented + }; + var indentedContentConstruct = { + tokenize: tokenizeIndentedContent, + partial: true + }; + function resolveCodeIndented(events, context) { + var code = { + type: "codeIndented", + start: events[0][1].start, + end: events[events.length - 1][1].end + }; + chunkedSplice(events, 0, 0, [["enter", code, context]]); + chunkedSplice(events, events.length, 0, [["exit", code, context]]); + return events; + } + function tokenizeCodeIndented(effects, ok, nok) { + return effects.attempt(indentedContentConstruct, afterPrefix, nok); + function afterPrefix(code) { + if (code === null) { + return ok(code); + } + if (markdownLineEnding(code)) { + return effects.attempt(indentedContentConstruct, afterPrefix, ok)(code); + } + effects.enter("codeFlowValue"); + return content(code); + } + function content(code) { + if (code === null || markdownLineEnding(code)) { + effects.exit("codeFlowValue"); + return afterPrefix(code); + } + effects.consume(code); + return content; + } + } + function tokenizeIndentedContent(effects, ok, nok) { + var self = this; + return factorySpace(effects, afterPrefix, "linePrefix", 4 + 1); + function afterPrefix(code) { + if (markdownLineEnding(code)) { + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + return factorySpace(effects, afterPrefix, "linePrefix", 4 + 1); + } + return prefixSize(self.events, "linePrefix") < 4 ? nok(code) : ok(code); + } + } + module2.exports = codeIndented; + } +}); + +// node_modules/micromark/dist/tokenize/code-text.js +var require_code_text = __commonJS({ + "node_modules/micromark/dist/tokenize/code-text.js"(exports, module2) { + "use strict"; + var markdownLineEnding = require_markdown_line_ending(); + var codeText = { + name: "codeText", + tokenize: tokenizeCodeText, + resolve: resolveCodeText, + previous + }; + function resolveCodeText(events) { + var tailExitIndex = events.length - 4; + var headEnterIndex = 3; + var index; + var enter; + if ((events[headEnterIndex][1].type === "lineEnding" || events[headEnterIndex][1].type === "space") && (events[tailExitIndex][1].type === "lineEnding" || events[tailExitIndex][1].type === "space")) { + index = headEnterIndex; + while (++index < tailExitIndex) { + if (events[index][1].type === "codeTextData") { + events[tailExitIndex][1].type = events[headEnterIndex][1].type = "codeTextPadding"; + headEnterIndex += 2; + tailExitIndex -= 2; + break; + } + } + } + index = headEnterIndex - 1; + tailExitIndex++; + while (++index <= tailExitIndex) { + if (enter === void 0) { + if (index !== tailExitIndex && events[index][1].type !== "lineEnding") { + enter = index; + } + } else if (index === tailExitIndex || events[index][1].type === "lineEnding") { + events[enter][1].type = "codeTextData"; + if (index !== enter + 2) { + events[enter][1].end = events[index - 1][1].end; + events.splice(enter + 2, index - enter - 2); + tailExitIndex -= index - enter - 2; + index = enter + 2; + } + enter = void 0; + } + } + return events; + } + function previous(code) { + return code !== 96 || this.events[this.events.length - 1][1].type === "characterEscape"; + } + function tokenizeCodeText(effects, ok, nok) { + var sizeOpen = 0; + var size; + var token; + return start; + function start(code) { + effects.enter("codeText"); + effects.enter("codeTextSequence"); + return openingSequence(code); + } + function openingSequence(code) { + if (code === 96) { + effects.consume(code); + sizeOpen++; + return openingSequence; + } + effects.exit("codeTextSequence"); + return gap(code); + } + function gap(code) { + if (code === null) { + return nok(code); + } + if (code === 96) { + token = effects.enter("codeTextSequence"); + size = 0; + return closingSequence(code); + } + if (code === 32) { + effects.enter("space"); + effects.consume(code); + effects.exit("space"); + return gap; + } + if (markdownLineEnding(code)) { + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + return gap; + } + effects.enter("codeTextData"); + return data(code); + } + function data(code) { + if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) { + effects.exit("codeTextData"); + return gap(code); + } + effects.consume(code); + return data; + } + function closingSequence(code) { + if (code === 96) { + effects.consume(code); + size++; + return closingSequence; + } + if (size === sizeOpen) { + effects.exit("codeTextSequence"); + effects.exit("codeText"); + return ok(code); + } + token.type = "codeTextData"; + return data(code); + } + } + module2.exports = codeText; + } +}); + +// node_modules/micromark/dist/tokenize/factory-destination.js +var require_factory_destination = __commonJS({ + "node_modules/micromark/dist/tokenize/factory-destination.js"(exports, module2) { + "use strict"; + var asciiControl = require_ascii_control(); + var markdownLineEndingOrSpace = require_markdown_line_ending_or_space(); + var markdownLineEnding = require_markdown_line_ending(); + function destinationFactory(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) { + var limit = max || Infinity; + var balance = 0; + return start; + function start(code) { + if (code === 60) { + effects.enter(type); + effects.enter(literalType); + effects.enter(literalMarkerType); + effects.consume(code); + effects.exit(literalMarkerType); + return destinationEnclosedBefore; + } + if (asciiControl(code) || code === 41) { + return nok(code); + } + effects.enter(type); + effects.enter(rawType); + effects.enter(stringType); + effects.enter("chunkString", { + contentType: "string" + }); + return destinationRaw(code); + } + function destinationEnclosedBefore(code) { + if (code === 62) { + effects.enter(literalMarkerType); + effects.consume(code); + effects.exit(literalMarkerType); + effects.exit(literalType); + effects.exit(type); + return ok; + } + effects.enter(stringType); + effects.enter("chunkString", { + contentType: "string" + }); + return destinationEnclosed(code); + } + function destinationEnclosed(code) { + if (code === 62) { + effects.exit("chunkString"); + effects.exit(stringType); + return destinationEnclosedBefore(code); + } + if (code === null || code === 60 || markdownLineEnding(code)) { + return nok(code); + } + effects.consume(code); + return code === 92 ? destinationEnclosedEscape : destinationEnclosed; + } + function destinationEnclosedEscape(code) { + if (code === 60 || code === 62 || code === 92) { + effects.consume(code); + return destinationEnclosed; + } + return destinationEnclosed(code); + } + function destinationRaw(code) { + if (code === 40) { + if (++balance > limit) + return nok(code); + effects.consume(code); + return destinationRaw; + } + if (code === 41) { + if (!balance--) { + effects.exit("chunkString"); + effects.exit(stringType); + effects.exit(rawType); + effects.exit(type); + return ok(code); + } + effects.consume(code); + return destinationRaw; + } + if (code === null || markdownLineEndingOrSpace(code)) { + if (balance) + return nok(code); + effects.exit("chunkString"); + effects.exit(stringType); + effects.exit(rawType); + effects.exit(type); + return ok(code); + } + if (asciiControl(code)) + return nok(code); + effects.consume(code); + return code === 92 ? destinationRawEscape : destinationRaw; + } + function destinationRawEscape(code) { + if (code === 40 || code === 41 || code === 92) { + effects.consume(code); + return destinationRaw; + } + return destinationRaw(code); + } + } + module2.exports = destinationFactory; + } +}); + +// node_modules/micromark/dist/tokenize/factory-label.js +var require_factory_label = __commonJS({ + "node_modules/micromark/dist/tokenize/factory-label.js"(exports, module2) { + "use strict"; + var markdownLineEnding = require_markdown_line_ending(); + var markdownSpace = require_markdown_space(); + function labelFactory(effects, ok, nok, type, markerType, stringType) { + var self = this; + var size = 0; + var data; + return start; + function start(code) { + effects.enter(type); + effects.enter(markerType); + effects.consume(code); + effects.exit(markerType); + effects.enter(stringType); + return atBreak; + } + function atBreak(code) { + if (code === null || code === 91 || code === 93 && !data || code === 94 && !size && "_hiddenFootnoteSupport" in self.parser.constructs || size > 999) { + return nok(code); + } + if (code === 93) { + effects.exit(stringType); + effects.enter(markerType); + effects.consume(code); + effects.exit(markerType); + effects.exit(type); + return ok; + } + if (markdownLineEnding(code)) { + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + return atBreak; + } + effects.enter("chunkString", { + contentType: "string" + }); + return label(code); + } + function label(code) { + if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) { + effects.exit("chunkString"); + return atBreak(code); + } + effects.consume(code); + data = data || !markdownSpace(code); + return code === 92 ? labelEscape : label; + } + function labelEscape(code) { + if (code === 91 || code === 92 || code === 93) { + effects.consume(code); + size++; + return label; + } + return label(code); + } + } + module2.exports = labelFactory; + } +}); + +// node_modules/micromark/dist/tokenize/factory-whitespace.js +var require_factory_whitespace = __commonJS({ + "node_modules/micromark/dist/tokenize/factory-whitespace.js"(exports, module2) { + "use strict"; + var markdownLineEnding = require_markdown_line_ending(); + var markdownSpace = require_markdown_space(); + var factorySpace = require_factory_space(); + function whitespaceFactory(effects, ok) { + var seen; + return start; + function start(code) { + if (markdownLineEnding(code)) { + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + seen = true; + return start; + } + if (markdownSpace(code)) { + return factorySpace(effects, start, seen ? "linePrefix" : "lineSuffix")(code); + } + return ok(code); + } + } + module2.exports = whitespaceFactory; + } +}); + +// node_modules/micromark/dist/tokenize/factory-title.js +var require_factory_title = __commonJS({ + "node_modules/micromark/dist/tokenize/factory-title.js"(exports, module2) { + "use strict"; + var markdownLineEnding = require_markdown_line_ending(); + var factorySpace = require_factory_space(); + function titleFactory(effects, ok, nok, type, markerType, stringType) { + var marker; + return start; + function start(code) { + effects.enter(type); + effects.enter(markerType); + effects.consume(code); + effects.exit(markerType); + marker = code === 40 ? 41 : code; + return atFirstTitleBreak; + } + function atFirstTitleBreak(code) { + if (code === marker) { + effects.enter(markerType); + effects.consume(code); + effects.exit(markerType); + effects.exit(type); + return ok; + } + effects.enter(stringType); + return atTitleBreak(code); + } + function atTitleBreak(code) { + if (code === marker) { + effects.exit(stringType); + return atFirstTitleBreak(marker); + } + if (code === null) { + return nok(code); + } + if (markdownLineEnding(code)) { + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + return factorySpace(effects, atTitleBreak, "linePrefix"); + } + effects.enter("chunkString", { + contentType: "string" + }); + return title(code); + } + function title(code) { + if (code === marker || code === null || markdownLineEnding(code)) { + effects.exit("chunkString"); + return atTitleBreak(code); + } + effects.consume(code); + return code === 92 ? titleEscape : title; + } + function titleEscape(code) { + if (code === marker || code === 92) { + effects.consume(code); + return title; + } + return title(code); + } + } + module2.exports = titleFactory; + } +}); + +// node_modules/micromark/dist/tokenize/definition.js +var require_definition = __commonJS({ + "node_modules/micromark/dist/tokenize/definition.js"(exports, module2) { + "use strict"; + var markdownLineEnding = require_markdown_line_ending(); + var markdownLineEndingOrSpace = require_markdown_line_ending_or_space(); + var normalizeIdentifier = require_normalize_identifier(); + var factoryDestination = require_factory_destination(); + var factoryLabel = require_factory_label(); + var factorySpace = require_factory_space(); + var factoryWhitespace = require_factory_whitespace(); + var factoryTitle = require_factory_title(); + var definition = { + name: "definition", + tokenize: tokenizeDefinition + }; + var titleConstruct = { + tokenize: tokenizeTitle, + partial: true + }; + function tokenizeDefinition(effects, ok, nok) { + var self = this; + var identifier; + return start; + function start(code) { + effects.enter("definition"); + return factoryLabel.call(self, effects, labelAfter, nok, "definitionLabel", "definitionLabelMarker", "definitionLabelString")(code); + } + function labelAfter(code) { + identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)); + if (code === 58) { + effects.enter("definitionMarker"); + effects.consume(code); + effects.exit("definitionMarker"); + return factoryWhitespace(effects, factoryDestination(effects, effects.attempt(titleConstruct, factorySpace(effects, after, "whitespace"), factorySpace(effects, after, "whitespace")), nok, "definitionDestination", "definitionDestinationLiteral", "definitionDestinationLiteralMarker", "definitionDestinationRaw", "definitionDestinationString")); + } + return nok(code); + } + function after(code) { + if (code === null || markdownLineEnding(code)) { + effects.exit("definition"); + if (self.parser.defined.indexOf(identifier) < 0) { + self.parser.defined.push(identifier); + } + return ok(code); + } + return nok(code); + } + } + function tokenizeTitle(effects, ok, nok) { + return start; + function start(code) { + return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, before)(code) : nok(code); + } + function before(code) { + if (code === 34 || code === 39 || code === 40) { + return factoryTitle(effects, factorySpace(effects, after, "whitespace"), nok, "definitionTitle", "definitionTitleMarker", "definitionTitleString")(code); + } + return nok(code); + } + function after(code) { + return code === null || markdownLineEnding(code) ? ok(code) : nok(code); + } + } + module2.exports = definition; + } +}); + +// node_modules/micromark/dist/tokenize/hard-break-escape.js +var require_hard_break_escape = __commonJS({ + "node_modules/micromark/dist/tokenize/hard-break-escape.js"(exports, module2) { + "use strict"; + var markdownLineEnding = require_markdown_line_ending(); + var hardBreakEscape = { + name: "hardBreakEscape", + tokenize: tokenizeHardBreakEscape + }; + function tokenizeHardBreakEscape(effects, ok, nok) { + return start; + function start(code) { + effects.enter("hardBreakEscape"); + effects.enter("escapeMarker"); + effects.consume(code); + return open; + } + function open(code) { + if (markdownLineEnding(code)) { + effects.exit("escapeMarker"); + effects.exit("hardBreakEscape"); + return ok(code); + } + return nok(code); + } + } + module2.exports = hardBreakEscape; + } +}); + +// node_modules/micromark/dist/tokenize/heading-atx.js +var require_heading_atx = __commonJS({ + "node_modules/micromark/dist/tokenize/heading-atx.js"(exports, module2) { + "use strict"; + var markdownLineEnding = require_markdown_line_ending(); + var markdownLineEndingOrSpace = require_markdown_line_ending_or_space(); + var markdownSpace = require_markdown_space(); + var chunkedSplice = require_chunked_splice(); + var factorySpace = require_factory_space(); + var headingAtx = { + name: "headingAtx", + tokenize: tokenizeHeadingAtx, + resolve: resolveHeadingAtx + }; + function resolveHeadingAtx(events, context) { + var contentEnd = events.length - 2; + var contentStart = 3; + var content; + var text; + if (events[contentStart][1].type === "whitespace") { + contentStart += 2; + } + if (contentEnd - 2 > contentStart && events[contentEnd][1].type === "whitespace") { + contentEnd -= 2; + } + if (events[contentEnd][1].type === "atxHeadingSequence" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === "whitespace")) { + contentEnd -= contentStart + 1 === contentEnd ? 2 : 4; + } + if (contentEnd > contentStart) { + content = { + type: "atxHeadingText", + start: events[contentStart][1].start, + end: events[contentEnd][1].end + }; + text = { + type: "chunkText", + start: events[contentStart][1].start, + end: events[contentEnd][1].end, + contentType: "text" + }; + chunkedSplice(events, contentStart, contentEnd - contentStart + 1, [ + ["enter", content, context], + ["enter", text, context], + ["exit", text, context], + ["exit", content, context] + ]); + } + return events; + } + function tokenizeHeadingAtx(effects, ok, nok) { + var self = this; + var size = 0; + return start; + function start(code) { + effects.enter("atxHeading"); + effects.enter("atxHeadingSequence"); + return fenceOpenInside(code); + } + function fenceOpenInside(code) { + if (code === 35 && size++ < 6) { + effects.consume(code); + return fenceOpenInside; + } + if (code === null || markdownLineEndingOrSpace(code)) { + effects.exit("atxHeadingSequence"); + return self.interrupt ? ok(code) : headingBreak(code); + } + return nok(code); + } + function headingBreak(code) { + if (code === 35) { + effects.enter("atxHeadingSequence"); + return sequence(code); + } + if (code === null || markdownLineEnding(code)) { + effects.exit("atxHeading"); + return ok(code); + } + if (markdownSpace(code)) { + return factorySpace(effects, headingBreak, "whitespace")(code); + } + effects.enter("atxHeadingText"); + return data(code); + } + function sequence(code) { + if (code === 35) { + effects.consume(code); + return sequence; + } + effects.exit("atxHeadingSequence"); + return headingBreak(code); + } + function data(code) { + if (code === null || code === 35 || markdownLineEndingOrSpace(code)) { + effects.exit("atxHeadingText"); + return headingBreak(code); + } + effects.consume(code); + return data; + } + } + module2.exports = headingAtx; + } +}); + +// node_modules/micromark/dist/constant/html-block-names.js +var require_html_block_names = __commonJS({ + "node_modules/micromark/dist/constant/html-block-names.js"(exports, module2) { + "use strict"; + var basics = [ + "address", + "article", + "aside", + "base", + "basefont", + "blockquote", + "body", + "caption", + "center", + "col", + "colgroup", + "dd", + "details", + "dialog", + "dir", + "div", + "dl", + "dt", + "fieldset", + "figcaption", + "figure", + "footer", + "form", + "frame", + "frameset", + "h1", + "h2", + "h3", + "h4", + "h5", + "h6", + "head", + "header", + "hr", + "html", + "iframe", + "legend", + "li", + "link", + "main", + "menu", + "menuitem", + "nav", + "noframes", + "ol", + "optgroup", + "option", + "p", + "param", + "section", + "source", + "summary", + "table", + "tbody", + "td", + "tfoot", + "th", + "thead", + "title", + "tr", + "track", + "ul" + ]; + module2.exports = basics; + } +}); + +// node_modules/micromark/dist/constant/html-raw-names.js +var require_html_raw_names = __commonJS({ + "node_modules/micromark/dist/constant/html-raw-names.js"(exports, module2) { + "use strict"; + var raws = ["pre", "script", "style", "textarea"]; + module2.exports = raws; + } +}); + +// node_modules/micromark/dist/tokenize/html-flow.js +var require_html_flow = __commonJS({ + "node_modules/micromark/dist/tokenize/html-flow.js"(exports, module2) { + "use strict"; + var asciiAlpha = require_ascii_alpha(); + var asciiAlphanumeric = require_ascii_alphanumeric(); + var markdownLineEnding = require_markdown_line_ending(); + var markdownLineEndingOrSpace = require_markdown_line_ending_or_space(); + var markdownSpace = require_markdown_space(); + var fromCharCode = require_from_char_code(); + var htmlBlockNames = require_html_block_names(); + var htmlRawNames = require_html_raw_names(); + var partialBlankLine = require_partial_blank_line(); + var htmlFlow = { + name: "htmlFlow", + tokenize: tokenizeHtmlFlow, + resolveTo: resolveToHtmlFlow, + concrete: true + }; + var nextBlankConstruct = { + tokenize: tokenizeNextBlank, + partial: true + }; + function resolveToHtmlFlow(events) { + var index = events.length; + while (index--) { + if (events[index][0] === "enter" && events[index][1].type === "htmlFlow") { + break; + } + } + if (index > 1 && events[index - 2][1].type === "linePrefix") { + events[index][1].start = events[index - 2][1].start; + events[index + 1][1].start = events[index - 2][1].start; + events.splice(index - 2, 2); + } + return events; + } + function tokenizeHtmlFlow(effects, ok, nok) { + var self = this; + var kind; + var startTag; + var buffer; + var index; + var marker; + return start; + function start(code) { + effects.enter("htmlFlow"); + effects.enter("htmlFlowData"); + effects.consume(code); + return open; + } + function open(code) { + if (code === 33) { + effects.consume(code); + return declarationStart; + } + if (code === 47) { + effects.consume(code); + return tagCloseStart; + } + if (code === 63) { + effects.consume(code); + kind = 3; + return self.interrupt ? ok : continuationDeclarationInside; + } + if (asciiAlpha(code)) { + effects.consume(code); + buffer = fromCharCode(code); + startTag = true; + return tagName; + } + return nok(code); + } + function declarationStart(code) { + if (code === 45) { + effects.consume(code); + kind = 2; + return commentOpenInside; + } + if (code === 91) { + effects.consume(code); + kind = 5; + buffer = "CDATA["; + index = 0; + return cdataOpenInside; + } + if (asciiAlpha(code)) { + effects.consume(code); + kind = 4; + return self.interrupt ? ok : continuationDeclarationInside; + } + return nok(code); + } + function commentOpenInside(code) { + if (code === 45) { + effects.consume(code); + return self.interrupt ? ok : continuationDeclarationInside; + } + return nok(code); + } + function cdataOpenInside(code) { + if (code === buffer.charCodeAt(index++)) { + effects.consume(code); + return index === buffer.length ? self.interrupt ? ok : continuation : cdataOpenInside; + } + return nok(code); + } + function tagCloseStart(code) { + if (asciiAlpha(code)) { + effects.consume(code); + buffer = fromCharCode(code); + return tagName; + } + return nok(code); + } + function tagName(code) { + if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) { + if (code !== 47 && startTag && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) { + kind = 1; + return self.interrupt ? ok(code) : continuation(code); + } + if (htmlBlockNames.indexOf(buffer.toLowerCase()) > -1) { + kind = 6; + if (code === 47) { + effects.consume(code); + return basicSelfClosing; + } + return self.interrupt ? ok(code) : continuation(code); + } + kind = 7; + return self.interrupt ? nok(code) : startTag ? completeAttributeNameBefore(code) : completeClosingTagAfter(code); + } + if (code === 45 || asciiAlphanumeric(code)) { + effects.consume(code); + buffer += fromCharCode(code); + return tagName; + } + return nok(code); + } + function basicSelfClosing(code) { + if (code === 62) { + effects.consume(code); + return self.interrupt ? ok : continuation; + } + return nok(code); + } + function completeClosingTagAfter(code) { + if (markdownSpace(code)) { + effects.consume(code); + return completeClosingTagAfter; + } + return completeEnd(code); + } + function completeAttributeNameBefore(code) { + if (code === 47) { + effects.consume(code); + return completeEnd; + } + if (code === 58 || code === 95 || asciiAlpha(code)) { + effects.consume(code); + return completeAttributeName; + } + if (markdownSpace(code)) { + effects.consume(code); + return completeAttributeNameBefore; + } + return completeEnd(code); + } + function completeAttributeName(code) { + if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) { + effects.consume(code); + return completeAttributeName; + } + return completeAttributeNameAfter(code); + } + function completeAttributeNameAfter(code) { + if (code === 61) { + effects.consume(code); + return completeAttributeValueBefore; + } + if (markdownSpace(code)) { + effects.consume(code); + return completeAttributeNameAfter; + } + return completeAttributeNameBefore(code); + } + function completeAttributeValueBefore(code) { + if (code === null || code === 60 || code === 61 || code === 62 || code === 96) { + return nok(code); + } + if (code === 34 || code === 39) { + effects.consume(code); + marker = code; + return completeAttributeValueQuoted; + } + if (markdownSpace(code)) { + effects.consume(code); + return completeAttributeValueBefore; + } + marker = void 0; + return completeAttributeValueUnquoted(code); + } + function completeAttributeValueQuoted(code) { + if (code === marker) { + effects.consume(code); + return completeAttributeValueQuotedAfter; + } + if (code === null || markdownLineEnding(code)) { + return nok(code); + } + effects.consume(code); + return completeAttributeValueQuoted; + } + function completeAttributeValueUnquoted(code) { + if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) { + return completeAttributeNameAfter(code); + } + effects.consume(code); + return completeAttributeValueUnquoted; + } + function completeAttributeValueQuotedAfter(code) { + if (code === 47 || code === 62 || markdownSpace(code)) { + return completeAttributeNameBefore(code); + } + return nok(code); + } + function completeEnd(code) { + if (code === 62) { + effects.consume(code); + return completeAfter; + } + return nok(code); + } + function completeAfter(code) { + if (markdownSpace(code)) { + effects.consume(code); + return completeAfter; + } + return code === null || markdownLineEnding(code) ? continuation(code) : nok(code); + } + function continuation(code) { + if (code === 45 && kind === 2) { + effects.consume(code); + return continuationCommentInside; + } + if (code === 60 && kind === 1) { + effects.consume(code); + return continuationRawTagOpen; + } + if (code === 62 && kind === 4) { + effects.consume(code); + return continuationClose; + } + if (code === 63 && kind === 3) { + effects.consume(code); + return continuationDeclarationInside; + } + if (code === 93 && kind === 5) { + effects.consume(code); + return continuationCharacterDataInside; + } + if (markdownLineEnding(code) && (kind === 6 || kind === 7)) { + return effects.check(nextBlankConstruct, continuationClose, continuationAtLineEnding)(code); + } + if (code === null || markdownLineEnding(code)) { + return continuationAtLineEnding(code); + } + effects.consume(code); + return continuation; + } + function continuationAtLineEnding(code) { + effects.exit("htmlFlowData"); + return htmlContinueStart(code); + } + function htmlContinueStart(code) { + if (code === null) { + return done(code); + } + if (markdownLineEnding(code)) { + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + return htmlContinueStart; + } + effects.enter("htmlFlowData"); + return continuation(code); + } + function continuationCommentInside(code) { + if (code === 45) { + effects.consume(code); + return continuationDeclarationInside; + } + return continuation(code); + } + function continuationRawTagOpen(code) { + if (code === 47) { + effects.consume(code); + buffer = ""; + return continuationRawEndTag; + } + return continuation(code); + } + function continuationRawEndTag(code) { + if (code === 62 && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) { + effects.consume(code); + return continuationClose; + } + if (asciiAlpha(code) && buffer.length < 8) { + effects.consume(code); + buffer += fromCharCode(code); + return continuationRawEndTag; + } + return continuation(code); + } + function continuationCharacterDataInside(code) { + if (code === 93) { + effects.consume(code); + return continuationDeclarationInside; + } + return continuation(code); + } + function continuationDeclarationInside(code) { + if (code === 62) { + effects.consume(code); + return continuationClose; + } + return continuation(code); + } + function continuationClose(code) { + if (code === null || markdownLineEnding(code)) { + effects.exit("htmlFlowData"); + return done(code); + } + effects.consume(code); + return continuationClose; + } + function done(code) { + effects.exit("htmlFlow"); + return ok(code); + } + } + function tokenizeNextBlank(effects, ok, nok) { + return start; + function start(code) { + effects.exit("htmlFlowData"); + effects.enter("lineEndingBlank"); + effects.consume(code); + effects.exit("lineEndingBlank"); + return effects.attempt(partialBlankLine, ok, nok); + } + } + module2.exports = htmlFlow; + } +}); + +// node_modules/micromark/dist/tokenize/html-text.js +var require_html_text = __commonJS({ + "node_modules/micromark/dist/tokenize/html-text.js"(exports, module2) { + "use strict"; + var asciiAlpha = require_ascii_alpha(); + var asciiAlphanumeric = require_ascii_alphanumeric(); + var markdownLineEnding = require_markdown_line_ending(); + var markdownLineEndingOrSpace = require_markdown_line_ending_or_space(); + var markdownSpace = require_markdown_space(); + var factorySpace = require_factory_space(); + var htmlText = { + name: "htmlText", + tokenize: tokenizeHtmlText + }; + function tokenizeHtmlText(effects, ok, nok) { + var self = this; + var marker; + var buffer; + var index; + var returnState; + return start; + function start(code) { + effects.enter("htmlText"); + effects.enter("htmlTextData"); + effects.consume(code); + return open; + } + function open(code) { + if (code === 33) { + effects.consume(code); + return declarationOpen; + } + if (code === 47) { + effects.consume(code); + return tagCloseStart; + } + if (code === 63) { + effects.consume(code); + return instruction; + } + if (asciiAlpha(code)) { + effects.consume(code); + return tagOpen; + } + return nok(code); + } + function declarationOpen(code) { + if (code === 45) { + effects.consume(code); + return commentOpen; + } + if (code === 91) { + effects.consume(code); + buffer = "CDATA["; + index = 0; + return cdataOpen; + } + if (asciiAlpha(code)) { + effects.consume(code); + return declaration; + } + return nok(code); + } + function commentOpen(code) { + if (code === 45) { + effects.consume(code); + return commentStart; + } + return nok(code); + } + function commentStart(code) { + if (code === null || code === 62) { + return nok(code); + } + if (code === 45) { + effects.consume(code); + return commentStartDash; + } + return comment(code); + } + function commentStartDash(code) { + if (code === null || code === 62) { + return nok(code); + } + return comment(code); + } + function comment(code) { + if (code === null) { + return nok(code); + } + if (code === 45) { + effects.consume(code); + return commentClose; + } + if (markdownLineEnding(code)) { + returnState = comment; + return atLineEnding(code); + } + effects.consume(code); + return comment; + } + function commentClose(code) { + if (code === 45) { + effects.consume(code); + return end; + } + return comment(code); + } + function cdataOpen(code) { + if (code === buffer.charCodeAt(index++)) { + effects.consume(code); + return index === buffer.length ? cdata : cdataOpen; + } + return nok(code); + } + function cdata(code) { + if (code === null) { + return nok(code); + } + if (code === 93) { + effects.consume(code); + return cdataClose; + } + if (markdownLineEnding(code)) { + returnState = cdata; + return atLineEnding(code); + } + effects.consume(code); + return cdata; + } + function cdataClose(code) { + if (code === 93) { + effects.consume(code); + return cdataEnd; + } + return cdata(code); + } + function cdataEnd(code) { + if (code === 62) { + return end(code); + } + if (code === 93) { + effects.consume(code); + return cdataEnd; + } + return cdata(code); + } + function declaration(code) { + if (code === null || code === 62) { + return end(code); + } + if (markdownLineEnding(code)) { + returnState = declaration; + return atLineEnding(code); + } + effects.consume(code); + return declaration; + } + function instruction(code) { + if (code === null) { + return nok(code); + } + if (code === 63) { + effects.consume(code); + return instructionClose; + } + if (markdownLineEnding(code)) { + returnState = instruction; + return atLineEnding(code); + } + effects.consume(code); + return instruction; + } + function instructionClose(code) { + return code === 62 ? end(code) : instruction(code); + } + function tagCloseStart(code) { + if (asciiAlpha(code)) { + effects.consume(code); + return tagClose; + } + return nok(code); + } + function tagClose(code) { + if (code === 45 || asciiAlphanumeric(code)) { + effects.consume(code); + return tagClose; + } + return tagCloseBetween(code); + } + function tagCloseBetween(code) { + if (markdownLineEnding(code)) { + returnState = tagCloseBetween; + return atLineEnding(code); + } + if (markdownSpace(code)) { + effects.consume(code); + return tagCloseBetween; + } + return end(code); + } + function tagOpen(code) { + if (code === 45 || asciiAlphanumeric(code)) { + effects.consume(code); + return tagOpen; + } + if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) { + return tagOpenBetween(code); + } + return nok(code); + } + function tagOpenBetween(code) { + if (code === 47) { + effects.consume(code); + return end; + } + if (code === 58 || code === 95 || asciiAlpha(code)) { + effects.consume(code); + return tagOpenAttributeName; + } + if (markdownLineEnding(code)) { + returnState = tagOpenBetween; + return atLineEnding(code); + } + if (markdownSpace(code)) { + effects.consume(code); + return tagOpenBetween; + } + return end(code); + } + function tagOpenAttributeName(code) { + if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) { + effects.consume(code); + return tagOpenAttributeName; + } + return tagOpenAttributeNameAfter(code); + } + function tagOpenAttributeNameAfter(code) { + if (code === 61) { + effects.consume(code); + return tagOpenAttributeValueBefore; + } + if (markdownLineEnding(code)) { + returnState = tagOpenAttributeNameAfter; + return atLineEnding(code); + } + if (markdownSpace(code)) { + effects.consume(code); + return tagOpenAttributeNameAfter; + } + return tagOpenBetween(code); + } + function tagOpenAttributeValueBefore(code) { + if (code === null || code === 60 || code === 61 || code === 62 || code === 96) { + return nok(code); + } + if (code === 34 || code === 39) { + effects.consume(code); + marker = code; + return tagOpenAttributeValueQuoted; + } + if (markdownLineEnding(code)) { + returnState = tagOpenAttributeValueBefore; + return atLineEnding(code); + } + if (markdownSpace(code)) { + effects.consume(code); + return tagOpenAttributeValueBefore; + } + effects.consume(code); + marker = void 0; + return tagOpenAttributeValueUnquoted; + } + function tagOpenAttributeValueQuoted(code) { + if (code === marker) { + effects.consume(code); + return tagOpenAttributeValueQuotedAfter; + } + if (code === null) { + return nok(code); + } + if (markdownLineEnding(code)) { + returnState = tagOpenAttributeValueQuoted; + return atLineEnding(code); + } + effects.consume(code); + return tagOpenAttributeValueQuoted; + } + function tagOpenAttributeValueQuotedAfter(code) { + if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) { + return tagOpenBetween(code); + } + return nok(code); + } + function tagOpenAttributeValueUnquoted(code) { + if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) { + return nok(code); + } + if (code === 62 || markdownLineEndingOrSpace(code)) { + return tagOpenBetween(code); + } + effects.consume(code); + return tagOpenAttributeValueUnquoted; + } + function atLineEnding(code) { + effects.exit("htmlTextData"); + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + return factorySpace(effects, afterPrefix, "linePrefix", self.parser.constructs.disable.null.indexOf("codeIndented") > -1 ? void 0 : 4); + } + function afterPrefix(code) { + effects.enter("htmlTextData"); + return returnState(code); + } + function end(code) { + if (code === 62) { + effects.consume(code); + effects.exit("htmlTextData"); + effects.exit("htmlText"); + return ok; + } + return nok(code); + } + } + module2.exports = htmlText; + } +}); + +// node_modules/micromark/dist/tokenize/label-end.js +var require_label_end = __commonJS({ + "node_modules/micromark/dist/tokenize/label-end.js"(exports, module2) { + "use strict"; + var markdownLineEndingOrSpace = require_markdown_line_ending_or_space(); + var chunkedPush = require_chunked_push(); + var chunkedSplice = require_chunked_splice(); + var normalizeIdentifier = require_normalize_identifier(); + var resolveAll = require_resolve_all(); + var shallow = require_shallow(); + var factoryDestination = require_factory_destination(); + var factoryLabel = require_factory_label(); + var factoryTitle = require_factory_title(); + var factoryWhitespace = require_factory_whitespace(); + var labelEnd = { + name: "labelEnd", + tokenize: tokenizeLabelEnd, + resolveTo: resolveToLabelEnd, + resolveAll: resolveAllLabelEnd + }; + var resourceConstruct = { + tokenize: tokenizeResource + }; + var fullReferenceConstruct = { + tokenize: tokenizeFullReference + }; + var collapsedReferenceConstruct = { + tokenize: tokenizeCollapsedReference + }; + function resolveAllLabelEnd(events) { + var index = -1; + var token; + while (++index < events.length) { + token = events[index][1]; + if (!token._used && (token.type === "labelImage" || token.type === "labelLink" || token.type === "labelEnd")) { + events.splice(index + 1, token.type === "labelImage" ? 4 : 2); + token.type = "data"; + index++; + } + } + return events; + } + function resolveToLabelEnd(events, context) { + var index = events.length; + var offset = 0; + var group; + var label; + var text; + var token; + var open; + var close; + var media; + while (index--) { + token = events[index][1]; + if (open) { + if (token.type === "link" || token.type === "labelLink" && token._inactive) { + break; + } + if (events[index][0] === "enter" && token.type === "labelLink") { + token._inactive = true; + } + } else if (close) { + if (events[index][0] === "enter" && (token.type === "labelImage" || token.type === "labelLink") && !token._balanced) { + open = index; + if (token.type !== "labelLink") { + offset = 2; + break; + } + } + } else if (token.type === "labelEnd") { + close = index; + } + } + group = { + type: events[open][1].type === "labelLink" ? "link" : "image", + start: shallow(events[open][1].start), + end: shallow(events[events.length - 1][1].end) + }; + label = { + type: "label", + start: shallow(events[open][1].start), + end: shallow(events[close][1].end) + }; + text = { + type: "labelText", + start: shallow(events[open + offset + 2][1].end), + end: shallow(events[close - 2][1].start) + }; + media = [ + ["enter", group, context], + ["enter", label, context] + ]; + media = chunkedPush(media, events.slice(open + 1, open + offset + 3)); + media = chunkedPush(media, [["enter", text, context]]); + media = chunkedPush(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context)); + media = chunkedPush(media, [ + ["exit", text, context], + events[close - 2], + events[close - 1], + ["exit", label, context] + ]); + media = chunkedPush(media, events.slice(close + 1)); + media = chunkedPush(media, [["exit", group, context]]); + chunkedSplice(events, open, events.length, media); + return events; + } + function tokenizeLabelEnd(effects, ok, nok) { + var self = this; + var index = self.events.length; + var labelStart; + var defined; + while (index--) { + if ((self.events[index][1].type === "labelImage" || self.events[index][1].type === "labelLink") && !self.events[index][1]._balanced) { + labelStart = self.events[index][1]; + break; + } + } + return start; + function start(code) { + if (!labelStart) { + return nok(code); + } + if (labelStart._inactive) + return balanced(code); + defined = self.parser.defined.indexOf(normalizeIdentifier(self.sliceSerialize({ + start: labelStart.end, + end: self.now() + }))) > -1; + effects.enter("labelEnd"); + effects.enter("labelMarker"); + effects.consume(code); + effects.exit("labelMarker"); + effects.exit("labelEnd"); + return afterLabelEnd; + } + function afterLabelEnd(code) { + if (code === 40) { + return effects.attempt(resourceConstruct, ok, defined ? ok : balanced)(code); + } + if (code === 91) { + return effects.attempt(fullReferenceConstruct, ok, defined ? effects.attempt(collapsedReferenceConstruct, ok, balanced) : balanced)(code); + } + return defined ? ok(code) : balanced(code); + } + function balanced(code) { + labelStart._balanced = true; + return nok(code); + } + } + function tokenizeResource(effects, ok, nok) { + return start; + function start(code) { + effects.enter("resource"); + effects.enter("resourceMarker"); + effects.consume(code); + effects.exit("resourceMarker"); + return factoryWhitespace(effects, open); + } + function open(code) { + if (code === 41) { + return end(code); + } + return factoryDestination(effects, destinationAfter, nok, "resourceDestination", "resourceDestinationLiteral", "resourceDestinationLiteralMarker", "resourceDestinationRaw", "resourceDestinationString", 3)(code); + } + function destinationAfter(code) { + return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, between)(code) : end(code); + } + function between(code) { + if (code === 34 || code === 39 || code === 40) { + return factoryTitle(effects, factoryWhitespace(effects, end), nok, "resourceTitle", "resourceTitleMarker", "resourceTitleString")(code); + } + return end(code); + } + function end(code) { + if (code === 41) { + effects.enter("resourceMarker"); + effects.consume(code); + effects.exit("resourceMarker"); + effects.exit("resource"); + return ok; + } + return nok(code); + } + } + function tokenizeFullReference(effects, ok, nok) { + var self = this; + return start; + function start(code) { + return factoryLabel.call(self, effects, afterLabel, nok, "reference", "referenceMarker", "referenceString")(code); + } + function afterLabel(code) { + return self.parser.defined.indexOf(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) < 0 ? nok(code) : ok(code); + } + } + function tokenizeCollapsedReference(effects, ok, nok) { + return start; + function start(code) { + effects.enter("reference"); + effects.enter("referenceMarker"); + effects.consume(code); + effects.exit("referenceMarker"); + return open; + } + function open(code) { + if (code === 93) { + effects.enter("referenceMarker"); + effects.consume(code); + effects.exit("referenceMarker"); + effects.exit("reference"); + return ok; + } + return nok(code); + } + } + module2.exports = labelEnd; + } +}); + +// node_modules/micromark/dist/tokenize/label-start-image.js +var require_label_start_image = __commonJS({ + "node_modules/micromark/dist/tokenize/label-start-image.js"(exports, module2) { + "use strict"; + var labelEnd = require_label_end(); + var labelStartImage = { + name: "labelStartImage", + tokenize: tokenizeLabelStartImage, + resolveAll: labelEnd.resolveAll + }; + function tokenizeLabelStartImage(effects, ok, nok) { + var self = this; + return start; + function start(code) { + effects.enter("labelImage"); + effects.enter("labelImageMarker"); + effects.consume(code); + effects.exit("labelImageMarker"); + return open; + } + function open(code) { + if (code === 91) { + effects.enter("labelMarker"); + effects.consume(code); + effects.exit("labelMarker"); + effects.exit("labelImage"); + return after; + } + return nok(code); + } + function after(code) { + return code === 94 && "_hiddenFootnoteSupport" in self.parser.constructs ? nok(code) : ok(code); + } + } + module2.exports = labelStartImage; + } +}); + +// node_modules/micromark/dist/tokenize/label-start-link.js +var require_label_start_link = __commonJS({ + "node_modules/micromark/dist/tokenize/label-start-link.js"(exports, module2) { + "use strict"; + var labelEnd = require_label_end(); + var labelStartLink = { + name: "labelStartLink", + tokenize: tokenizeLabelStartLink, + resolveAll: labelEnd.resolveAll + }; + function tokenizeLabelStartLink(effects, ok, nok) { + var self = this; + return start; + function start(code) { + effects.enter("labelLink"); + effects.enter("labelMarker"); + effects.consume(code); + effects.exit("labelMarker"); + effects.exit("labelLink"); + return after; + } + function after(code) { + return code === 94 && "_hiddenFootnoteSupport" in self.parser.constructs ? nok(code) : ok(code); + } + } + module2.exports = labelStartLink; + } +}); + +// node_modules/micromark/dist/tokenize/line-ending.js +var require_line_ending = __commonJS({ + "node_modules/micromark/dist/tokenize/line-ending.js"(exports, module2) { + "use strict"; + var factorySpace = require_factory_space(); + var lineEnding = { + name: "lineEnding", + tokenize: tokenizeLineEnding + }; + function tokenizeLineEnding(effects, ok) { + return start; + function start(code) { + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + return factorySpace(effects, ok, "linePrefix"); + } + } + module2.exports = lineEnding; + } +}); + +// node_modules/micromark/dist/tokenize/thematic-break.js +var require_thematic_break = __commonJS({ + "node_modules/micromark/dist/tokenize/thematic-break.js"(exports, module2) { + "use strict"; + var markdownLineEnding = require_markdown_line_ending(); + var markdownSpace = require_markdown_space(); + var factorySpace = require_factory_space(); + var thematicBreak = { + name: "thematicBreak", + tokenize: tokenizeThematicBreak + }; + function tokenizeThematicBreak(effects, ok, nok) { + var size = 0; + var marker; + return start; + function start(code) { + effects.enter("thematicBreak"); + marker = code; + return atBreak(code); + } + function atBreak(code) { + if (code === marker) { + effects.enter("thematicBreakSequence"); + return sequence(code); + } + if (markdownSpace(code)) { + return factorySpace(effects, atBreak, "whitespace")(code); + } + if (size < 3 || code !== null && !markdownLineEnding(code)) { + return nok(code); + } + effects.exit("thematicBreak"); + return ok(code); + } + function sequence(code) { + if (code === marker) { + effects.consume(code); + size++; + return sequence; + } + effects.exit("thematicBreakSequence"); + return atBreak(code); + } + } + module2.exports = thematicBreak; + } +}); + +// node_modules/micromark/dist/tokenize/list.js +var require_list = __commonJS({ + "node_modules/micromark/dist/tokenize/list.js"(exports, module2) { + "use strict"; + var asciiDigit = require_ascii_digit(); + var markdownSpace = require_markdown_space(); + var prefixSize = require_prefix_size(); + var sizeChunks = require_size_chunks(); + var factorySpace = require_factory_space(); + var partialBlankLine = require_partial_blank_line(); + var thematicBreak = require_thematic_break(); + var list = { + name: "list", + tokenize: tokenizeListStart, + continuation: { + tokenize: tokenizeListContinuation + }, + exit: tokenizeListEnd + }; + var listItemPrefixWhitespaceConstruct = { + tokenize: tokenizeListItemPrefixWhitespace, + partial: true + }; + var indentConstruct = { + tokenize: tokenizeIndent, + partial: true + }; + function tokenizeListStart(effects, ok, nok) { + var self = this; + var initialSize = prefixSize(self.events, "linePrefix"); + var size = 0; + return start; + function start(code) { + var kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? "listUnordered" : "listOrdered"); + if (kind === "listUnordered" ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) { + if (!self.containerState.type) { + self.containerState.type = kind; + effects.enter(kind, { + _container: true + }); + } + if (kind === "listUnordered") { + effects.enter("listItemPrefix"); + return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code); + } + if (!self.interrupt || code === 49) { + effects.enter("listItemPrefix"); + effects.enter("listItemValue"); + return inside(code); + } + } + return nok(code); + } + function inside(code) { + if (asciiDigit(code) && ++size < 10) { + effects.consume(code); + return inside; + } + if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) { + effects.exit("listItemValue"); + return atMarker(code); + } + return nok(code); + } + function atMarker(code) { + effects.enter("listItemMarker"); + effects.consume(code); + effects.exit("listItemMarker"); + self.containerState.marker = self.containerState.marker || code; + return effects.check(partialBlankLine, self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix)); + } + function onBlank(code) { + self.containerState.initialBlankLine = true; + initialSize++; + return endOfPrefix(code); + } + function otherPrefix(code) { + if (markdownSpace(code)) { + effects.enter("listItemPrefixWhitespace"); + effects.consume(code); + effects.exit("listItemPrefixWhitespace"); + return endOfPrefix; + } + return nok(code); + } + function endOfPrefix(code) { + self.containerState.size = initialSize + sizeChunks(self.sliceStream(effects.exit("listItemPrefix"))); + return ok(code); + } + } + function tokenizeListContinuation(effects, ok, nok) { + var self = this; + self.containerState._closeFlow = void 0; + return effects.check(partialBlankLine, onBlank, notBlank); + function onBlank(code) { + self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine; + return factorySpace(effects, ok, "listItemIndent", self.containerState.size + 1)(code); + } + function notBlank(code) { + if (self.containerState.furtherBlankLines || !markdownSpace(code)) { + self.containerState.furtherBlankLines = self.containerState.initialBlankLine = void 0; + return notInCurrentItem(code); + } + self.containerState.furtherBlankLines = self.containerState.initialBlankLine = void 0; + return effects.attempt(indentConstruct, ok, notInCurrentItem)(code); + } + function notInCurrentItem(code) { + self.containerState._closeFlow = true; + self.interrupt = void 0; + return factorySpace(effects, effects.attempt(list, ok, nok), "linePrefix", self.parser.constructs.disable.null.indexOf("codeIndented") > -1 ? void 0 : 4)(code); + } + } + function tokenizeIndent(effects, ok, nok) { + var self = this; + return factorySpace(effects, afterPrefix, "listItemIndent", self.containerState.size + 1); + function afterPrefix(code) { + return prefixSize(self.events, "listItemIndent") === self.containerState.size ? ok(code) : nok(code); + } + } + function tokenizeListEnd(effects) { + effects.exit(this.containerState.type); + } + function tokenizeListItemPrefixWhitespace(effects, ok, nok) { + var self = this; + return factorySpace(effects, afterPrefix, "listItemPrefixWhitespace", self.parser.constructs.disable.null.indexOf("codeIndented") > -1 ? void 0 : 4 + 1); + function afterPrefix(code) { + return markdownSpace(code) || !prefixSize(self.events, "listItemPrefixWhitespace") ? nok(code) : ok(code); + } + } + module2.exports = list; + } +}); + +// node_modules/micromark/dist/tokenize/setext-underline.js +var require_setext_underline = __commonJS({ + "node_modules/micromark/dist/tokenize/setext-underline.js"(exports, module2) { + "use strict"; + var markdownLineEnding = require_markdown_line_ending(); + var shallow = require_shallow(); + var factorySpace = require_factory_space(); + var setextUnderline = { + name: "setextUnderline", + tokenize: tokenizeSetextUnderline, + resolveTo: resolveToSetextUnderline + }; + function resolveToSetextUnderline(events, context) { + var index = events.length; + var content; + var text; + var definition; + var heading; + while (index--) { + if (events[index][0] === "enter") { + if (events[index][1].type === "content") { + content = index; + break; + } + if (events[index][1].type === "paragraph") { + text = index; + } + } else { + if (events[index][1].type === "content") { + events.splice(index, 1); + } + if (!definition && events[index][1].type === "definition") { + definition = index; + } + } + } + heading = { + type: "setextHeading", + start: shallow(events[text][1].start), + end: shallow(events[events.length - 1][1].end) + }; + events[text][1].type = "setextHeadingText"; + if (definition) { + events.splice(text, 0, ["enter", heading, context]); + events.splice(definition + 1, 0, ["exit", events[content][1], context]); + events[content][1].end = shallow(events[definition][1].end); + } else { + events[content][1] = heading; + } + events.push(["exit", heading, context]); + return events; + } + function tokenizeSetextUnderline(effects, ok, nok) { + var self = this; + var index = self.events.length; + var marker; + var paragraph; + while (index--) { + if (self.events[index][1].type !== "lineEnding" && self.events[index][1].type !== "linePrefix" && self.events[index][1].type !== "content") { + paragraph = self.events[index][1].type === "paragraph"; + break; + } + } + return start; + function start(code) { + if (!self.lazy && (self.interrupt || paragraph)) { + effects.enter("setextHeadingLine"); + effects.enter("setextHeadingLineSequence"); + marker = code; + return closingSequence(code); + } + return nok(code); + } + function closingSequence(code) { + if (code === marker) { + effects.consume(code); + return closingSequence; + } + effects.exit("setextHeadingLineSequence"); + return factorySpace(effects, closingSequenceEnd, "lineSuffix")(code); + } + function closingSequenceEnd(code) { + if (code === null || markdownLineEnding(code)) { + effects.exit("setextHeadingLine"); + return ok(code); + } + return nok(code); + } + } + module2.exports = setextUnderline; + } +}); + +// node_modules/micromark/dist/constructs.js +var require_constructs = __commonJS({ + "node_modules/micromark/dist/constructs.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var text$1 = require_text(); + var attention = require_attention(); + var autolink = require_autolink(); + var blockQuote = require_block_quote(); + var characterEscape = require_character_escape(); + var characterReference = require_character_reference(); + var codeFenced = require_code_fenced(); + var codeIndented = require_code_indented(); + var codeText = require_code_text(); + var definition = require_definition(); + var hardBreakEscape = require_hard_break_escape(); + var headingAtx = require_heading_atx(); + var htmlFlow = require_html_flow(); + var htmlText = require_html_text(); + var labelEnd = require_label_end(); + var labelStartImage = require_label_start_image(); + var labelStartLink = require_label_start_link(); + var lineEnding = require_line_ending(); + var list = require_list(); + var setextUnderline = require_setext_underline(); + var thematicBreak = require_thematic_break(); + var document2 = { + 42: list, + 43: list, + 45: list, + 48: list, + 49: list, + 50: list, + 51: list, + 52: list, + 53: list, + 54: list, + 55: list, + 56: list, + 57: list, + 62: blockQuote + }; + var contentInitial = { + 91: definition + }; + var flowInitial = { + "-2": codeIndented, + "-1": codeIndented, + 32: codeIndented + }; + var flow = { + 35: headingAtx, + 42: thematicBreak, + 45: [setextUnderline, thematicBreak], + 60: htmlFlow, + 61: setextUnderline, + 95: thematicBreak, + 96: codeFenced, + 126: codeFenced + }; + var string2 = { + 38: characterReference, + 92: characterEscape + }; + var text = { + "-5": lineEnding, + "-4": lineEnding, + "-3": lineEnding, + 33: labelStartImage, + 38: characterReference, + 42: attention, + 60: [autolink, htmlText], + 91: labelStartLink, + 92: [hardBreakEscape, characterEscape], + 93: labelEnd, + 95: attention, + 96: codeText + }; + var insideSpan = { + null: [attention, text$1.resolver] + }; + var disable = { + null: [] + }; + exports.contentInitial = contentInitial; + exports.disable = disable; + exports.document = document2; + exports.flow = flow; + exports.flowInitial = flowInitial; + exports.insideSpan = insideSpan; + exports.string = string2; + exports.text = text; + } +}); + +// node_modules/micromark/dist/parse.js +var require_parse = __commonJS({ + "node_modules/micromark/dist/parse.js"(exports, module2) { + "use strict"; + var content = require_content(); + var document2 = require_document(); + var flow = require_flow(); + var text = require_text(); + var combineExtensions = require_combine_extensions(); + var createTokenizer = require_create_tokenizer(); + var miniflat = require_miniflat(); + var constructs = require_constructs(); + function parse3(options) { + var settings = options || {}; + var parser = { + defined: [], + constructs: combineExtensions([constructs].concat(miniflat(settings.extensions))), + content: create(content), + document: create(document2), + flow: create(flow), + string: create(text.string), + text: create(text.text) + }; + return parser; + function create(initializer) { + return creator; + function creator(from) { + return createTokenizer(parser, initializer, from); + } + } + } + module2.exports = parse3; + } +}); + +// node_modules/micromark/dist/preprocess.js +var require_preprocess = __commonJS({ + "node_modules/micromark/dist/preprocess.js"(exports, module2) { + "use strict"; + var search = /[\0\t\n\r]/g; + function preprocess() { + var start = true; + var column = 1; + var buffer = ""; + var atCarriageReturn; + return preprocessor; + function preprocessor(value, encoding, end) { + var chunks = []; + var match; + var next; + var startPosition; + var endPosition; + var code; + value = buffer + value.toString(encoding); + startPosition = 0; + buffer = ""; + if (start) { + if (value.charCodeAt(0) === 65279) { + startPosition++; + } + start = void 0; + } + while (startPosition < value.length) { + search.lastIndex = startPosition; + match = search.exec(value); + endPosition = match ? match.index : value.length; + code = value.charCodeAt(endPosition); + if (!match) { + buffer = value.slice(startPosition); + break; + } + if (code === 10 && startPosition === endPosition && atCarriageReturn) { + chunks.push(-3); + atCarriageReturn = void 0; + } else { + if (atCarriageReturn) { + chunks.push(-5); + atCarriageReturn = void 0; + } + if (startPosition < endPosition) { + chunks.push(value.slice(startPosition, endPosition)); + column += endPosition - startPosition; + } + if (code === 0) { + chunks.push(65533); + column++; + } else if (code === 9) { + next = Math.ceil(column / 4) * 4; + chunks.push(-2); + while (column++ < next) + chunks.push(-1); + } else if (code === 10) { + chunks.push(-4); + column = 1; + } else { + atCarriageReturn = true; + column = 1; + } + } + startPosition = endPosition + 1; + } + if (end) { + if (atCarriageReturn) + chunks.push(-5); + if (buffer) + chunks.push(buffer); + chunks.push(null); + } + return chunks; + } + } + module2.exports = preprocess; + } +}); + +// node_modules/micromark/dist/postprocess.js +var require_postprocess = __commonJS({ + "node_modules/micromark/dist/postprocess.js"(exports, module2) { + "use strict"; + var subtokenize = require_subtokenize(); + function postprocess(events) { + while (!subtokenize(events)) { + } + return events; + } + module2.exports = postprocess; + } +}); + +// node_modules/mdast-util-from-markdown/dist/index.js +var require_dist = __commonJS({ + "node_modules/mdast-util-from-markdown/dist/index.js"(exports, module2) { + "use strict"; + module2.exports = fromMarkdown; + var toString = require_mdast_util_to_string(); + var assign = require_assign(); + var own = require_has_own_property(); + var normalizeIdentifier = require_normalize_identifier(); + var safeFromInt = require_safe_from_int(); + var parser = require_parse(); + var preprocessor = require_preprocess(); + var postprocess = require_postprocess(); + var decode = require_decode_entity_browser(); + var stringifyPosition = require_unist_util_stringify_position(); + function fromMarkdown(value, encoding, options) { + if (typeof encoding !== "string") { + options = encoding; + encoding = void 0; + } + return compiler(options)(postprocess(parser(options).document().write(preprocessor()(value, encoding, true)))); + } + function compiler(options) { + var settings = options || {}; + var config = configure({ + transforms: [], + canContainEols: [ + "emphasis", + "fragment", + "heading", + "paragraph", + "strong" + ], + enter: { + autolink: opener(link), + autolinkProtocol: onenterdata, + autolinkEmail: onenterdata, + atxHeading: opener(heading), + blockQuote: opener(blockQuote), + characterEscape: onenterdata, + characterReference: onenterdata, + codeFenced: opener(codeFlow), + codeFencedFenceInfo: buffer, + codeFencedFenceMeta: buffer, + codeIndented: opener(codeFlow, buffer), + codeText: opener(codeText, buffer), + codeTextData: onenterdata, + data: onenterdata, + codeFlowValue: onenterdata, + definition: opener(definition), + definitionDestinationString: buffer, + definitionLabelString: buffer, + definitionTitleString: buffer, + emphasis: opener(emphasis), + hardBreakEscape: opener(hardBreak), + hardBreakTrailing: opener(hardBreak), + htmlFlow: opener(html, buffer), + htmlFlowData: onenterdata, + htmlText: opener(html, buffer), + htmlTextData: onenterdata, + image: opener(image), + label: buffer, + link: opener(link), + listItem: opener(listItem), + listItemValue: onenterlistitemvalue, + listOrdered: opener(list, onenterlistordered), + listUnordered: opener(list), + paragraph: opener(paragraph), + reference: onenterreference, + referenceString: buffer, + resourceDestinationString: buffer, + resourceTitleString: buffer, + setextHeading: opener(heading), + strong: opener(strong), + thematicBreak: opener(thematicBreak) + }, + exit: { + atxHeading: closer(), + atxHeadingSequence: onexitatxheadingsequence, + autolink: closer(), + autolinkEmail: onexitautolinkemail, + autolinkProtocol: onexitautolinkprotocol, + blockQuote: closer(), + characterEscapeValue: onexitdata, + characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker, + characterReferenceMarkerNumeric: onexitcharacterreferencemarker, + characterReferenceValue: onexitcharacterreferencevalue, + codeFenced: closer(onexitcodefenced), + codeFencedFence: onexitcodefencedfence, + codeFencedFenceInfo: onexitcodefencedfenceinfo, + codeFencedFenceMeta: onexitcodefencedfencemeta, + codeFlowValue: onexitdata, + codeIndented: closer(onexitcodeindented), + codeText: closer(onexitcodetext), + codeTextData: onexitdata, + data: onexitdata, + definition: closer(), + definitionDestinationString: onexitdefinitiondestinationstring, + definitionLabelString: onexitdefinitionlabelstring, + definitionTitleString: onexitdefinitiontitlestring, + emphasis: closer(), + hardBreakEscape: closer(onexithardbreak), + hardBreakTrailing: closer(onexithardbreak), + htmlFlow: closer(onexithtmlflow), + htmlFlowData: onexitdata, + htmlText: closer(onexithtmltext), + htmlTextData: onexitdata, + image: closer(onexitimage), + label: onexitlabel, + labelText: onexitlabeltext, + lineEnding: onexitlineending, + link: closer(onexitlink), + listItem: closer(), + listOrdered: closer(), + listUnordered: closer(), + paragraph: closer(), + referenceString: onexitreferencestring, + resourceDestinationString: onexitresourcedestinationstring, + resourceTitleString: onexitresourcetitlestring, + resource: onexitresource, + setextHeading: closer(onexitsetextheading), + setextHeadingLineSequence: onexitsetextheadinglinesequence, + setextHeadingText: onexitsetextheadingtext, + strong: closer(), + thematicBreak: closer() + } + }, settings.mdastExtensions || []); + var data = {}; + return compile; + function compile(events) { + var tree = { type: "root", children: [] }; + var stack = [tree]; + var tokenStack = []; + var listStack = []; + var index = -1; + var handler; + var listStart; + var context = { + stack, + tokenStack, + config, + enter, + exit, + buffer, + resume, + setData, + getData + }; + while (++index < events.length) { + if (events[index][1].type === "listOrdered" || events[index][1].type === "listUnordered") { + if (events[index][0] === "enter") { + listStack.push(index); + } else { + listStart = listStack.pop(index); + index = prepareList(events, listStart, index); + } + } + } + index = -1; + while (++index < events.length) { + handler = config[events[index][0]]; + if (own.call(handler, events[index][1].type)) { + handler[events[index][1].type].call(assign({ sliceSerialize: events[index][2].sliceSerialize }, context), events[index][1]); + } + } + if (tokenStack.length) { + throw new Error("Cannot close document, a token (`" + tokenStack[tokenStack.length - 1].type + "`, " + stringifyPosition({ + start: tokenStack[tokenStack.length - 1].start, + end: tokenStack[tokenStack.length - 1].end + }) + ") is still open"); + } + tree.position = { + start: point(events.length ? events[0][1].start : { line: 1, column: 1, offset: 0 }), + end: point(events.length ? events[events.length - 2][1].end : { line: 1, column: 1, offset: 0 }) + }; + index = -1; + while (++index < config.transforms.length) { + tree = config.transforms[index](tree) || tree; + } + return tree; + } + function prepareList(events, start, length) { + var index = start - 1; + var containerBalance = -1; + var listSpread = false; + var listItem2; + var tailIndex; + var lineIndex; + var tailEvent; + var event; + var firstBlankLineIndex; + var atMarker; + while (++index <= length) { + event = events[index]; + if (event[1].type === "listUnordered" || event[1].type === "listOrdered" || event[1].type === "blockQuote") { + if (event[0] === "enter") { + containerBalance++; + } else { + containerBalance--; + } + atMarker = void 0; + } else if (event[1].type === "lineEndingBlank") { + if (event[0] === "enter") { + if (listItem2 && !atMarker && !containerBalance && !firstBlankLineIndex) { + firstBlankLineIndex = index; + } + atMarker = void 0; + } + } else if (event[1].type === "linePrefix" || event[1].type === "listItemValue" || event[1].type === "listItemMarker" || event[1].type === "listItemPrefix" || event[1].type === "listItemPrefixWhitespace") { + } else { + atMarker = void 0; + } + if (!containerBalance && event[0] === "enter" && event[1].type === "listItemPrefix" || containerBalance === -1 && event[0] === "exit" && (event[1].type === "listUnordered" || event[1].type === "listOrdered")) { + if (listItem2) { + tailIndex = index; + lineIndex = void 0; + while (tailIndex--) { + tailEvent = events[tailIndex]; + if (tailEvent[1].type === "lineEnding" || tailEvent[1].type === "lineEndingBlank") { + if (tailEvent[0] === "exit") + continue; + if (lineIndex) { + events[lineIndex][1].type = "lineEndingBlank"; + listSpread = true; + } + tailEvent[1].type = "lineEnding"; + lineIndex = tailIndex; + } else if (tailEvent[1].type === "linePrefix" || tailEvent[1].type === "blockQuotePrefix" || tailEvent[1].type === "blockQuotePrefixWhitespace" || tailEvent[1].type === "blockQuoteMarker" || tailEvent[1].type === "listItemIndent") { + } else { + break; + } + } + if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) { + listItem2._spread = true; + } + listItem2.end = point(lineIndex ? events[lineIndex][1].start : event[1].end); + events.splice(lineIndex || index, 0, ["exit", listItem2, event[2]]); + index++; + length++; + } + if (event[1].type === "listItemPrefix") { + listItem2 = { + type: "listItem", + _spread: false, + start: point(event[1].start) + }; + events.splice(index, 0, ["enter", listItem2, event[2]]); + index++; + length++; + firstBlankLineIndex = void 0; + atMarker = true; + } + } + } + events[start][1]._spread = listSpread; + return length; + } + function setData(key, value) { + data[key] = value; + } + function getData(key) { + return data[key]; + } + function point(d) { + return { line: d.line, column: d.column, offset: d.offset }; + } + function opener(create, and) { + return open; + function open(token) { + enter.call(this, create(token), token); + if (and) + and.call(this, token); + } + } + function buffer() { + this.stack.push({ type: "fragment", children: [] }); + } + function enter(node, token) { + this.stack[this.stack.length - 1].children.push(node); + this.stack.push(node); + this.tokenStack.push(token); + node.position = { start: point(token.start) }; + return node; + } + function closer(and) { + return close; + function close(token) { + if (and) + and.call(this, token); + exit.call(this, token); + } + } + function exit(token) { + var node = this.stack.pop(); + var open = this.tokenStack.pop(); + if (!open) { + throw new Error("Cannot close `" + token.type + "` (" + stringifyPosition({ start: token.start, end: token.end }) + "): it\u2019s not open"); + } else if (open.type !== token.type) { + throw new Error("Cannot close `" + token.type + "` (" + stringifyPosition({ start: token.start, end: token.end }) + "): a different token (`" + open.type + "`, " + stringifyPosition({ start: open.start, end: open.end }) + ") is open"); + } + node.position.end = point(token.end); + return node; + } + function resume() { + return toString(this.stack.pop()); + } + function onenterlistordered() { + setData("expectingFirstListItemValue", true); + } + function onenterlistitemvalue(token) { + if (getData("expectingFirstListItemValue")) { + this.stack[this.stack.length - 2].start = parseInt(this.sliceSerialize(token), 10); + setData("expectingFirstListItemValue"); + } + } + function onexitcodefencedfenceinfo() { + var data2 = this.resume(); + this.stack[this.stack.length - 1].lang = data2; + } + function onexitcodefencedfencemeta() { + var data2 = this.resume(); + this.stack[this.stack.length - 1].meta = data2; + } + function onexitcodefencedfence() { + if (getData("flowCodeInside")) + return; + this.buffer(); + setData("flowCodeInside", true); + } + function onexitcodefenced() { + var data2 = this.resume(); + this.stack[this.stack.length - 1].value = data2.replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, ""); + setData("flowCodeInside"); + } + function onexitcodeindented() { + var data2 = this.resume(); + this.stack[this.stack.length - 1].value = data2; + } + function onexitdefinitionlabelstring(token) { + var label = this.resume(); + this.stack[this.stack.length - 1].label = label; + this.stack[this.stack.length - 1].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase(); + } + function onexitdefinitiontitlestring() { + var data2 = this.resume(); + this.stack[this.stack.length - 1].title = data2; + } + function onexitdefinitiondestinationstring() { + var data2 = this.resume(); + this.stack[this.stack.length - 1].url = data2; + } + function onexitatxheadingsequence(token) { + if (!this.stack[this.stack.length - 1].depth) { + this.stack[this.stack.length - 1].depth = this.sliceSerialize(token).length; + } + } + function onexitsetextheadingtext() { + setData("setextHeadingSlurpLineEnding", true); + } + function onexitsetextheadinglinesequence(token) { + this.stack[this.stack.length - 1].depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2; + } + function onexitsetextheading() { + setData("setextHeadingSlurpLineEnding"); + } + function onenterdata(token) { + var siblings = this.stack[this.stack.length - 1].children; + var tail = siblings[siblings.length - 1]; + if (!tail || tail.type !== "text") { + tail = text(); + tail.position = { start: point(token.start) }; + this.stack[this.stack.length - 1].children.push(tail); + } + this.stack.push(tail); + } + function onexitdata(token) { + var tail = this.stack.pop(); + tail.value += this.sliceSerialize(token); + tail.position.end = point(token.end); + } + function onexitlineending(token) { + var context = this.stack[this.stack.length - 1]; + if (getData("atHardBreak")) { + context.children[context.children.length - 1].position.end = point(token.end); + setData("atHardBreak"); + return; + } + if (!getData("setextHeadingSlurpLineEnding") && config.canContainEols.indexOf(context.type) > -1) { + onenterdata.call(this, token); + onexitdata.call(this, token); + } + } + function onexithardbreak() { + setData("atHardBreak", true); + } + function onexithtmlflow() { + var data2 = this.resume(); + this.stack[this.stack.length - 1].value = data2; + } + function onexithtmltext() { + var data2 = this.resume(); + this.stack[this.stack.length - 1].value = data2; + } + function onexitcodetext() { + var data2 = this.resume(); + this.stack[this.stack.length - 1].value = data2; + } + function onexitlink() { + var context = this.stack[this.stack.length - 1]; + if (getData("inReference")) { + context.type += "Reference"; + context.referenceType = getData("referenceType") || "shortcut"; + delete context.url; + delete context.title; + } else { + delete context.identifier; + delete context.label; + delete context.referenceType; + } + setData("referenceType"); + } + function onexitimage() { + var context = this.stack[this.stack.length - 1]; + if (getData("inReference")) { + context.type += "Reference"; + context.referenceType = getData("referenceType") || "shortcut"; + delete context.url; + delete context.title; + } else { + delete context.identifier; + delete context.label; + delete context.referenceType; + } + setData("referenceType"); + } + function onexitlabeltext(token) { + this.stack[this.stack.length - 2].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase(); + } + function onexitlabel() { + var fragment = this.stack[this.stack.length - 1]; + var value = this.resume(); + this.stack[this.stack.length - 1].label = value; + setData("inReference", true); + if (this.stack[this.stack.length - 1].type === "link") { + this.stack[this.stack.length - 1].children = fragment.children; + } else { + this.stack[this.stack.length - 1].alt = value; + } + } + function onexitresourcedestinationstring() { + var data2 = this.resume(); + this.stack[this.stack.length - 1].url = data2; + } + function onexitresourcetitlestring() { + var data2 = this.resume(); + this.stack[this.stack.length - 1].title = data2; + } + function onexitresource() { + setData("inReference"); + } + function onenterreference() { + setData("referenceType", "collapsed"); + } + function onexitreferencestring(token) { + var label = this.resume(); + this.stack[this.stack.length - 1].label = label; + this.stack[this.stack.length - 1].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase(); + setData("referenceType", "full"); + } + function onexitcharacterreferencemarker(token) { + setData("characterReferenceType", token.type); + } + function onexitcharacterreferencevalue(token) { + var data2 = this.sliceSerialize(token); + var type = getData("characterReferenceType"); + var value; + var tail; + if (type) { + value = safeFromInt(data2, type === "characterReferenceMarkerNumeric" ? 10 : 16); + setData("characterReferenceType"); + } else { + value = decode(data2); + } + tail = this.stack.pop(); + tail.value += value; + tail.position.end = point(token.end); + } + function onexitautolinkprotocol(token) { + onexitdata.call(this, token); + this.stack[this.stack.length - 1].url = this.sliceSerialize(token); + } + function onexitautolinkemail(token) { + onexitdata.call(this, token); + this.stack[this.stack.length - 1].url = "mailto:" + this.sliceSerialize(token); + } + function blockQuote() { + return { type: "blockquote", children: [] }; + } + function codeFlow() { + return { type: "code", lang: null, meta: null, value: "" }; + } + function codeText() { + return { type: "inlineCode", value: "" }; + } + function definition() { + return { + type: "definition", + identifier: "", + label: null, + title: null, + url: "" + }; + } + function emphasis() { + return { type: "emphasis", children: [] }; + } + function heading() { + return { type: "heading", depth: void 0, children: [] }; + } + function hardBreak() { + return { type: "break" }; + } + function html() { + return { type: "html", value: "" }; + } + function image() { + return { type: "image", title: null, url: "", alt: null }; + } + function link() { + return { type: "link", title: null, url: "", children: [] }; + } + function list(token) { + return { + type: "list", + ordered: token.type === "listOrdered", + start: null, + spread: token._spread, + children: [] + }; + } + function listItem(token) { + return { + type: "listItem", + spread: token._spread, + checked: null, + children: [] + }; + } + function paragraph() { + return { type: "paragraph", children: [] }; + } + function strong() { + return { type: "strong", children: [] }; + } + function text() { + return { type: "text", value: "" }; + } + function thematicBreak() { + return { type: "thematicBreak" }; + } + } + function configure(config, extensions) { + var index = -1; + while (++index < extensions.length) { + extension(config, extensions[index]); + } + return config; + } + function extension(config, extension2) { + var key; + var left; + for (key in extension2) { + left = own.call(config, key) ? config[key] : config[key] = {}; + if (key === "canContainEols" || key === "transforms") { + config[key] = [].concat(left, extension2[key]); + } else { + Object.assign(left, extension2[key]); + } + } + } + } +}); + +// node_modules/mdast-util-from-markdown/index.js +var require_mdast_util_from_markdown = __commonJS({ + "node_modules/mdast-util-from-markdown/index.js"(exports, module2) { + "use strict"; + module2.exports = require_dist(); + } +}); + +// node_modules/remark-parse/index.js +var require_remark_parse = __commonJS({ + "node_modules/remark-parse/index.js"(exports, module2) { + "use strict"; + module2.exports = parse3; + var fromMarkdown = require_mdast_util_from_markdown(); + function parse3(options) { + var self = this; + this.Parser = parse4; + function parse4(doc) { + return fromMarkdown(doc, Object.assign({}, self.data("settings"), options, { + extensions: self.data("micromarkExtensions") || [], + mdastExtensions: self.data("fromMarkdownExtensions") || [] + })); + } + } + } +}); + +// node_modules/@tryfabric/martian/build/src/notion/languageMap.json +var require_languageMap = __commonJS({ + "node_modules/@tryfabric/martian/build/src/notion/languageMap.json"(exports, module2) { + module2.exports = { + abap: "abap", + sh: "shell", + "shell-script": "shell", + bash: "shell", + zsh: "shell", + text: "vb.net", + c_cpp: "c++", + clojure: "clojure", + coffee: "coffeescript", + "coffee-script": "coffeescript", + cpp: "c++", + csharp: "c#", + cake: "c#", + cakescript: "c#", + css: "css", + dart: "dart", + diff: "diff", + udiff: "diff", + dockerfile: "docker", + elixir: "elixir", + elm: "elm", + erlang: "erlang", + fsharp: "f#", + cucumber: "gherkin", + glsl: "glsl", + golang: "go", + groovy: "groovy", + haskell: "haskell", + html: "html", + xhtml: "html", + java: "java/c/c++/c#", + javascript: "javascript", + js: "javascript", + node: "javascript", + json: "json", + julia: "julia", + tex: "latex", + latex: "latex", + less: "less", + lisp: "webassembly", + livescript: "livescript", + "live-script": "livescript", + ls: "livescript", + lua: "lua", + makefile: "makefile", + bsdmake: "makefile", + make: "makefile", + mf: "makefile", + markdown: "markdown", + pandoc: "markdown", + matlab: "matlab", + octave: "matlab", + nix: "nix", + nixos: "nix", + objectivec: "objective-c", + "obj-c": "objective-c", + objc: "objective-c", + ocaml: "ocaml", + pascal: "pascal", + delphi: "pascal", + objectpascal: "pascal", + perl: "perl", + cperl: "perl", + php: "php", + inc: "php", + powershell: "powershell", + posh: "powershell", + pwsh: "powershell", + prolog: "prolog", + protobuf: "protobuf", + "Protocol Buffers": "protobuf", + python: "python", + python3: "python", + rusthon: "python", + r: "r", + R: "r", + Rscript: "r", + splus: "r", + rust: "rust", + ruby: "ruby", + jruby: "ruby", + macruby: "ruby", + rake: "ruby", + rb: "ruby", + rbx: "ruby", + rs: "rust", + sass: "sass", + scala: "scala", + scheme: "scheme", + scss: "scss", + sql: "sql", + typescript: "typescript", + ts: "typescript", + "visual basic": "vb.net", + vbnet: "vb.net", + "vb .net": "vb.net", + "vb.net": "vb.net", + verilog: "verilog", + vhdl: "vhdl", + wast: "webassembly", + wasm: "webassembly", + xml: "xml", + rss: "xml", + xsd: "xml", + wsdl: "xml", + yaml: "yaml", + yml: "yaml" + }; + } +}); + +// node_modules/@tryfabric/martian/build/src/notion/blocks.js +var require_blocks = __commonJS({ + "node_modules/@tryfabric/martian/build/src/notion/blocks.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.tableRow = exports.table = exports.toDo = exports.numberedListItem = exports.bulletedListItem = exports.headingThree = exports.headingTwo = exports.headingOne = exports.table_of_contents = exports.image = exports.blockquote = exports.code = exports.paragraph = void 0; + function paragraph(text) { + return { + object: "block", + type: "paragraph", + paragraph: { + rich_text: text + } + }; + } + exports.paragraph = paragraph; + function code(text, lang = "plain text") { + return { + object: "block", + type: "code", + code: { + rich_text: text, + language: lang + } + }; + } + exports.code = code; + function blockquote(text) { + return { + object: "block", + type: "quote", + quote: { + rich_text: text + } + }; + } + exports.blockquote = blockquote; + function image(url) { + return { + object: "block", + type: "image", + image: { + type: "external", + external: { + url + } + } + }; + } + exports.image = image; + function table_of_contents() { + return { + object: "block", + type: "table_of_contents", + table_of_contents: {} + }; + } + exports.table_of_contents = table_of_contents; + function headingOne(text) { + return { + object: "block", + type: "heading_1", + heading_1: { + rich_text: text + } + }; + } + exports.headingOne = headingOne; + function headingTwo(text) { + return { + object: "block", + type: "heading_2", + heading_2: { + rich_text: text + } + }; + } + exports.headingTwo = headingTwo; + function headingThree(text) { + return { + object: "block", + type: "heading_3", + heading_3: { + rich_text: text + } + }; + } + exports.headingThree = headingThree; + function bulletedListItem(text, children = []) { + return { + object: "block", + type: "bulleted_list_item", + bulleted_list_item: { + rich_text: text, + children: children.length ? children : void 0 + } + }; + } + exports.bulletedListItem = bulletedListItem; + function numberedListItem(text, children = []) { + return { + object: "block", + type: "numbered_list_item", + numbered_list_item: { + rich_text: text, + children: children.length ? children : void 0 + } + }; + } + exports.numberedListItem = numberedListItem; + function toDo(checked, text, children = []) { + return { + object: "block", + type: "to_do", + to_do: { + rich_text: text, + checked, + children: children.length ? children : void 0 + } + }; + } + exports.toDo = toDo; + function table(children, tableWidth) { + return { + object: "block", + type: "table", + table: { + table_width: tableWidth, + has_row_header: true, + children: (children === null || children === void 0 ? void 0 : children.length) ? children : [] + } + }; + } + exports.table = table; + function tableRow(cells = []) { + return { + object: "block", + type: "table_row", + table_row: { + cells: cells.length ? cells : [] + } + }; + } + exports.tableRow = tableRow; + } +}); + +// node_modules/@tryfabric/martian/build/src/notion/common.js +var require_common = __commonJS({ + "node_modules/@tryfabric/martian/build/src/notion/common.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isSupportedCodeLang = exports.SUPPORTED_CODE_BLOCK_LANGUAGES = exports.richText = exports.LIMITS = void 0; + exports.LIMITS = { + PAYLOAD_BLOCKS: 1e3, + RICH_TEXT_ARRAYS: 100, + RICH_TEXT: { + TEXT_CONTENT: 2e3, + LINK_URL: 1e3, + EQUATION_EXPRESSION: 1e3 + } + }; + function richText(content, options = {}) { + var _a; + const annotations = (_a = options.annotations) !== null && _a !== void 0 ? _a : {}; + return { + type: "text", + annotations: __spreadValues({ + bold: false, + strikethrough: false, + underline: false, + italic: false, + code: false, + color: "default" + }, annotations), + text: { + content, + link: options.url ? { + type: "url", + url: options.url + } : void 0 + } + }; + } + exports.richText = richText; + exports.SUPPORTED_CODE_BLOCK_LANGUAGES = [ + "abap", + "arduino", + "bash", + "basic", + "c", + "clojure", + "coffeescript", + "c++", + "c#", + "css", + "dart", + "diff", + "docker", + "elixir", + "elm", + "erlang", + "flow", + "fortran", + "f#", + "gherkin", + "glsl", + "go", + "graphql", + "groovy", + "haskell", + "html", + "java", + "javascript", + "json", + "julia", + "kotlin", + "latex", + "less", + "lisp", + "livescript", + "lua", + "makefile", + "markdown", + "markup", + "matlab", + "mermaid", + "nix", + "objective-c", + "ocaml", + "pascal", + "perl", + "php", + "plain text", + "powershell", + "prolog", + "protobuf", + "python", + "r", + "reason", + "ruby", + "rust", + "sass", + "scala", + "scheme", + "scss", + "shell", + "sql", + "swift", + "typescript", + "vb.net", + "verilog", + "vhdl", + "visual basic", + "webassembly", + "xml", + "yaml", + "java/c/c++/c#" + ]; + function isSupportedCodeLang(lang) { + return exports.SUPPORTED_CODE_BLOCK_LANGUAGES.includes(lang); + } + exports.isSupportedCodeLang = isSupportedCodeLang; + } +}); + +// node_modules/@tryfabric/martian/build/src/notion/index.js +var require_notion = __commonJS({ + "node_modules/@tryfabric/martian/build/src/notion/index.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __exportStar = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) + if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) + __createBinding(exports2, m, p); + }; + var __importDefault = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.parseCodeLanguage = void 0; + var languageMap_json_1 = __importDefault(require_languageMap()); + __exportStar(require_blocks(), exports); + __exportStar(require_common(), exports); + function parseCodeLanguage(lang) { + return lang ? languageMap_json_1.default[lang.toLowerCase()] : void 0; + } + exports.parseCodeLanguage = parseCodeLanguage; + } +}); + +// node_modules/@tryfabric/martian/build/src/parser/internal.js +var require_internal = __commonJS({ + "node_modules/@tryfabric/martian/build/src/parser/internal.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding(result, mod, k); + } + __setModuleDefault(result, mod); + return result; + }; + var __importDefault = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.parseRichText = exports.parseBlocks = void 0; + var notion = __importStar(require_notion()); + var path_1 = __importDefault(require("path")); + var url_1 = require("url"); + var notion_1 = require_notion(); + function ensureLength(text, copy) { + const chunks = text.match(/[^]{1,2000}/g) || []; + return chunks.flatMap((item) => notion.richText(item, copy)); + } + function ensureCodeBlockLanguage(lang) { + if (lang) { + lang = lang.toLowerCase(); + return (0, notion_1.isSupportedCodeLang)(lang) ? lang : notion.parseCodeLanguage(lang); + } + return void 0; + } + function parseInline(element, options) { + var _a; + const copy = { + annotations: __spreadValues({}, (_a = options === null || options === void 0 ? void 0 : options.annotations) !== null && _a !== void 0 ? _a : {}), + url: options === null || options === void 0 ? void 0 : options.url + }; + switch (element.type) { + case "text": + return ensureLength(element.value, copy); + case "delete": + copy.annotations.strikethrough = true; + return element.children.flatMap((child) => parseInline(child, copy)); + case "emphasis": + copy.annotations.italic = true; + return element.children.flatMap((child) => parseInline(child, copy)); + case "strong": + copy.annotations.bold = true; + return element.children.flatMap((child) => parseInline(child, copy)); + case "link": + copy.url = element.url; + return element.children.flatMap((child) => parseInline(child, copy)); + case "inlineCode": + copy.annotations.code = true; + return [notion.richText(element.value, copy)]; + default: + return []; + } + } + function parseImage(image, options) { + var _a; + const allowedTypes = [ + ".png", + ".jpg", + ".jpeg", + ".gif", + ".tif", + ".tiff", + ".bmp", + ".svg", + ".heic" + ]; + function dealWithError() { + return notion.paragraph([notion.richText(image.url)]); + } + try { + if ((_a = options.strictImageUrls) !== null && _a !== void 0 ? _a : true) { + const parsedUrl = new url_1.URL(image.url); + const fileType = path_1.default.extname(parsedUrl.pathname); + if (allowedTypes.includes(fileType)) { + return notion.image(image.url); + } else { + return dealWithError(); + } + } else { + return notion.image(image.url); + } + } catch (error) { + return dealWithError(); + } + } + function parseParagraph(element, options) { + const mightBeToc = element.children.length > 2 && element.children[0].type === "text" && element.children[0].value === "[[" && element.children[1].type === "emphasis"; + if (mightBeToc) { + const emphasisItem = element.children[1]; + const emphasisTextItem = emphasisItem.children[0]; + if (emphasisTextItem.value === "TOC") { + return [notion.table_of_contents()]; + } + } + const images = []; + const paragraphs = []; + element.children.forEach((item) => { + if (item.type === "image") { + images.push(parseImage(item, options)); + } else { + const richText = parseInline(item); + if (richText.length) { + paragraphs.push(richText); + } + } + }); + if (paragraphs.length) { + return [notion.paragraph(paragraphs.flat()), ...images]; + } else { + return images; + } + } + function parseBlockquote(element, options) { + const blocks = element.children.flatMap((child) => parseNode(child, options)); + const paragraphs = blocks.flatMap((child) => child); + const richtext = paragraphs.flatMap((child) => { + if (child.type === "paragraph") { + return child.paragraph.rich_text; + } + if (child.type === "heading_1") { + return child.heading_1.rich_text; + } + if (child.type === "heading_2") { + return child.heading_2.rich_text; + } + if (child.type === "heading_3") { + return child.heading_3.rich_text; + } + return []; + }); + return notion.blockquote(richtext); + } + function parseHeading(element) { + const text = element.children.flatMap((child) => parseInline(child)); + switch (element.depth) { + case 1: + return notion.headingOne(text); + case 2: + return notion.headingTwo(text); + default: + return notion.headingThree(text); + } + } + function parseCode(element) { + const text = ensureLength(element.value); + const lang = ensureCodeBlockLanguage(element.lang); + return notion.code(text, lang); + } + function parseList(element, options) { + return element.children.flatMap((item) => { + const paragraph = item.children.shift(); + if (paragraph === void 0 || paragraph.type !== "paragraph") { + return []; + } + const text = paragraph.children.flatMap((child) => parseInline(child)); + const parsedChildren = item.children.flatMap((child) => parseNode(child, options)); + if (element.start !== null && element.start !== void 0) { + return [notion.numberedListItem(text, parsedChildren)]; + } else if (item.checked !== null && item.checked !== void 0) { + return [notion.toDo(item.checked, text, parsedChildren)]; + } else { + return [notion.bulletedListItem(text, parsedChildren)]; + } + }); + } + function parseTableCell(node) { + return [node.children.flatMap((child) => parseInline(child))]; + } + function parseTableRow(node) { + const tableCells = node.children.flatMap((child) => parseTableCell(child)); + return [notion.tableRow(tableCells)]; + } + function parseTable(node) { + var _a; + const tableWidth = ((_a = node.children) === null || _a === void 0 ? void 0 : _a.length) ? node.children[0].children.length : 0; + const tableRows = node.children.flatMap((child) => parseTableRow(child)); + return [notion.table(tableRows, tableWidth)]; + } + function parseNode(node, options) { + switch (node.type) { + case "heading": + return [parseHeading(node)]; + case "paragraph": + return parseParagraph(node, options); + case "code": + return [parseCode(node)]; + case "blockquote": + return [parseBlockquote(node, options)]; + case "list": + return parseList(node, options); + case "table": + if (options.allowUnsupported) { + return parseTable(node); + } else { + return []; + } + default: + return []; + } + } + function parseBlocks(root, options) { + var _a, _b, _c, _d; + const parsed = root.children.flatMap((item) => parseNode(item, options || {})); + const truncate = !!((_b = (_a = options === null || options === void 0 ? void 0 : options.notionLimits) === null || _a === void 0 ? void 0 : _a.truncate) !== null && _b !== void 0 ? _b : true), limitCallback = (_d = (_c = options === null || options === void 0 ? void 0 : options.notionLimits) === null || _c === void 0 ? void 0 : _c.onError) !== null && _d !== void 0 ? _d : () => { + }; + if (parsed.length > notion_1.LIMITS.PAYLOAD_BLOCKS) + limitCallback(new Error(`Resulting blocks array exceeds Notion limit (${notion_1.LIMITS.PAYLOAD_BLOCKS})`)); + return truncate ? parsed.slice(0, notion_1.LIMITS.PAYLOAD_BLOCKS) : parsed; + } + exports.parseBlocks = parseBlocks; + function parseRichText(root, options) { + var _a, _b, _c, _d; + if (root.children[0].type !== "paragraph") { + throw new Error(`Unsupported markdown element: ${JSON.stringify(root)}`); + } + const richTexts = []; + root.children.forEach((paragraph) => { + if (paragraph.type === "paragraph") { + paragraph.children.forEach((child) => richTexts.push(...parseInline(child))); + } + }); + const truncate = !!((_b = (_a = options === null || options === void 0 ? void 0 : options.notionLimits) === null || _a === void 0 ? void 0 : _a.truncate) !== null && _b !== void 0 ? _b : true), limitCallback = (_d = (_c = options === null || options === void 0 ? void 0 : options.notionLimits) === null || _c === void 0 ? void 0 : _c.onError) !== null && _d !== void 0 ? _d : () => { + }; + if (richTexts.length > notion_1.LIMITS.RICH_TEXT_ARRAYS) + limitCallback(new Error(`Resulting richTexts array exceeds Notion limit (${notion_1.LIMITS.RICH_TEXT_ARRAYS})`)); + return (truncate ? richTexts.slice(0, notion_1.LIMITS.RICH_TEXT_ARRAYS) : richTexts).map((rt) => { + var _a2; + if (rt.type !== "text") + return rt; + if (rt.text.content.length > notion_1.LIMITS.RICH_TEXT.TEXT_CONTENT) { + limitCallback(new Error(`Resulting text content exceeds Notion limit (${notion_1.LIMITS.RICH_TEXT.TEXT_CONTENT})`)); + if (truncate) + rt.text.content = rt.text.content.slice(0, notion_1.LIMITS.RICH_TEXT.TEXT_CONTENT - 3) + "..."; + } + if (((_a2 = rt.text.link) === null || _a2 === void 0 ? void 0 : _a2.url) && rt.text.link.url.length > notion_1.LIMITS.RICH_TEXT.LINK_URL) + limitCallback(new Error(`Resulting text URL exceeds Notion limit (${notion_1.LIMITS.RICH_TEXT.LINK_URL})`)); + return rt; + }); + } + exports.parseRichText = parseRichText; + } +}); + +// node_modules/micromark-extension-gfm-autolink-literal/syntax.js +var require_syntax = __commonJS({ + "node_modules/micromark-extension-gfm-autolink-literal/syntax.js"(exports) { + var asciiAlpha = require_ascii_alpha(); + var asciiAlphanumeric = require_ascii_alphanumeric(); + var asciiControl = require_ascii_control(); + var markdownLineEnding = require_markdown_line_ending(); + var unicodePunctuation = require_unicode_punctuation(); + var unicodeWhitespace = require_unicode_whitespace(); + var www = { tokenize: tokenizeWww, partial: true }; + var domain = { tokenize: tokenizeDomain, partial: true }; + var path = { tokenize: tokenizePath, partial: true }; + var punctuation = { tokenize: tokenizePunctuation, partial: true }; + var namedCharacterReference = { + tokenize: tokenizeNamedCharacterReference, + partial: true + }; + var wwwAutolink = { tokenize: tokenizeWwwAutolink, previous: previousWww }; + var httpAutolink = { tokenize: tokenizeHttpAutolink, previous: previousHttp }; + var emailAutolink = { tokenize: tokenizeEmailAutolink, previous: previousEmail }; + var text = {}; + exports.text = text; + var code = 48; + while (code < 123) { + text[code] = emailAutolink; + code++; + if (code === 58) + code = 65; + else if (code === 91) + code = 97; + } + text[43] = emailAutolink; + text[45] = emailAutolink; + text[46] = emailAutolink; + text[95] = emailAutolink; + text[72] = [emailAutolink, httpAutolink]; + text[104] = [emailAutolink, httpAutolink]; + text[87] = [emailAutolink, wwwAutolink]; + text[119] = [emailAutolink, wwwAutolink]; + function tokenizeEmailAutolink(effects, ok, nok) { + var self = this; + var hasDot; + return start; + function start(code2) { + if (!gfmAtext(code2) || !previousEmail(self.previous) || previous(self.events)) { + return nok(code2); + } + effects.enter("literalAutolink"); + effects.enter("literalAutolinkEmail"); + return atext(code2); + } + function atext(code2) { + if (gfmAtext(code2)) { + effects.consume(code2); + return atext; + } + if (code2 === 64) { + effects.consume(code2); + return label; + } + return nok(code2); + } + function label(code2) { + if (code2 === 46) { + return effects.check(punctuation, done, dotContinuation)(code2); + } + if (code2 === 45 || code2 === 95) { + return effects.check(punctuation, nok, dashOrUnderscoreContinuation)(code2); + } + if (asciiAlphanumeric(code2)) { + effects.consume(code2); + return label; + } + return done(code2); + } + function dotContinuation(code2) { + effects.consume(code2); + hasDot = true; + return label; + } + function dashOrUnderscoreContinuation(code2) { + effects.consume(code2); + return afterDashOrUnderscore; + } + function afterDashOrUnderscore(code2) { + if (code2 === 46) { + return effects.check(punctuation, nok, dotContinuation)(code2); + } + return label(code2); + } + function done(code2) { + if (hasDot) { + effects.exit("literalAutolinkEmail"); + effects.exit("literalAutolink"); + return ok(code2); + } + return nok(code2); + } + } + function tokenizeWwwAutolink(effects, ok, nok) { + var self = this; + return start; + function start(code2) { + if (code2 !== 87 && code2 - 32 !== 87 || !previousWww(self.previous) || previous(self.events)) { + return nok(code2); + } + effects.enter("literalAutolink"); + effects.enter("literalAutolinkWww"); + return effects.check(www, effects.attempt(domain, effects.attempt(path, done), nok), nok)(code2); + } + function done(code2) { + effects.exit("literalAutolinkWww"); + effects.exit("literalAutolink"); + return ok(code2); + } + } + function tokenizeHttpAutolink(effects, ok, nok) { + var self = this; + return start; + function start(code2) { + if (code2 !== 72 && code2 - 32 !== 72 || !previousHttp(self.previous) || previous(self.events)) { + return nok(code2); + } + effects.enter("literalAutolink"); + effects.enter("literalAutolinkHttp"); + effects.consume(code2); + return t1; + } + function t1(code2) { + if (code2 === 84 || code2 - 32 === 84) { + effects.consume(code2); + return t2; + } + return nok(code2); + } + function t2(code2) { + if (code2 === 84 || code2 - 32 === 84) { + effects.consume(code2); + return p; + } + return nok(code2); + } + function p(code2) { + if (code2 === 80 || code2 - 32 === 80) { + effects.consume(code2); + return s; + } + return nok(code2); + } + function s(code2) { + if (code2 === 83 || code2 - 32 === 83) { + effects.consume(code2); + return colon; + } + return colon(code2); + } + function colon(code2) { + if (code2 === 58) { + effects.consume(code2); + return slash1; + } + return nok(code2); + } + function slash1(code2) { + if (code2 === 47) { + effects.consume(code2); + return slash2; + } + return nok(code2); + } + function slash2(code2) { + if (code2 === 47) { + effects.consume(code2); + return after; + } + return nok(code2); + } + function after(code2) { + return asciiControl(code2) || unicodeWhitespace(code2) || unicodePunctuation(code2) ? nok(code2) : effects.attempt(domain, effects.attempt(path, done), nok)(code2); + } + function done(code2) { + effects.exit("literalAutolinkHttp"); + effects.exit("literalAutolink"); + return ok(code2); + } + } + function tokenizeWww(effects, ok, nok) { + return start; + function start(code2) { + effects.consume(code2); + return w2; + } + function w2(code2) { + if (code2 === 87 || code2 - 32 === 87) { + effects.consume(code2); + return w3; + } + return nok(code2); + } + function w3(code2) { + if (code2 === 87 || code2 - 32 === 87) { + effects.consume(code2); + return dot; + } + return nok(code2); + } + function dot(code2) { + if (code2 === 46) { + effects.consume(code2); + return after; + } + return nok(code2); + } + function after(code2) { + return code2 === null || markdownLineEnding(code2) ? nok(code2) : ok(code2); + } + } + function tokenizeDomain(effects, ok, nok) { + var hasUnderscoreInLastSegment; + var hasUnderscoreInLastLastSegment; + return domain2; + function domain2(code2) { + if (code2 === 38) { + return effects.check(namedCharacterReference, done, punctuationContinuation)(code2); + } + if (code2 === 46 || code2 === 95) { + return effects.check(punctuation, done, punctuationContinuation)(code2); + } + if (asciiControl(code2) || unicodeWhitespace(code2) || code2 !== 45 && unicodePunctuation(code2)) { + return done(code2); + } + effects.consume(code2); + return domain2; + } + function punctuationContinuation(code2) { + if (code2 === 46) { + hasUnderscoreInLastLastSegment = hasUnderscoreInLastSegment; + hasUnderscoreInLastSegment = void 0; + effects.consume(code2); + return domain2; + } + if (code2 === 95) + hasUnderscoreInLastSegment = true; + effects.consume(code2); + return domain2; + } + function done(code2) { + if (!hasUnderscoreInLastLastSegment && !hasUnderscoreInLastSegment) { + return ok(code2); + } + return nok(code2); + } + } + function tokenizePath(effects, ok) { + var balance = 0; + return inPath; + function inPath(code2) { + if (code2 === 38) { + return effects.check(namedCharacterReference, ok, continuedPunctuation)(code2); + } + if (code2 === 40) { + balance++; + } + if (code2 === 41) { + return effects.check(punctuation, parenAtPathEnd, continuedPunctuation)(code2); + } + if (pathEnd(code2)) { + return ok(code2); + } + if (trailingPunctuation(code2)) { + return effects.check(punctuation, ok, continuedPunctuation)(code2); + } + effects.consume(code2); + return inPath; + } + function continuedPunctuation(code2) { + effects.consume(code2); + return inPath; + } + function parenAtPathEnd(code2) { + balance--; + return balance < 0 ? ok(code2) : continuedPunctuation(code2); + } + } + function tokenizeNamedCharacterReference(effects, ok, nok) { + return start; + function start(code2) { + effects.consume(code2); + return inside; + } + function inside(code2) { + if (asciiAlpha(code2)) { + effects.consume(code2); + return inside; + } + if (code2 === 59) { + effects.consume(code2); + return after; + } + return nok(code2); + } + function after(code2) { + return pathEnd(code2) ? ok(code2) : nok(code2); + } + } + function tokenizePunctuation(effects, ok, nok) { + return start; + function start(code2) { + effects.consume(code2); + return after; + } + function after(code2) { + if (trailingPunctuation(code2)) { + effects.consume(code2); + return after; + } + return pathEnd(code2) ? ok(code2) : nok(code2); + } + } + function trailingPunctuation(code2) { + return code2 === 33 || code2 === 34 || code2 === 39 || code2 === 41 || code2 === 42 || code2 === 44 || code2 === 46 || code2 === 58 || code2 === 59 || code2 === 60 || code2 === 63 || code2 === 95 || code2 === 126; + } + function pathEnd(code2) { + return code2 === null || code2 < 0 || code2 === 32 || code2 === 60; + } + function gfmAtext(code2) { + return code2 === 43 || code2 === 45 || code2 === 46 || code2 === 95 || asciiAlphanumeric(code2); + } + function previousWww(code2) { + return code2 === null || code2 < 0 || code2 === 32 || code2 === 40 || code2 === 42 || code2 === 95 || code2 === 126; + } + function previousHttp(code2) { + return code2 === null || !asciiAlpha(code2); + } + function previousEmail(code2) { + return code2 !== 47 && previousHttp(code2); + } + function previous(events) { + var index = events.length; + while (index--) { + if ((events[index][1].type === "labelLink" || events[index][1].type === "labelImage") && !events[index][1]._balanced) { + return true; + } + } + } + } +}); + +// node_modules/micromark-extension-gfm-autolink-literal/index.js +var require_micromark_extension_gfm_autolink_literal = __commonJS({ + "node_modules/micromark-extension-gfm-autolink-literal/index.js"(exports, module2) { + module2.exports = require_syntax(); + } +}); + +// node_modules/micromark-extension-gfm-strikethrough/index.js +var require_micromark_extension_gfm_strikethrough = __commonJS({ + "node_modules/micromark-extension-gfm-strikethrough/index.js"(exports, module2) { + module2.exports = create; + var classifyCharacter = require_classify_character(); + var chunkedSplice = require_chunked_splice(); + var resolveAll = require_resolve_all(); + var shallow = require_shallow(); + function create(options) { + var settings = options || {}; + var single = settings.singleTilde; + var tokenizer = { + tokenize: tokenizeStrikethrough, + resolveAll: resolveAllStrikethrough + }; + if (single === null || single === void 0) { + single = true; + } + return { text: { 126: tokenizer }, insideSpan: { null: tokenizer } }; + function resolveAllStrikethrough(events, context) { + var index = -1; + var strikethrough; + var text; + var open; + var nextEvents; + while (++index < events.length) { + if (events[index][0] === "enter" && events[index][1].type === "strikethroughSequenceTemporary" && events[index][1]._close) { + open = index; + while (open--) { + if (events[open][0] === "exit" && events[open][1].type === "strikethroughSequenceTemporary" && events[open][1]._open && events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) { + events[index][1].type = "strikethroughSequence"; + events[open][1].type = "strikethroughSequence"; + strikethrough = { + type: "strikethrough", + start: shallow(events[open][1].start), + end: shallow(events[index][1].end) + }; + text = { + type: "strikethroughText", + start: shallow(events[open][1].end), + end: shallow(events[index][1].start) + }; + nextEvents = [ + ["enter", strikethrough, context], + ["enter", events[open][1], context], + ["exit", events[open][1], context], + ["enter", text, context] + ]; + chunkedSplice(nextEvents, nextEvents.length, 0, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context)); + chunkedSplice(nextEvents, nextEvents.length, 0, [ + ["exit", text, context], + ["enter", events[index][1], context], + ["exit", events[index][1], context], + ["exit", strikethrough, context] + ]); + chunkedSplice(events, open - 1, index - open + 3, nextEvents); + index = open + nextEvents.length - 2; + break; + } + } + } + } + return removeRemainingSequences(events); + } + function removeRemainingSequences(events) { + var index = -1; + var length = events.length; + while (++index < length) { + if (events[index][1].type === "strikethroughSequenceTemporary") { + events[index][1].type = "data"; + } + } + return events; + } + function tokenizeStrikethrough(effects, ok, nok) { + var previous = this.previous; + var events = this.events; + var size = 0; + return start; + function start(code) { + if (code !== 126 || previous === 126 && events[events.length - 1][1].type !== "characterEscape") { + return nok(code); + } + effects.enter("strikethroughSequenceTemporary"); + return more(code); + } + function more(code) { + var before = classifyCharacter(previous); + var token; + var after; + if (code === 126) { + if (size > 1) + return nok(code); + effects.consume(code); + size++; + return more; + } + if (size < 2 && !single) + return nok(code); + token = effects.exit("strikethroughSequenceTemporary"); + after = classifyCharacter(code); + token._open = !after || after === 2 && before; + token._close = !before || before === 2 && after; + return ok(code); + } + } + } + } +}); + +// node_modules/micromark-extension-gfm-table/syntax.js +var require_syntax2 = __commonJS({ + "node_modules/micromark-extension-gfm-table/syntax.js"(exports) { + exports.flow = { + null: { tokenize: tokenizeTable, resolve: resolveTable, interruptible: true } + }; + var createSpace = require_factory_space(); + var setextUnderlineMini = { tokenize: tokenizeSetextUnderlineMini, partial: true }; + var nextPrefixedOrBlank = { tokenize: tokenizeNextPrefixedOrBlank, partial: true }; + function resolveTable(events, context) { + var length = events.length; + var index = -1; + var token; + var inHead; + var inDelimiterRow; + var inRow; + var cell; + var content; + var text; + var contentStart; + var contentEnd; + var cellStart; + while (++index < length) { + token = events[index][1]; + if (inRow) { + if (token.type === "temporaryTableCellContent") { + contentStart = contentStart || index; + contentEnd = index; + } + if ((token.type === "tableCellDivider" || token.type === "tableRow") && contentEnd) { + content = { + type: "tableContent", + start: events[contentStart][1].start, + end: events[contentEnd][1].end + }; + text = { + type: "chunkText", + start: content.start, + end: content.end, + contentType: "text" + }; + events.splice(contentStart, contentEnd - contentStart + 1, ["enter", content, context], ["enter", text, context], ["exit", text, context], ["exit", content, context]); + index -= contentEnd - contentStart - 3; + length = events.length; + contentStart = void 0; + contentEnd = void 0; + } + } + if (events[index][0] === "exit" && cellStart && cellStart + 1 < index && (token.type === "tableCellDivider" || token.type === "tableRow" && (cellStart + 3 < index || events[cellStart][1].type !== "whitespace"))) { + cell = { + type: inDelimiterRow ? "tableDelimiter" : inHead ? "tableHeader" : "tableData", + start: events[cellStart][1].start, + end: events[index][1].end + }; + events.splice(index + (token.type === "tableCellDivider" ? 1 : 0), 0, [ + "exit", + cell, + context + ]); + events.splice(cellStart, 0, ["enter", cell, context]); + index += 2; + length = events.length; + cellStart = index + 1; + } + if (token.type === "tableRow") { + inRow = events[index][0] === "enter"; + if (inRow) { + cellStart = index + 1; + } + } + if (token.type === "tableDelimiterRow") { + inDelimiterRow = events[index][0] === "enter"; + if (inDelimiterRow) { + cellStart = index + 1; + } + } + if (token.type === "tableHead") { + inHead = events[index][0] === "enter"; + } + } + return events; + } + function tokenizeTable(effects, ok, nok) { + var align = []; + var tableHeaderCount = 0; + var seenDelimiter; + var hasDash; + return start; + function start(code) { + if (code === null || code === -5 || code === -4 || code === -3) { + return nok(code); + } + effects.enter("table")._align = align; + effects.enter("tableHead"); + effects.enter("tableRow"); + if (code === 124) { + return cellDividerHead(code); + } + tableHeaderCount++; + effects.enter("temporaryTableCellContent"); + return inCellContentHead(code); + } + function cellDividerHead(code) { + effects.enter("tableCellDivider"); + effects.consume(code); + effects.exit("tableCellDivider"); + seenDelimiter = true; + return cellBreakHead; + } + function cellBreakHead(code) { + if (code === null || code === -5 || code === -4 || code === -3) { + return atRowEndHead(code); + } + if (code === -2 || code === -1 || code === 32) { + effects.enter("whitespace"); + effects.consume(code); + return inWhitespaceHead; + } + if (seenDelimiter) { + seenDelimiter = void 0; + tableHeaderCount++; + } + if (code === 124) { + return cellDividerHead(code); + } + effects.enter("temporaryTableCellContent"); + return inCellContentHead(code); + } + function inWhitespaceHead(code) { + if (code === -2 || code === -1 || code === 32) { + effects.consume(code); + return inWhitespaceHead; + } + effects.exit("whitespace"); + return cellBreakHead(code); + } + function inCellContentHead(code) { + if (code === null || code < 0 || code === 32 || code === 124) { + effects.exit("temporaryTableCellContent"); + return cellBreakHead(code); + } + effects.consume(code); + return code === 92 ? inCellContentEscapeHead : inCellContentHead; + } + function inCellContentEscapeHead(code) { + if (code === 92 || code === 124) { + effects.consume(code); + return inCellContentHead; + } + return inCellContentHead(code); + } + function atRowEndHead(code) { + if (code === null) { + return nok(code); + } + effects.exit("tableRow"); + effects.exit("tableHead"); + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + return effects.check(setextUnderlineMini, nok, createSpace(effects, rowStartDelimiter, "linePrefix", 4)); + } + function rowStartDelimiter(code) { + if (code === null || code < 0 || code === 32) { + return nok(code); + } + effects.enter("tableDelimiterRow"); + return atDelimiterRowBreak(code); + } + function atDelimiterRowBreak(code) { + if (code === null || code === -5 || code === -4 || code === -3) { + return rowEndDelimiter(code); + } + if (code === -2 || code === -1 || code === 32) { + effects.enter("whitespace"); + effects.consume(code); + return inWhitespaceDelimiter; + } + if (code === 45) { + effects.enter("tableDelimiterFiller"); + effects.consume(code); + hasDash = true; + align.push(null); + return inFillerDelimiter; + } + if (code === 58) { + effects.enter("tableDelimiterAlignment"); + effects.consume(code); + effects.exit("tableDelimiterAlignment"); + align.push("left"); + return afterLeftAlignment; + } + if (code === 124) { + effects.enter("tableCellDivider"); + effects.consume(code); + effects.exit("tableCellDivider"); + return atDelimiterRowBreak; + } + return nok(code); + } + function inWhitespaceDelimiter(code) { + if (code === -2 || code === -1 || code === 32) { + effects.consume(code); + return inWhitespaceDelimiter; + } + effects.exit("whitespace"); + return atDelimiterRowBreak(code); + } + function inFillerDelimiter(code) { + if (code === 45) { + effects.consume(code); + return inFillerDelimiter; + } + effects.exit("tableDelimiterFiller"); + if (code === 58) { + effects.enter("tableDelimiterAlignment"); + effects.consume(code); + effects.exit("tableDelimiterAlignment"); + align[align.length - 1] = align[align.length - 1] === "left" ? "center" : "right"; + return afterRightAlignment; + } + return atDelimiterRowBreak(code); + } + function afterLeftAlignment(code) { + if (code === 45) { + effects.enter("tableDelimiterFiller"); + effects.consume(code); + hasDash = true; + return inFillerDelimiter; + } + return nok(code); + } + function afterRightAlignment(code) { + if (code === null || code === -5 || code === -4 || code === -3) { + return rowEndDelimiter(code); + } + if (code === -2 || code === -1 || code === 32) { + effects.enter("whitespace"); + effects.consume(code); + return inWhitespaceDelimiter; + } + if (code === 124) { + effects.enter("tableCellDivider"); + effects.consume(code); + effects.exit("tableCellDivider"); + return atDelimiterRowBreak; + } + return nok(code); + } + function rowEndDelimiter(code) { + effects.exit("tableDelimiterRow"); + if (!hasDash || tableHeaderCount !== align.length) { + return nok(code); + } + if (code === null) { + return tableClose(code); + } + return effects.check(nextPrefixedOrBlank, tableClose, tableContinue)(code); + } + function tableClose(code) { + effects.exit("table"); + return ok(code); + } + function tableContinue(code) { + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + return createSpace(effects, bodyStart, "linePrefix", 4); + } + function bodyStart(code) { + effects.enter("tableBody"); + return rowStartBody(code); + } + function rowStartBody(code) { + effects.enter("tableRow"); + if (code === 124) { + return cellDividerBody(code); + } + effects.enter("temporaryTableCellContent"); + return inCellContentBody(code); + } + function cellDividerBody(code) { + effects.enter("tableCellDivider"); + effects.consume(code); + effects.exit("tableCellDivider"); + return cellBreakBody; + } + function cellBreakBody(code) { + if (code === null || code === -5 || code === -4 || code === -3) { + return atRowEndBody(code); + } + if (code === -2 || code === -1 || code === 32) { + effects.enter("whitespace"); + effects.consume(code); + return inWhitespaceBody; + } + if (code === 124) { + return cellDividerBody(code); + } + effects.enter("temporaryTableCellContent"); + return inCellContentBody(code); + } + function inWhitespaceBody(code) { + if (code === -2 || code === -1 || code === 32) { + effects.consume(code); + return inWhitespaceBody; + } + effects.exit("whitespace"); + return cellBreakBody(code); + } + function inCellContentBody(code) { + if (code === null || code < 0 || code === 32 || code === 124) { + effects.exit("temporaryTableCellContent"); + return cellBreakBody(code); + } + effects.consume(code); + return code === 92 ? inCellContentEscapeBody : inCellContentBody; + } + function inCellContentEscapeBody(code) { + if (code === 92 || code === 124) { + effects.consume(code); + return inCellContentBody; + } + return inCellContentBody(code); + } + function atRowEndBody(code) { + effects.exit("tableRow"); + if (code === null) { + return tableBodyClose(code); + } + return effects.check(nextPrefixedOrBlank, tableBodyClose, tableBodyContinue)(code); + } + function tableBodyClose(code) { + effects.exit("tableBody"); + return tableClose(code); + } + function tableBodyContinue(code) { + effects.enter("lineEnding"); + effects.consume(code); + effects.exit("lineEnding"); + return createSpace(effects, rowStartBody, "linePrefix", 4); + } + } + function tokenizeSetextUnderlineMini(effects, ok, nok) { + return start; + function start(code) { + if (code !== 45) { + return nok(code); + } + effects.enter("setextUnderline"); + return sequence(code); + } + function sequence(code) { + if (code === 45) { + effects.consume(code); + return sequence; + } + return whitespace(code); + } + function whitespace(code) { + if (code === -2 || code === -1 || code === 32) { + effects.consume(code); + return whitespace; + } + if (code === null || code === -5 || code === -4 || code === -3) { + return ok(code); + } + return nok(code); + } + } + function tokenizeNextPrefixedOrBlank(effects, ok, nok) { + var size = 0; + return start; + function start(code) { + effects.enter("check"); + effects.consume(code); + return whitespace; + } + function whitespace(code) { + if (code === -1 || code === 32) { + effects.consume(code); + size++; + return size === 4 ? ok : whitespace; + } + if (code === null || code < 0) { + return ok(code); + } + return nok(code); + } + } + } +}); + +// node_modules/micromark-extension-gfm-table/index.js +var require_micromark_extension_gfm_table = __commonJS({ + "node_modules/micromark-extension-gfm-table/index.js"(exports, module2) { + module2.exports = require_syntax2(); + } +}); + +// node_modules/micromark-extension-gfm-task-list-item/syntax.js +var require_syntax3 = __commonJS({ + "node_modules/micromark-extension-gfm-task-list-item/syntax.js"(exports) { + var markdownLineEndingOrSpace = require_markdown_line_ending_or_space(); + var spaceFactory = require_factory_space(); + var prefixSize = require_prefix_size(); + var tasklistCheck = { tokenize: tokenizeTasklistCheck }; + exports.text = { 91: tasklistCheck }; + function tokenizeTasklistCheck(effects, ok, nok) { + var self = this; + return open; + function open(code) { + if (code !== 91 || self.previous !== null || !self._gfmTasklistFirstContentOfListItem) { + return nok(code); + } + effects.enter("taskListCheck"); + effects.enter("taskListCheckMarker"); + effects.consume(code); + effects.exit("taskListCheckMarker"); + return inside; + } + function inside(code) { + if (code === -2 || code === 32) { + effects.enter("taskListCheckValueUnchecked"); + effects.consume(code); + effects.exit("taskListCheckValueUnchecked"); + return close; + } + if (code === 88 || code === 120) { + effects.enter("taskListCheckValueChecked"); + effects.consume(code); + effects.exit("taskListCheckValueChecked"); + return close; + } + return nok(code); + } + function close(code) { + if (code === 93) { + effects.enter("taskListCheckMarker"); + effects.consume(code); + effects.exit("taskListCheckMarker"); + effects.exit("taskListCheck"); + return effects.check({ tokenize: spaceThenNonSpace }, ok, nok); + } + return nok(code); + } + } + function spaceThenNonSpace(effects, ok, nok) { + var self = this; + return spaceFactory(effects, after, "whitespace"); + function after(code) { + return prefixSize(self.events, "whitespace") && code !== null && !markdownLineEndingOrSpace(code) ? ok(code) : nok(code); + } + } + } +}); + +// node_modules/micromark-extension-gfm-task-list-item/index.js +var require_micromark_extension_gfm_task_list_item = __commonJS({ + "node_modules/micromark-extension-gfm-task-list-item/index.js"(exports, module2) { + module2.exports = require_syntax3(); + } +}); + +// node_modules/micromark-extension-gfm/syntax.js +var require_syntax4 = __commonJS({ + "node_modules/micromark-extension-gfm/syntax.js"(exports, module2) { + var combine = require_combine_extensions(); + var autolink = require_micromark_extension_gfm_autolink_literal(); + var strikethrough = require_micromark_extension_gfm_strikethrough(); + var table = require_micromark_extension_gfm_table(); + var tasklist = require_micromark_extension_gfm_task_list_item(); + module2.exports = create; + function create(options) { + return combine([autolink, strikethrough(options), table, tasklist]); + } + } +}); + +// node_modules/micromark-extension-gfm/index.js +var require_micromark_extension_gfm = __commonJS({ + "node_modules/micromark-extension-gfm/index.js"(exports, module2) { + module2.exports = require_syntax4(); + } +}); + +// node_modules/ccount/index.js +var require_ccount = __commonJS({ + "node_modules/ccount/index.js"(exports, module2) { + "use strict"; + module2.exports = ccount; + function ccount(source, character) { + var value = String(source); + var count = 0; + var index; + if (typeof character !== "string") { + throw new Error("Expected character"); + } + index = value.indexOf(character); + while (index !== -1) { + count++; + index = value.indexOf(character, index + character.length); + } + return count; + } + } +}); + +// node_modules/unist-util-is/convert.js +var require_convert = __commonJS({ + "node_modules/unist-util-is/convert.js"(exports, module2) { + "use strict"; + module2.exports = convert; + function convert(test) { + if (test == null) { + return ok; + } + if (typeof test === "string") { + return typeFactory(test); + } + if (typeof test === "object") { + return "length" in test ? anyFactory(test) : allFactory(test); + } + if (typeof test === "function") { + return test; + } + throw new Error("Expected function, string, or object as test"); + } + function allFactory(test) { + return all; + function all(node) { + var key; + for (key in test) { + if (node[key] !== test[key]) + return false; + } + return true; + } + } + function anyFactory(tests) { + var checks = []; + var index = -1; + while (++index < tests.length) { + checks[index] = convert(tests[index]); + } + return any; + function any() { + var index2 = -1; + while (++index2 < checks.length) { + if (checks[index2].apply(this, arguments)) { + return true; + } + } + return false; + } + } + function typeFactory(test) { + return type; + function type(node) { + return Boolean(node && node.type === test); + } + } + function ok() { + return true; + } + } +}); + +// node_modules/unist-util-visit-parents/color.browser.js +var require_color_browser = __commonJS({ + "node_modules/unist-util-visit-parents/color.browser.js"(exports, module2) { + module2.exports = identity; + function identity(d) { + return d; + } + } +}); + +// node_modules/unist-util-visit-parents/index.js +var require_unist_util_visit_parents = __commonJS({ + "node_modules/unist-util-visit-parents/index.js"(exports, module2) { + "use strict"; + module2.exports = visitParents; + var convert = require_convert(); + var color = require_color_browser(); + var CONTINUE = true; + var SKIP3 = "skip"; + var EXIT = false; + visitParents.CONTINUE = CONTINUE; + visitParents.SKIP = SKIP3; + visitParents.EXIT = EXIT; + function visitParents(tree, test, visitor, reverse) { + var step; + var is; + if (typeof test === "function" && typeof visitor !== "function") { + reverse = visitor; + visitor = test; + test = null; + } + is = convert(test); + step = reverse ? -1 : 1; + factory(tree, null, [])(); + function factory(node, index, parents) { + var value = typeof node === "object" && node !== null ? node : {}; + var name; + if (typeof value.type === "string") { + name = typeof value.tagName === "string" ? value.tagName : typeof value.name === "string" ? value.name : void 0; + visit3.displayName = "node (" + color(value.type + (name ? "<" + name + ">" : "")) + ")"; + } + return visit3; + function visit3() { + var grandparents = parents.concat(node); + var result = []; + var subresult; + var offset; + if (!test || is(node, index, parents[parents.length - 1] || null)) { + result = toResult(visitor(node, parents)); + if (result[0] === EXIT) { + return result; + } + } + if (node.children && result[0] !== SKIP3) { + offset = (reverse ? node.children.length : -1) + step; + while (offset > -1 && offset < node.children.length) { + subresult = factory(node.children[offset], offset, grandparents)(); + if (subresult[0] === EXIT) { + return subresult; + } + offset = typeof subresult[1] === "number" ? subresult[1] : offset + step; + } + } + return result; + } + } + } + function toResult(value) { + if (value !== null && typeof value === "object" && "length" in value) { + return value; + } + if (typeof value === "number") { + return [CONTINUE, value]; + } + return [value]; + } + } +}); + +// node_modules/escape-string-regexp/index.js +var require_escape_string_regexp = __commonJS({ + "node_modules/escape-string-regexp/index.js"(exports, module2) { + "use strict"; + module2.exports = (string2) => { + if (typeof string2 !== "string") { + throw new TypeError("Expected a string"); + } + return string2.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d"); + }; + } +}); + +// node_modules/mdast-util-find-and-replace/index.js +var require_mdast_util_find_and_replace = __commonJS({ + "node_modules/mdast-util-find-and-replace/index.js"(exports, module2) { + "use strict"; + module2.exports = findAndReplace; + var visit3 = require_unist_util_visit_parents(); + var convert = require_convert(); + var escape = require_escape_string_regexp(); + var splice = [].splice; + function findAndReplace(tree, find, replace, options) { + var settings; + var schema4; + if (typeof find === "string" || find && typeof find.exec === "function") { + schema4 = [[find, replace]]; + } else { + schema4 = find; + options = replace; + } + settings = options || {}; + search(tree, settings, handlerFactory(toPairs(schema4))); + return tree; + function handlerFactory(pairs2) { + var pair = pairs2[0]; + return handler; + function handler(node, parent) { + var find2 = pair[0]; + var replace2 = pair[1]; + var nodes = []; + var start = 0; + var index = parent.children.indexOf(node); + var position; + var match; + var subhandler; + var value; + find2.lastIndex = 0; + match = find2.exec(node.value); + while (match) { + position = match.index; + value = replace2.apply(null, [].concat(match, { index: match.index, input: match.input })); + if (value !== false) { + if (start !== position) { + nodes.push({ type: "text", value: node.value.slice(start, position) }); + } + if (typeof value === "string" && value.length > 0) { + value = { type: "text", value }; + } + if (value) { + nodes = [].concat(nodes, value); + } + start = position + match[0].length; + } + if (!find2.global) { + break; + } + match = find2.exec(node.value); + } + if (position === void 0) { + nodes = [node]; + index--; + } else { + if (start < node.value.length) { + nodes.push({ type: "text", value: node.value.slice(start) }); + } + nodes.unshift(index, 1); + splice.apply(parent.children, nodes); + } + if (pairs2.length > 1) { + subhandler = handlerFactory(pairs2.slice(1)); + position = -1; + while (++position < nodes.length) { + node = nodes[position]; + if (node.type === "text") { + subhandler(node, parent); + } else { + search(node, settings, subhandler); + } + } + } + return index + nodes.length + 1; + } + } + } + function search(tree, settings, handler) { + var ignored = convert(settings.ignore || []); + var result = []; + visit3(tree, "text", visitor); + return result; + function visitor(node, parents) { + var index = -1; + var parent; + var grandparent; + while (++index < parents.length) { + parent = parents[index]; + if (ignored(parent, grandparent ? grandparent.children.indexOf(parent) : void 0, grandparent)) { + return; + } + grandparent = parent; + } + return handler(node, grandparent); + } + } + function toPairs(schema4) { + var result = []; + var key; + var index; + if (typeof schema4 !== "object") { + throw new Error("Expected array or object as schema"); + } + if ("length" in schema4) { + index = -1; + while (++index < schema4.length) { + result.push([ + toExpression(schema4[index][0]), + toFunction(schema4[index][1]) + ]); + } + } else { + for (key in schema4) { + result.push([toExpression(key), toFunction(schema4[key])]); + } + } + return result; + } + function toExpression(find) { + return typeof find === "string" ? new RegExp(escape(find), "g") : find; + } + function toFunction(replace) { + return typeof replace === "function" ? replace : returner; + function returner() { + return replace; + } + } + } +}); + +// node_modules/mdast-util-gfm-autolink-literal/from-markdown.js +var require_from_markdown = __commonJS({ + "node_modules/mdast-util-gfm-autolink-literal/from-markdown.js"(exports) { + var ccount = require_ccount(); + var findAndReplace = require_mdast_util_find_and_replace(); + var unicodePunctuation = require_unicode_punctuation(); + var unicodeWhitespace = require_unicode_whitespace(); + exports.transforms = [transformGfmAutolinkLiterals]; + exports.enter = { + literalAutolink: enterLiteralAutolink, + literalAutolinkEmail: enterLiteralAutolinkValue, + literalAutolinkHttp: enterLiteralAutolinkValue, + literalAutolinkWww: enterLiteralAutolinkValue + }; + exports.exit = { + literalAutolink: exitLiteralAutolink, + literalAutolinkEmail: exitLiteralAutolinkEmail, + literalAutolinkHttp: exitLiteralAutolinkHttp, + literalAutolinkWww: exitLiteralAutolinkWww + }; + function enterLiteralAutolink(token) { + this.enter({ type: "link", title: null, url: "", children: [] }, token); + } + function enterLiteralAutolinkValue(token) { + this.config.enter.autolinkProtocol.call(this, token); + } + function exitLiteralAutolinkHttp(token) { + this.config.exit.autolinkProtocol.call(this, token); + } + function exitLiteralAutolinkWww(token) { + this.config.exit.data.call(this, token); + this.stack[this.stack.length - 1].url = "http://" + this.sliceSerialize(token); + } + function exitLiteralAutolinkEmail(token) { + this.config.exit.autolinkEmail.call(this, token); + } + function exitLiteralAutolink(token) { + this.exit(token); + } + function transformGfmAutolinkLiterals(tree) { + findAndReplace(tree, [ + [/(https?:\/\/|www(?=\.))([-.\w]+)([^ \t\r\n]*)/i, findUrl], + [/([-.\w+]+)@([-\w]+(?:\.[-\w]+)+)/, findEmail] + ], { ignore: ["link", "linkReference"] }); + } + function findUrl($0, protocol, domain, path, match) { + var prefix = ""; + var parts; + var result; + if (!previous(match)) { + return false; + } + if (/^w/i.test(protocol)) { + domain = protocol + domain; + protocol = ""; + prefix = "http://"; + } + if (!isCorrectDomain(domain)) { + return false; + } + parts = splitUrl(domain + path); + if (!parts[0]) + return false; + result = { + type: "link", + title: null, + url: prefix + protocol + parts[0], + children: [{ type: "text", value: protocol + parts[0] }] + }; + if (parts[1]) { + result = [result, { type: "text", value: parts[1] }]; + } + return result; + } + function findEmail($0, atext, label, match) { + if (!previous(match, true) || /[_-]$/.test(label)) { + return false; + } + return { + type: "link", + title: null, + url: "mailto:" + atext + "@" + label, + children: [{ type: "text", value: atext + "@" + label }] + }; + } + function isCorrectDomain(domain) { + var parts = domain.split("."); + if (parts.length < 2 || parts[parts.length - 1] && (/_/.test(parts[parts.length - 1]) || !/[a-zA-Z\d]/.test(parts[parts.length - 1])) || parts[parts.length - 2] && (/_/.test(parts[parts.length - 2]) || !/[a-zA-Z\d]/.test(parts[parts.length - 2]))) { + return false; + } + return true; + } + function splitUrl(url) { + var trail = /[!"&'),.:;<>?\]}]+$/.exec(url); + var closingParenIndex; + var openingParens; + var closingParens; + if (trail) { + url = url.slice(0, trail.index); + trail = trail[0]; + closingParenIndex = trail.indexOf(")"); + openingParens = ccount(url, "("); + closingParens = ccount(url, ")"); + while (closingParenIndex !== -1 && openingParens > closingParens) { + url += trail.slice(0, closingParenIndex + 1); + trail = trail.slice(closingParenIndex + 1); + closingParenIndex = trail.indexOf(")"); + closingParens++; + } + } + return [url, trail]; + } + function previous(match, email) { + var code = match.input.charCodeAt(match.index - 1); + return (code !== code || unicodeWhitespace(code) || unicodePunctuation(code)) && (!email || code !== 47); + } + } +}); + +// node_modules/mdast-util-gfm-strikethrough/from-markdown.js +var require_from_markdown2 = __commonJS({ + "node_modules/mdast-util-gfm-strikethrough/from-markdown.js"(exports) { + exports.canContainEols = ["delete"]; + exports.enter = { strikethrough: enterStrikethrough }; + exports.exit = { strikethrough: exitStrikethrough }; + function enterStrikethrough(token) { + this.enter({ type: "delete", children: [] }, token); + } + function exitStrikethrough(token) { + this.exit(token); + } + } +}); + +// node_modules/mdast-util-gfm-table/from-markdown.js +var require_from_markdown3 = __commonJS({ + "node_modules/mdast-util-gfm-table/from-markdown.js"(exports) { + exports.enter = { + table: enterTable, + tableData: enterCell, + tableHeader: enterCell, + tableRow: enterRow + }; + exports.exit = { + codeText: exitCodeText, + table: exitTable, + tableData: exit, + tableHeader: exit, + tableRow: exit + }; + function enterTable(token) { + this.enter({ type: "table", align: token._align, children: [] }, token); + this.setData("inTable", true); + } + function exitTable(token) { + this.exit(token); + this.setData("inTable"); + } + function enterRow(token) { + this.enter({ type: "tableRow", children: [] }, token); + } + function exit(token) { + this.exit(token); + } + function enterCell(token) { + this.enter({ type: "tableCell", children: [] }, token); + } + function exitCodeText(token) { + var value = this.resume(); + if (this.getData("inTable")) { + value = value.replace(/\\([\\|])/g, replace); + } + this.stack[this.stack.length - 1].value = value; + this.exit(token); + } + function replace($0, $1) { + return $1 === "|" ? $1 : $0; + } + } +}); + +// node_modules/mdast-util-gfm-task-list-item/from-markdown.js +var require_from_markdown4 = __commonJS({ + "node_modules/mdast-util-gfm-task-list-item/from-markdown.js"(exports) { + exports.exit = { + taskListCheckValueChecked: exitCheck, + taskListCheckValueUnchecked: exitCheck, + paragraph: exitParagraphWithTaskListItem + }; + function exitCheck(token) { + this.stack[this.stack.length - 2].checked = token.type === "taskListCheckValueChecked"; + } + function exitParagraphWithTaskListItem(token) { + var parent = this.stack[this.stack.length - 2]; + var node = this.stack[this.stack.length - 1]; + var siblings = parent.children; + var head = node.children[0]; + var index = -1; + var firstParaghraph; + if (parent && parent.type === "listItem" && typeof parent.checked === "boolean" && head && head.type === "text") { + while (++index < siblings.length) { + if (siblings[index].type === "paragraph") { + firstParaghraph = siblings[index]; + break; + } + } + if (firstParaghraph === node) { + head.value = head.value.slice(1); + if (head.value.length === 0) { + node.children.shift(); + } else { + head.position.start.column++; + head.position.start.offset++; + node.position.start = Object.assign({}, head.position.start); + } + } + } + this.exit(token); + } + } +}); + +// node_modules/mdast-util-gfm/from-markdown.js +var require_from_markdown5 = __commonJS({ + "node_modules/mdast-util-gfm/from-markdown.js"(exports, module2) { + var autolinkLiteral = require_from_markdown(); + var strikethrough = require_from_markdown2(); + var table = require_from_markdown3(); + var taskListItem = require_from_markdown4(); + var own = {}.hasOwnProperty; + module2.exports = configure([ + autolinkLiteral, + strikethrough, + table, + taskListItem + ]); + function configure(extensions) { + var config = { transforms: [], canContainEols: [] }; + var length = extensions.length; + var index = -1; + while (++index < length) { + extension(config, extensions[index]); + } + return config; + } + function extension(config, extension2) { + var key; + var left; + var right; + for (key in extension2) { + left = own.call(config, key) ? config[key] : config[key] = {}; + right = extension2[key]; + if (key === "canContainEols" || key === "transforms") { + config[key] = [].concat(left, right); + } else { + Object.assign(left, right); + } + } + } + } +}); + +// node_modules/mdast-util-gfm-autolink-literal/to-markdown.js +var require_to_markdown = __commonJS({ + "node_modules/mdast-util-gfm-autolink-literal/to-markdown.js"(exports) { + var inConstruct = "phrasing"; + var notInConstruct = ["autolink", "link", "image", "label"]; + exports.unsafe = [ + { + character: "@", + before: "[+\\-.\\w]", + after: "[\\-.\\w]", + inConstruct, + notInConstruct + }, + { + character: ".", + before: "[Ww]", + after: "[\\-.\\w]", + inConstruct, + notInConstruct + }, + { + character: ":", + before: "[ps]", + after: "\\/", + inConstruct, + notInConstruct + } + ]; + } +}); + +// node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js +var require_container_phrasing = __commonJS({ + "node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js"(exports, module2) { + module2.exports = phrasing; + function phrasing(parent, context, safeOptions) { + var children = parent.children || []; + var results = []; + var index = -1; + var before = safeOptions.before; + var after; + var handle; + var child; + while (++index < children.length) { + child = children[index]; + if (index + 1 < children.length) { + handle = context.handle.handlers[children[index + 1].type]; + if (handle && handle.peek) + handle = handle.peek; + after = handle ? handle(children[index + 1], parent, context, { + before: "", + after: "" + }).charAt(0) : ""; + } else { + after = safeOptions.after; + } + if (results.length > 0 && (before === "\r" || before === "\n") && child.type === "html") { + results[results.length - 1] = results[results.length - 1].replace(/(\r?\n|\r)$/, " "); + before = " "; + } + results.push(context.handle(child, parent, context, { + before, + after + })); + before = results[results.length - 1].slice(-1); + } + return results.join(""); + } + } +}); + +// node_modules/mdast-util-gfm-strikethrough/to-markdown.js +var require_to_markdown2 = __commonJS({ + "node_modules/mdast-util-gfm-strikethrough/to-markdown.js"(exports) { + var phrasing = require_container_phrasing(); + exports.unsafe = [{ character: "~", inConstruct: "phrasing" }]; + exports.handlers = { delete: handleDelete }; + handleDelete.peek = peekDelete; + function handleDelete(node, _, context) { + var exit = context.enter("emphasis"); + var value = phrasing(node, context, { before: "~", after: "~" }); + exit(); + return "~~" + value + "~~"; + } + function peekDelete() { + return "~"; + } + } +}); + +// node_modules/mdast-util-to-markdown/lib/util/pattern-compile.js +var require_pattern_compile = __commonJS({ + "node_modules/mdast-util-to-markdown/lib/util/pattern-compile.js"(exports, module2) { + module2.exports = patternCompile; + function patternCompile(pattern) { + var before; + var after; + if (!pattern._compiled) { + before = pattern.before ? "(?:" + pattern.before + ")" : ""; + after = pattern.after ? "(?:" + pattern.after + ")" : ""; + if (pattern.atBreak) { + before = "[\\r\\n][\\t ]*" + before; + } + pattern._compiled = new RegExp((before ? "(" + before + ")" : "") + (/[|\\{}()[\]^$+*?.-]/.test(pattern.character) ? "\\" : "") + pattern.character + (after || ""), "g"); + } + return pattern._compiled; + } + } +}); + +// node_modules/mdast-util-to-markdown/lib/handle/inline-code.js +var require_inline_code = __commonJS({ + "node_modules/mdast-util-to-markdown/lib/handle/inline-code.js"(exports, module2) { + module2.exports = inlineCode; + inlineCode.peek = inlineCodePeek; + var patternCompile = require_pattern_compile(); + function inlineCode(node, parent, context) { + var value = node.value || ""; + var sequence = "`"; + var index = -1; + var pattern; + var expression; + var match; + var position; + while (new RegExp("(^|[^`])" + sequence + "([^`]|$)").test(value)) { + sequence += "`"; + } + if (/[^ \r\n]/.test(value) && (/[ \r\n`]/.test(value.charAt(0)) || /[ \r\n`]/.test(value.charAt(value.length - 1)))) { + value = " " + value + " "; + } + while (++index < context.unsafe.length) { + pattern = context.unsafe[index]; + if (!pattern.atBreak) + continue; + expression = patternCompile(pattern); + while (match = expression.exec(value)) { + position = match.index; + if (value.charCodeAt(position) === 10 && value.charCodeAt(position - 1) === 13) { + position--; + } + value = value.slice(0, position) + " " + value.slice(match.index + 1); + } + } + return sequence + value + sequence; + } + function inlineCodePeek() { + return "`"; + } + } +}); + +// node_modules/repeat-string/index.js +var require_repeat_string = __commonJS({ + "node_modules/repeat-string/index.js"(exports, module2) { + "use strict"; + var res = ""; + var cache; + module2.exports = repeat; + function repeat(str, num) { + if (typeof str !== "string") { + throw new TypeError("expected a string"); + } + if (num === 1) + return str; + if (num === 2) + return str + str; + var max = str.length * num; + if (cache !== str || typeof cache === "undefined") { + cache = str; + res = ""; + } else if (res.length >= max) { + return res.substr(0, max); + } + while (max > res.length && num > 1) { + if (num & 1) { + res += str; + } + num >>= 1; + str += str; + } + res += str; + res = res.substr(0, max); + return res; + } + } +}); + +// node_modules/markdown-table/index.js +var require_markdown_table = __commonJS({ + "node_modules/markdown-table/index.js"(exports, module2) { + "use strict"; + var repeat = require_repeat_string(); + module2.exports = markdownTable; + var trailingWhitespace = / +$/; + var space = " "; + var lineFeed = "\n"; + var dash = "-"; + var colon = ":"; + var verticalBar = "|"; + var x = 0; + var C = 67; + var L = 76; + var R = 82; + var c = 99; + var l = 108; + var r = 114; + function markdownTable(table, options) { + var settings = options || {}; + var padding = settings.padding !== false; + var start = settings.delimiterStart !== false; + var end = settings.delimiterEnd !== false; + var align = (settings.align || []).concat(); + var alignDelimiters = settings.alignDelimiters !== false; + var alignments = []; + var stringLength = settings.stringLength || defaultStringLength; + var rowIndex = -1; + var rowLength = table.length; + var cellMatrix = []; + var sizeMatrix = []; + var row = []; + var sizes = []; + var longestCellByColumn = []; + var mostCellsPerRow = 0; + var cells; + var columnIndex; + var columnLength; + var largest; + var size; + var cell; + var lines; + var line; + var before; + var after; + var code; + while (++rowIndex < rowLength) { + cells = table[rowIndex]; + columnIndex = -1; + columnLength = cells.length; + row = []; + sizes = []; + if (columnLength > mostCellsPerRow) { + mostCellsPerRow = columnLength; + } + while (++columnIndex < columnLength) { + cell = serialize(cells[columnIndex]); + if (alignDelimiters === true) { + size = stringLength(cell); + sizes[columnIndex] = size; + largest = longestCellByColumn[columnIndex]; + if (largest === void 0 || size > largest) { + longestCellByColumn[columnIndex] = size; + } + } + row.push(cell); + } + cellMatrix[rowIndex] = row; + sizeMatrix[rowIndex] = sizes; + } + columnIndex = -1; + columnLength = mostCellsPerRow; + if (typeof align === "object" && "length" in align) { + while (++columnIndex < columnLength) { + alignments[columnIndex] = toAlignment(align[columnIndex]); + } + } else { + code = toAlignment(align); + while (++columnIndex < columnLength) { + alignments[columnIndex] = code; + } + } + columnIndex = -1; + columnLength = mostCellsPerRow; + row = []; + sizes = []; + while (++columnIndex < columnLength) { + code = alignments[columnIndex]; + before = ""; + after = ""; + if (code === l) { + before = colon; + } else if (code === r) { + after = colon; + } else if (code === c) { + before = colon; + after = colon; + } + size = alignDelimiters ? Math.max(1, longestCellByColumn[columnIndex] - before.length - after.length) : 1; + cell = before + repeat(dash, size) + after; + if (alignDelimiters === true) { + size = before.length + size + after.length; + if (size > longestCellByColumn[columnIndex]) { + longestCellByColumn[columnIndex] = size; + } + sizes[columnIndex] = size; + } + row[columnIndex] = cell; + } + cellMatrix.splice(1, 0, row); + sizeMatrix.splice(1, 0, sizes); + rowIndex = -1; + rowLength = cellMatrix.length; + lines = []; + while (++rowIndex < rowLength) { + row = cellMatrix[rowIndex]; + sizes = sizeMatrix[rowIndex]; + columnIndex = -1; + columnLength = mostCellsPerRow; + line = []; + while (++columnIndex < columnLength) { + cell = row[columnIndex] || ""; + before = ""; + after = ""; + if (alignDelimiters === true) { + size = longestCellByColumn[columnIndex] - (sizes[columnIndex] || 0); + code = alignments[columnIndex]; + if (code === r) { + before = repeat(space, size); + } else if (code === c) { + if (size % 2 === 0) { + before = repeat(space, size / 2); + after = before; + } else { + before = repeat(space, size / 2 + 0.5); + after = repeat(space, size / 2 - 0.5); + } + } else { + after = repeat(space, size); + } + } + if (start === true && columnIndex === 0) { + line.push(verticalBar); + } + if (padding === true && !(alignDelimiters === false && cell === "") && (start === true || columnIndex !== 0)) { + line.push(space); + } + if (alignDelimiters === true) { + line.push(before); + } + line.push(cell); + if (alignDelimiters === true) { + line.push(after); + } + if (padding === true) { + line.push(space); + } + if (end === true || columnIndex !== columnLength - 1) { + line.push(verticalBar); + } + } + line = line.join(""); + if (end === false) { + line = line.replace(trailingWhitespace, ""); + } + lines.push(line); + } + return lines.join(lineFeed); + } + function serialize(value) { + return value === null || value === void 0 ? "" : String(value); + } + function defaultStringLength(value) { + return value.length; + } + function toAlignment(value) { + var code = typeof value === "string" ? value.charCodeAt(0) : x; + return code === L || code === l ? l : code === R || code === r ? r : code === C || code === c ? c : x; + } + } +}); + +// node_modules/mdast-util-gfm-table/to-markdown.js +var require_to_markdown3 = __commonJS({ + "node_modules/mdast-util-gfm-table/to-markdown.js"(exports, module2) { + var phrasing = require_container_phrasing(); + var defaultInlineCode = require_inline_code(); + var markdownTable = require_markdown_table(); + module2.exports = toMarkdown; + function toMarkdown(options) { + var settings = options || {}; + var padding = settings.tableCellPadding; + var alignDelimiters = settings.tablePipeAlign; + var stringLength = settings.stringLength; + var around = padding ? " " : "|"; + return { + unsafe: [ + { character: "\r", inConstruct: "tableCell" }, + { character: "\n", inConstruct: "tableCell" }, + { atBreak: true, character: "|", after: "[ :-]" }, + { character: "|", inConstruct: "tableCell" }, + { atBreak: true, character: ":", after: "-" }, + { atBreak: true, character: "-", after: "[:|-]" } + ], + handlers: { + table: handleTable, + tableRow: handleTableRow, + tableCell: handleTableCell, + inlineCode: inlineCodeWithTable + } + }; + function handleTable(node, _, context) { + return serializeData(handleTableAsData(node, context), node.align); + } + function handleTableRow(node, _, context) { + var row = handleTableRowAsData(node, context); + var value = serializeData([row]); + return value.slice(0, value.indexOf("\n")); + } + function handleTableCell(node, _, context) { + var exit = context.enter("tableCell"); + var value = phrasing(node, context, { before: around, after: around }); + exit(); + return value; + } + function serializeData(matrix, align) { + return markdownTable(matrix, { + align, + alignDelimiters, + padding, + stringLength + }); + } + function handleTableAsData(node, context) { + var children = node.children; + var index = -1; + var length = children.length; + var result = []; + var subexit = context.enter("table"); + while (++index < length) { + result[index] = handleTableRowAsData(children[index], context); + } + subexit(); + return result; + } + function handleTableRowAsData(node, context) { + var children = node.children; + var index = -1; + var length = children.length; + var result = []; + var subexit = context.enter("tableRow"); + while (++index < length) { + result[index] = handleTableCell(children[index], node, context); + } + subexit(); + return result; + } + function inlineCodeWithTable(node, parent, context) { + var value = defaultInlineCode(node, parent, context); + if (context.stack.indexOf("tableCell") !== -1) { + value = value.replace(/\|/g, "\\$&"); + } + return value; + } + } + } +}); + +// node_modules/mdast-util-to-markdown/lib/util/check-bullet.js +var require_check_bullet = __commonJS({ + "node_modules/mdast-util-to-markdown/lib/util/check-bullet.js"(exports, module2) { + module2.exports = checkBullet; + function checkBullet(context) { + var marker = context.options.bullet || "*"; + if (marker !== "*" && marker !== "+" && marker !== "-") { + throw new Error("Cannot serialize items with `" + marker + "` for `options.bullet`, expected `*`, `+`, or `-`"); + } + return marker; + } + } +}); + +// node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js +var require_check_list_item_indent = __commonJS({ + "node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js"(exports, module2) { + module2.exports = checkListItemIndent; + function checkListItemIndent(context) { + var style = context.options.listItemIndent || "tab"; + if (style === 1 || style === "1") { + return "one"; + } + if (style !== "tab" && style !== "one" && style !== "mixed") { + throw new Error("Cannot serialize items with `" + style + "` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`"); + } + return style; + } + } +}); + +// node_modules/mdast-util-to-markdown/lib/util/container-flow.js +var require_container_flow = __commonJS({ + "node_modules/mdast-util-to-markdown/lib/util/container-flow.js"(exports, module2) { + module2.exports = flow; + var repeat = require_repeat_string(); + function flow(parent, context) { + var children = parent.children || []; + var results = []; + var index = -1; + var child; + while (++index < children.length) { + child = children[index]; + results.push(context.handle(child, parent, context, { before: "\n", after: "\n" })); + if (index + 1 < children.length) { + results.push(between(child, children[index + 1])); + } + } + return results.join(""); + function between(left, right) { + var index2 = -1; + var result; + while (++index2 < context.join.length) { + result = context.join[index2](left, right, parent, context); + if (result === true || result === 1) { + break; + } + if (typeof result === "number") { + return repeat("\n", 1 + Number(result)); + } + if (result === false) { + return "\n\n\n\n"; + } + } + return "\n\n"; + } + } + } +}); + +// node_modules/mdast-util-to-markdown/lib/util/indent-lines.js +var require_indent_lines = __commonJS({ + "node_modules/mdast-util-to-markdown/lib/util/indent-lines.js"(exports, module2) { + module2.exports = indentLines; + var eol = /\r?\n|\r/g; + function indentLines(value, map2) { + var result = []; + var start = 0; + var line = 0; + var match; + while (match = eol.exec(value)) { + one(value.slice(start, match.index)); + result.push(match[0]); + start = match.index + match[0].length; + line++; + } + one(value.slice(start)); + return result.join(""); + function one(value2) { + result.push(map2(value2, line, !value2)); + } + } + } +}); + +// node_modules/mdast-util-to-markdown/lib/handle/list-item.js +var require_list_item = __commonJS({ + "node_modules/mdast-util-to-markdown/lib/handle/list-item.js"(exports, module2) { + module2.exports = listItem; + var repeat = require_repeat_string(); + var checkBullet = require_check_bullet(); + var checkListItemIndent = require_check_list_item_indent(); + var flow = require_container_flow(); + var indentLines = require_indent_lines(); + function listItem(node, parent, context) { + var bullet = checkBullet(context); + var listItemIndent = checkListItemIndent(context); + var size; + var value; + var exit; + if (parent && parent.ordered) { + bullet = (parent.start > -1 ? parent.start : 1) + (context.options.incrementListMarker === false ? 0 : parent.children.indexOf(node)) + "."; + } + size = bullet.length + 1; + if (listItemIndent === "tab" || listItemIndent === "mixed" && (parent && parent.spread || node.spread)) { + size = Math.ceil(size / 4) * 4; + } + exit = context.enter("listItem"); + value = indentLines(flow(node, context), map2); + exit(); + return value; + function map2(line, index, blank) { + if (index) { + return (blank ? "" : repeat(" ", size)) + line; + } + return (blank ? bullet : bullet + repeat(" ", size - bullet.length)) + line; + } + } + } +}); + +// node_modules/mdast-util-gfm-task-list-item/to-markdown.js +var require_to_markdown4 = __commonJS({ + "node_modules/mdast-util-gfm-task-list-item/to-markdown.js"(exports) { + var defaultListItem = require_list_item(); + exports.unsafe = [{ atBreak: true, character: "-", after: "[:|-]" }]; + exports.handlers = { + listItem: listItemWithTaskListItem + }; + function listItemWithTaskListItem(node, parent, context) { + var value = defaultListItem(node, parent, context); + var head = node.children[0]; + if (typeof node.checked === "boolean" && head && head.type === "paragraph") { + value = value.replace(/^(?:[*+-]|\d+\.)([\r\n]| {1,3})/, check); + } + return value; + function check($0) { + return $0 + "[" + (node.checked ? "x" : " ") + "] "; + } + } + } +}); + +// node_modules/mdast-util-to-markdown/lib/configure.js +var require_configure = __commonJS({ + "node_modules/mdast-util-to-markdown/lib/configure.js"(exports, module2) { + module2.exports = configure; + function configure(base, extension) { + var index = -1; + var key; + if (extension.extensions) { + while (++index < extension.extensions.length) { + configure(base, extension.extensions[index]); + } + } + for (key in extension) { + if (key === "extensions") { + } else if (key === "unsafe" || key === "join") { + base[key] = base[key].concat(extension[key] || []); + } else if (key === "handlers") { + base[key] = Object.assign(base[key], extension[key] || {}); + } else { + base.options[key] = extension[key]; + } + } + return base; + } + } +}); + +// node_modules/mdast-util-gfm/to-markdown.js +var require_to_markdown5 = __commonJS({ + "node_modules/mdast-util-gfm/to-markdown.js"(exports, module2) { + var autolinkLiteral = require_to_markdown(); + var strikethrough = require_to_markdown2(); + var table = require_to_markdown3(); + var taskListItem = require_to_markdown4(); + var configure = require_configure(); + module2.exports = toMarkdown; + function toMarkdown(options) { + var config = configure({ handlers: {}, join: [], unsafe: [], options: {} }, { + extensions: [autolinkLiteral, strikethrough, table(options), taskListItem] + }); + return Object.assign(config.options, { + handlers: config.handlers, + join: config.join, + unsafe: config.unsafe + }); + } + } +}); + +// node_modules/remark-gfm/index.js +var require_remark_gfm = __commonJS({ + "node_modules/remark-gfm/index.js"(exports, module2) { + "use strict"; + var syntax = require_micromark_extension_gfm(); + var fromMarkdown = require_from_markdown5(); + var toMarkdown = require_to_markdown5(); + var warningIssued; + module2.exports = gfm; + function gfm(options) { + var data = this.data(); + if (!warningIssued && (this.Parser && this.Parser.prototype && this.Parser.prototype.blockTokenizers || this.Compiler && this.Compiler.prototype && this.Compiler.prototype.visitors)) { + warningIssued = true; + console.warn("[remark-gfm] Warning: please upgrade to remark 13 to use this plugin"); + } + add("micromarkExtensions", syntax(options)); + add("fromMarkdownExtensions", fromMarkdown); + add("toMarkdownExtensions", toMarkdown(options)); + function add(field, value) { + if (data[field]) + data[field].push(value); + else + data[field] = [value]; + } + } + } +}); + +// node_modules/@tryfabric/martian/build/src/index.js +var require_src = __commonJS({ + "node_modules/@tryfabric/martian/build/src/index.js"(exports) { + "use strict"; + var __importDefault = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.markdownToRichText = exports.markdownToBlocks = void 0; + var unified_1 = __importDefault(require_unified()); + var remark_parse_1 = __importDefault(require_remark_parse()); + var internal_1 = require_internal(); + var remark_gfm_1 = __importDefault(require_remark_gfm()); + function markdownToBlocks2(body, options) { + const root = (0, unified_1.default)().use(remark_parse_1.default).use(remark_gfm_1.default).parse(body); + return (0, internal_1.parseBlocks)(root, options); + } + exports.markdownToBlocks = markdownToBlocks2; + function markdownToRichText(text, options) { + const root = (0, unified_1.default)().use(remark_parse_1.default).use(remark_gfm_1.default).parse(text); + return (0, internal_1.parseRichText)(root, options); + } + exports.markdownToRichText = markdownToRichText; + } +}); + +// node_modules/js-yaml/lib/js-yaml/common.js +var require_common2 = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/common.js"(exports, module2) { + "use strict"; + 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(string2, count) { + var result = "", cycle; + for (cycle = 0; cycle < count; cycle += 1) { + result += string2; + } + return result; + } + function isNegativeZero(number) { + return number === 0 && Number.NEGATIVE_INFINITY === 1 / number; + } + module2.exports.isNothing = isNothing; + module2.exports.isObject = isObject; + module2.exports.toArray = toArray; + module2.exports.repeat = repeat; + module2.exports.isNegativeZero = isNegativeZero; + module2.exports.extend = extend; + } +}); + +// node_modules/js-yaml/lib/js-yaml/exception.js +var require_exception = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/exception.js"(exports, module2) { + "use strict"; + function YAMLException(reason, mark) { + Error.call(this); + this.name = "YAMLException"; + this.reason = reason; + this.mark = mark; + this.message = (this.reason || "(unknown reason)") + (this.mark ? " " + this.mark.toString() : ""); + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } else { + this.stack = new Error().stack || ""; + } + } + YAMLException.prototype = Object.create(Error.prototype); + YAMLException.prototype.constructor = YAMLException; + YAMLException.prototype.toString = function toString(compact) { + var result = this.name + ": "; + result += this.reason || "(unknown reason)"; + if (!compact && this.mark) { + result += " " + this.mark.toString(); + } + return result; + }; + module2.exports = YAMLException; + } +}); + +// node_modules/js-yaml/lib/js-yaml/mark.js +var require_mark = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/mark.js"(exports, module2) { + "use strict"; + var common = require_common2(); + function Mark(name, buffer, position, line, column) { + this.name = name; + this.buffer = buffer; + this.position = position; + this.line = line; + this.column = column; + } + Mark.prototype.getSnippet = function getSnippet(indent, maxLength) { + var head, start, tail, end, snippet; + if (!this.buffer) + return null; + indent = indent || 4; + maxLength = maxLength || 75; + head = ""; + start = this.position; + while (start > 0 && "\0\r\n\x85\u2028\u2029".indexOf(this.buffer.charAt(start - 1)) === -1) { + start -= 1; + if (this.position - start > maxLength / 2 - 1) { + head = " ... "; + start += 5; + break; + } + } + tail = ""; + end = this.position; + while (end < this.buffer.length && "\0\r\n\x85\u2028\u2029".indexOf(this.buffer.charAt(end)) === -1) { + end += 1; + if (end - this.position > maxLength / 2 - 1) { + tail = " ... "; + end -= 5; + break; + } + } + snippet = this.buffer.slice(start, end); + return common.repeat(" ", indent) + head + snippet + tail + "\n" + common.repeat(" ", indent + this.position - start + head.length) + "^"; + }; + Mark.prototype.toString = function toString(compact) { + var snippet, where = ""; + if (this.name) { + where += 'in "' + this.name + '" '; + } + where += "at line " + (this.line + 1) + ", column " + (this.column + 1); + if (!compact) { + snippet = this.getSnippet(); + if (snippet) { + where += ":\n" + snippet; + } + } + return where; + }; + module2.exports = Mark; + } +}); + +// node_modules/js-yaml/lib/js-yaml/type.js +var require_type = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type.js"(exports, module2) { + "use strict"; + var YAMLException = require_exception(); + var TYPE_CONSTRUCTOR_OPTIONS = [ + "kind", + "resolve", + "construct", + "instanceOf", + "predicate", + "represent", + "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(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.tag = tag; + this.kind = options["kind"] || null; + this.resolve = options["resolve"] || function() { + return true; + }; + this.construct = options["construct"] || function(data) { + return data; + }; + this.instanceOf = options["instanceOf"] || null; + this.predicate = options["predicate"] || null; + this.represent = options["represent"] || null; + this.defaultStyle = options["defaultStyle"] || null; + this.styleAliases = compileStyleAliases(options["styleAliases"] || null); + if (YAML_NODE_KINDS.indexOf(this.kind) === -1) { + throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.'); + } + } + module2.exports = Type; + } +}); + +// node_modules/js-yaml/lib/js-yaml/schema.js +var require_schema = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/schema.js"(exports, module2) { + "use strict"; + var common = require_common2(); + var YAMLException = require_exception(); + var Type = require_type(); + function compileList(schema4, name, result) { + var exclude = []; + schema4.include.forEach(function(includedSchema) { + result = compileList(includedSchema, name, result); + }); + schema4[name].forEach(function(currentType) { + result.forEach(function(previousType, previousIndex) { + if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) { + exclude.push(previousIndex); + } + }); + result.push(currentType); + }); + return result.filter(function(type, index) { + return exclude.indexOf(index) === -1; + }); + } + function compileMap() { + var result = { + scalar: {}, + sequence: {}, + mapping: {}, + fallback: {} + }, index, length; + function collectType(type) { + result[type.kind][type.tag] = result["fallback"][type.tag] = type; + } + for (index = 0, length = arguments.length; index < length; index += 1) { + arguments[index].forEach(collectType); + } + return result; + } + function Schema2(definition) { + this.include = definition.include || []; + this.implicit = definition.implicit || []; + this.explicit = definition.explicit || []; + this.implicit.forEach(function(type) { + 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."); + } + }); + this.compiledImplicit = compileList(this, "implicit", []); + this.compiledExplicit = compileList(this, "explicit", []); + this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit); + } + Schema2.DEFAULT = null; + Schema2.create = function createSchema() { + var schemas2, types; + switch (arguments.length) { + case 1: + schemas2 = Schema2.DEFAULT; + types = arguments[0]; + break; + case 2: + schemas2 = arguments[0]; + types = arguments[1]; + break; + default: + throw new YAMLException("Wrong number of arguments for Schema.create function"); + } + schemas2 = common.toArray(schemas2); + types = common.toArray(types); + if (!schemas2.every(function(schema4) { + return schema4 instanceof Schema2; + })) { + throw new YAMLException("Specified list of super schemas (or a single Schema object) contains a non-Schema object."); + } + if (!types.every(function(type) { + return type instanceof Type; + })) { + throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object."); + } + return new Schema2({ + include: schemas2, + explicit: types + }); + }; + module2.exports = Schema2; + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/str.js +var require_str = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/str.js"(exports, module2) { + "use strict"; + var Type = require_type(); + module2.exports = new Type("tag:yaml.org,2002:str", { + kind: "scalar", + construct: function(data) { + return data !== null ? data : ""; + } + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/seq.js +var require_seq = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/seq.js"(exports, module2) { + "use strict"; + var Type = require_type(); + module2.exports = new Type("tag:yaml.org,2002:seq", { + kind: "sequence", + construct: function(data) { + return data !== null ? data : []; + } + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/map.js +var require_map = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/map.js"(exports, module2) { + "use strict"; + var Type = require_type(); + module2.exports = new Type("tag:yaml.org,2002:map", { + kind: "mapping", + construct: function(data) { + return data !== null ? data : {}; + } + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/schema/failsafe.js +var require_failsafe = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/schema/failsafe.js"(exports, module2) { + "use strict"; + var Schema2 = require_schema(); + module2.exports = new Schema2({ + explicit: [ + require_str(), + require_seq(), + require_map() + ] + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/null.js +var require_null = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/null.js"(exports, module2) { + "use strict"; + var Type = require_type(); + 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; + } + module2.exports = new Type("tag:yaml.org,2002:null", { + kind: "scalar", + resolve: resolveYamlNull, + construct: constructYamlNull, + predicate: isNull, + represent: { + canonical: function() { + return "~"; + }, + lowercase: function() { + return "null"; + }, + uppercase: function() { + return "NULL"; + }, + camelcase: function() { + return "Null"; + } + }, + defaultStyle: "lowercase" + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/bool.js +var require_bool = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/bool.js"(exports, module2) { + "use strict"; + var Type = require_type(); + 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]"; + } + module2.exports = new Type("tag:yaml.org,2002:bool", { + kind: "scalar", + resolve: resolveYamlBoolean, + construct: constructYamlBoolean, + predicate: isBoolean, + represent: { + lowercase: function(object) { + return object ? "true" : "false"; + }, + uppercase: function(object) { + return object ? "TRUE" : "FALSE"; + }, + camelcase: function(object) { + return object ? "True" : "False"; + } + }, + defaultStyle: "lowercase" + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/int.js +var require_int = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/int.js"(exports, module2) { + "use strict"; + var common = require_common2(); + var Type = require_type(); + 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 !== "_"; + } + 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 (ch === ":") + break; + if (!isDecCode(data.charCodeAt(index))) { + return false; + } + hasDigits = true; + } + if (!hasDigits || ch === "_") + return false; + if (ch !== ":") + return true; + return /^(:[0-5]?[0-9])+$/.test(data.slice(index)); + } + function constructYamlInteger(data) { + var value = data, sign = 1, ch, base, digits = []; + if (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, 16); + return sign * parseInt(value, 8); + } + if (value.indexOf(":") !== -1) { + value.split(":").forEach(function(v) { + digits.unshift(parseInt(v, 10)); + }); + value = 0; + base = 1; + digits.forEach(function(d) { + value += d * base; + base *= 60; + }); + return sign * value; + } + return sign * parseInt(value, 10); + } + function isInteger(object) { + return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 === 0 && !common.isNegativeZero(object)); + } + module2.exports = new Type("tag:yaml.org,2002:int", { + kind: "scalar", + resolve: resolveYamlInteger, + construct: constructYamlInteger, + predicate: isInteger, + represent: { + binary: function(obj) { + return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1); + }, + octal: function(obj) { + return obj >= 0 ? "0" + obj.toString(8) : "-0" + obj.toString(8).slice(1); + }, + decimal: function(obj) { + return obj.toString(10); + }, + hexadecimal: function(obj) { + return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1); + } + }, + defaultStyle: "decimal", + styleAliases: { + binary: [2, "bin"], + octal: [8, "oct"], + decimal: [10, "dec"], + hexadecimal: [16, "hex"] + } + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/float.js +var require_float = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/float.js"(exports, module2) { + "use strict"; + var common = require_common2(); + var Type = require_type(); + var YAML_FLOAT_PATTERN = new RegExp("^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"); + function resolveYamlFloat(data) { + if (data === null) + return false; + if (!YAML_FLOAT_PATTERN.test(data) || data[data.length - 1] === "_") { + return false; + } + return true; + } + function constructYamlFloat(data) { + var value, sign, base, digits; + value = data.replace(/_/g, "").toLowerCase(); + sign = value[0] === "-" ? -1 : 1; + digits = []; + if ("+-".indexOf(value[0]) >= 0) { + value = value.slice(1); + } + if (value === ".inf") { + return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; + } else if (value === ".nan") { + return NaN; + } else if (value.indexOf(":") >= 0) { + value.split(":").forEach(function(v) { + digits.unshift(parseFloat(v, 10)); + }); + value = 0; + base = 1; + digits.forEach(function(d) { + value += d * base; + base *= 60; + }); + return sign * value; + } + return sign * parseFloat(value, 10); + } + var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/; + function representYamlFloat(object, style) { + var res; + if (isNaN(object)) { + switch (style) { + case "lowercase": + return ".nan"; + case "uppercase": + return ".NAN"; + case "camelcase": + return ".NaN"; + } + } else if (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)); + } + module2.exports = new Type("tag:yaml.org,2002:float", { + kind: "scalar", + resolve: resolveYamlFloat, + construct: constructYamlFloat, + predicate: isFloat, + represent: representYamlFloat, + defaultStyle: "lowercase" + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/schema/json.js +var require_json = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/schema/json.js"(exports, module2) { + "use strict"; + var Schema2 = require_schema(); + module2.exports = new Schema2({ + include: [ + require_failsafe() + ], + implicit: [ + require_null(), + require_bool(), + require_int(), + require_float() + ] + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/schema/core.js +var require_core2 = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/schema/core.js"(exports, module2) { + "use strict"; + var Schema2 = require_schema(); + module2.exports = new Schema2({ + include: [ + require_json() + ] + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/timestamp.js +var require_timestamp = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/timestamp.js"(exports, module2) { + "use strict"; + var Type = require_type(); + 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(); + } + module2.exports = new Type("tag:yaml.org,2002:timestamp", { + kind: "scalar", + resolve: resolveYamlTimestamp, + construct: constructYamlTimestamp, + instanceOf: Date, + represent: representYamlTimestamp + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/merge.js +var require_merge = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/merge.js"(exports, module2) { + "use strict"; + var Type = require_type(); + function resolveYamlMerge(data) { + return data === "<<" || data === null; + } + module2.exports = new Type("tag:yaml.org,2002:merge", { + kind: "scalar", + resolve: resolveYamlMerge + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/binary.js +var require_binary = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/binary.js"(exports, module2) { + "use strict"; + var NodeBuffer; + try { + _require = require; + NodeBuffer = _require("buffer").Buffer; + } catch (__) { + } + var _require; + var Type = require_type(); + 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); + } + if (NodeBuffer) { + return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result); + } + return result; + } + function representYamlBinary(object) { + var result = "", bits = 0, idx, tail, max = object.length, 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(object) { + return NodeBuffer && NodeBuffer.isBuffer(object); + } + module2.exports = new Type("tag:yaml.org,2002:binary", { + kind: "scalar", + resolve: resolveYamlBinary, + construct: constructYamlBinary, + predicate: isBinary, + represent: representYamlBinary + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/omap.js +var require_omap = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/omap.js"(exports, module2) { + "use strict"; + var Type = require_type(); + var _hasOwnProperty = Object.prototype.hasOwnProperty; + var _toString = 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.call(pair) !== "[object Object]") + return false; + for (pairKey in pair) { + if (_hasOwnProperty.call(pair, pairKey)) { + if (!pairHasKey) + pairHasKey = true; + else + return false; + } + } + if (!pairHasKey) + return false; + if (objectKeys.indexOf(pairKey) === -1) + objectKeys.push(pairKey); + else + return false; + } + return true; + } + function constructYamlOmap(data) { + return data !== null ? data : []; + } + module2.exports = new Type("tag:yaml.org,2002:omap", { + kind: "sequence", + resolve: resolveYamlOmap, + construct: constructYamlOmap + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/pairs.js +var require_pairs = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/pairs.js"(exports, module2) { + "use strict"; + var Type = require_type(); + var _toString = 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.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; + } + module2.exports = new Type("tag:yaml.org,2002:pairs", { + kind: "sequence", + resolve: resolveYamlPairs, + construct: constructYamlPairs + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/set.js +var require_set = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/set.js"(exports, module2) { + "use strict"; + var Type = require_type(); + var _hasOwnProperty = Object.prototype.hasOwnProperty; + function resolveYamlSet(data) { + if (data === null) + return true; + var key, object = data; + for (key in object) { + if (_hasOwnProperty.call(object, key)) { + if (object[key] !== null) + return false; + } + } + return true; + } + function constructYamlSet(data) { + return data !== null ? data : {}; + } + module2.exports = new Type("tag:yaml.org,2002:set", { + kind: "mapping", + resolve: resolveYamlSet, + construct: constructYamlSet + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/schema/default_safe.js +var require_default_safe = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/schema/default_safe.js"(exports, module2) { + "use strict"; + var Schema2 = require_schema(); + module2.exports = new Schema2({ + include: [ + require_core2() + ], + implicit: [ + require_timestamp(), + require_merge() + ], + explicit: [ + require_binary(), + require_omap(), + require_pairs(), + require_set() + ] + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/js/undefined.js +var require_undefined = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/js/undefined.js"(exports, module2) { + "use strict"; + var Type = require_type(); + function resolveJavascriptUndefined() { + return true; + } + function constructJavascriptUndefined() { + return void 0; + } + function representJavascriptUndefined() { + return ""; + } + function isUndefined(object) { + return typeof object === "undefined"; + } + module2.exports = new Type("tag:yaml.org,2002:js/undefined", { + kind: "scalar", + resolve: resolveJavascriptUndefined, + construct: constructJavascriptUndefined, + predicate: isUndefined, + represent: representJavascriptUndefined + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/js/regexp.js +var require_regexp = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/js/regexp.js"(exports, module2) { + "use strict"; + var Type = require_type(); + function resolveJavascriptRegExp(data) { + if (data === null) + return false; + if (data.length === 0) + return false; + var regexp = data, tail = /\/([gim]*)$/.exec(data), modifiers = ""; + if (regexp[0] === "/") { + if (tail) + modifiers = tail[1]; + if (modifiers.length > 3) + return false; + if (regexp[regexp.length - modifiers.length - 1] !== "/") + return false; + } + return true; + } + function constructJavascriptRegExp(data) { + var regexp = data, tail = /\/([gim]*)$/.exec(data), modifiers = ""; + if (regexp[0] === "/") { + if (tail) + modifiers = tail[1]; + regexp = regexp.slice(1, regexp.length - modifiers.length - 1); + } + return new RegExp(regexp, modifiers); + } + function representJavascriptRegExp(object) { + var result = "/" + object.source + "/"; + if (object.global) + result += "g"; + if (object.multiline) + result += "m"; + if (object.ignoreCase) + result += "i"; + return result; + } + function isRegExp(object) { + return Object.prototype.toString.call(object) === "[object RegExp]"; + } + module2.exports = new Type("tag:yaml.org,2002:js/regexp", { + kind: "scalar", + resolve: resolveJavascriptRegExp, + construct: constructJavascriptRegExp, + predicate: isRegExp, + represent: representJavascriptRegExp + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/type/js/function.js +var require_function = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/type/js/function.js"(exports, module2) { + "use strict"; + var esprima; + try { + _require = require; + esprima = _require("esprima"); + } catch (_) { + if (typeof window !== "undefined") + esprima = window.esprima; + } + var _require; + var Type = require_type(); + function resolveJavascriptFunction(data) { + if (data === null) + return false; + try { + var source = "(" + data + ")", ast = esprima.parse(source, { range: true }); + if (ast.type !== "Program" || ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement" || ast.body[0].expression.type !== "ArrowFunctionExpression" && ast.body[0].expression.type !== "FunctionExpression") { + return false; + } + return true; + } catch (err) { + return false; + } + } + function constructJavascriptFunction(data) { + var source = "(" + data + ")", ast = esprima.parse(source, { range: true }), params = [], body; + if (ast.type !== "Program" || ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement" || ast.body[0].expression.type !== "ArrowFunctionExpression" && ast.body[0].expression.type !== "FunctionExpression") { + throw new Error("Failed to resolve function"); + } + ast.body[0].expression.params.forEach(function(param) { + params.push(param.name); + }); + body = ast.body[0].expression.body.range; + if (ast.body[0].expression.body.type === "BlockStatement") { + return new Function(params, source.slice(body[0] + 1, body[1] - 1)); + } + return new Function(params, "return " + source.slice(body[0], body[1])); + } + function representJavascriptFunction(object) { + return object.toString(); + } + function isFunction(object) { + return Object.prototype.toString.call(object) === "[object Function]"; + } + module2.exports = new Type("tag:yaml.org,2002:js/function", { + kind: "scalar", + resolve: resolveJavascriptFunction, + construct: constructJavascriptFunction, + predicate: isFunction, + represent: representJavascriptFunction + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/schema/default_full.js +var require_default_full = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/schema/default_full.js"(exports, module2) { + "use strict"; + var Schema2 = require_schema(); + module2.exports = Schema2.DEFAULT = new Schema2({ + include: [ + require_default_safe() + ], + explicit: [ + require_undefined(), + require_regexp(), + require_function() + ] + }); + } +}); + +// node_modules/js-yaml/lib/js-yaml/loader.js +var require_loader = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/loader.js"(exports, module2) { + "use strict"; + var common = require_common2(); + var YAMLException = require_exception(); + var Mark = require_mark(); + var DEFAULT_SAFE_SCHEMA = require_default_safe(); + var DEFAULT_FULL_SCHEMA = require_default_full(); + var _hasOwnProperty = Object.prototype.hasOwnProperty; + var CONTEXT_FLOW_IN = 1; + var CONTEXT_FLOW_OUT = 2; + var CONTEXT_BLOCK_IN = 3; + var CONTEXT_BLOCK_OUT = 4; + var CHOMPING_CLIP = 1; + var CHOMPING_STRIP = 2; + var CHOMPING_KEEP = 3; + var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; + var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/; + var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/; + var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i; + var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i; + function _class(obj) { + return Object.prototype.toString.call(obj); + } + function is_EOL(c) { + return 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 ? "" : 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(input, options) { + this.input = input; + this.filename = options["filename"] || null; + this.schema = options["schema"] || DEFAULT_FULL_SCHEMA; + this.onWarning = options["onWarning"] || null; + this.legacy = options["legacy"] || false; + this.json = options["json"] || false; + this.listener = options["listener"] || null; + this.implicitTypes = this.schema.compiledImplicit; + this.typeMap = this.schema.compiledTypeMap; + this.length = input.length; + this.position = 0; + this.line = 0; + this.lineStart = 0; + this.lineIndent = 0; + this.documents = []; + } + function generateError(state, message) { + return new YAMLException(message, new Mark(state.filename, state.input, state.position, state.line, state.position - state.lineStart)); + } + function throwError(state, message) { + throw generateError(state, message); + } + function throwWarning(state, message) { + if (state.onWarning) { + state.onWarning.call(null, generateError(state, message)); + } + } + var directiveHandlers = { + YAML: function 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.call(state.tagMap, handle)) { + throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle'); + } + if (!PATTERN_TAG_URI.test(prefix)) { + throwError(state, "ill-formed tag prefix (second argument) of the TAG directive"); + } + state.tagMap[handle] = prefix; + } + }; + function captureSegment(state, start, end, checkJson) { + var _position, _length, _character, _result; + if (start < end) { + _result = state.input.slice(start, end); + if (checkJson) { + for (_position = 0, _length = _result.length; _position < _length; _position += 1) { + _character = _result.charCodeAt(_position); + if (!(_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.call(destination, key)) { + destination[key] = source[key]; + overridableKeys[key] = true; + } + } + } + function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) { + var index, quantity; + if (Array.isArray(keyNode)) { + keyNode = Array.prototype.slice.call(keyNode); + for (index = 0, quantity = keyNode.length; index < quantity; index += 1) { + if (Array.isArray(keyNode[index])) { + throwError(state, "nested arrays are not supported inside keys"); + } + if (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.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) { + state.line = startLine || state.line; + state.position = startPos || state.position; + throwError(state, "duplicated mapping key"); + } + _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; + } + function skipSeparationSpace(state, allowComments, checkIndent) { + var lineBreaks = 0, ch = state.input.charCodeAt(state.position); + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + 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, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair2, isExplicitPair, isMapping, overridableKeys = {}, 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"); + } + keyTag = keyNode = valueNode = null; + isPair2 = isExplicitPair = false; + if (ch === 63) { + following = state.input.charCodeAt(state.position + 1); + if (is_WS_OR_EOL(following)) { + isPair2 = isExplicitPair = true; + state.position++; + skipSeparationSpace(state, true, nodeIndent); + } + } + _line = state.line; + composeNode2(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) { + isPair2 = true; + ch = state.input.charCodeAt(++state.position); + skipSeparationSpace(state, true, nodeIndent); + composeNode2(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + valueNode = state.result; + } + if (isMapping) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode); + } else if (isPair2) { + _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode)); + } 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"; + } + } + break; + } + if (folding) { + if (is_WHITE_SPACE(ch)) { + atMoreIndented = true; + state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); + } else if (atMoreIndented) { + atMoreIndented = false; + state.result += common.repeat("\n", emptyLines + 1); + } else if (emptyLines === 0) { + if (didReadContent) { + state.result += " "; + } + } else { + state.result += common.repeat("\n", emptyLines); + } + } else { + state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); + } + didReadContent = true; + detectedIndent = true; + emptyLines = 0; + captureStart = state.position; + while (!is_EOL(ch) && ch !== 0) { + ch = state.input.charCodeAt(++state.position); + } + captureSegment(state, captureStart, state.position, false); + } + return true; + } + function readBlockSequence(state, nodeIndent) { + var _line, _tag = state.tag, _anchor = state.anchor, _result = [], following, detected = false, ch; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + ch = state.input.charCodeAt(state.position); + while (ch !== 0) { + if (ch !== 45) { + break; + } + following = state.input.charCodeAt(state.position + 1); + if (!is_WS_OR_EOL(following)) { + break; + } + detected = true; + state.position++; + if (skipSeparationSpace(state, true, -1)) { + if (state.lineIndent <= nodeIndent) { + _result.push(null); + ch = state.input.charCodeAt(state.position); + continue; + } + } + _line = state.line; + composeNode2(state, nodeIndent, CONTEXT_BLOCK_IN, false, true); + _result.push(state.result); + skipSeparationSpace(state, true, -1); + ch = state.input.charCodeAt(state.position); + if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) { + throwError(state, "bad indentation of a sequence entry"); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = "sequence"; + state.result = _result; + return true; + } + return false; + } + function readBlockMapping(state, nodeIndent, flowIndent) { + var following, allowCompact, _line, _pos, _tag = state.tag, _anchor = state.anchor, _result = {}, overridableKeys = {}, keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + ch = state.input.charCodeAt(state.position); + while (ch !== 0) { + following = state.input.charCodeAt(state.position + 1); + _line = state.line; + _pos = state.position; + if ((ch === 63 || ch === 58) && is_WS_OR_EOL(following)) { + if (ch === 63) { + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); + keyTag = keyNode = valueNode = null; + } + detected = true; + atExplicitKey = true; + allowCompact = true; + } else if (atExplicitKey) { + atExplicitKey = false; + allowCompact = true; + } else { + throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line"); + } + state.position += 1; + ch = following; + } else if (composeNode2(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) { + if (state.line === _line) { + ch = state.input.charCodeAt(state.position); + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + if (ch === 58) { + ch = state.input.charCodeAt(++state.position); + if (!is_WS_OR_EOL(ch)) { + throwError(state, "a whitespace character is expected after the key-value separator within a block mapping"); + } + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); + keyTag = keyNode = valueNode = null; + } + detected = true; + atExplicitKey = false; + allowCompact = false; + keyTag = state.tag; + keyNode = state.result; + } else if (detected) { + throwError(state, "can not read an implicit mapping pair; a colon is missed"); + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; + } + } else if (detected) { + throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key"); + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; + } + } else { + break; + } + if (state.line === _line || state.lineIndent > nodeIndent) { + if (composeNode2(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) { + if (atExplicitKey) { + keyNode = state.result; + } else { + valueNode = state.result; + } + } + if (!atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos); + keyTag = keyNode = valueNode = null; + } + skipSeparationSpace(state, true, -1); + ch = state.input.charCodeAt(state.position); + } + if (state.lineIndent > nodeIndent && 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); + } + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = "mapping"; + state.result = _result; + } + return detected; + } + function readTagProperty(state) { + var _position, isVerbatim = false, isNamed = false, tagHandle, tagName, ch; + ch = state.input.charCodeAt(state.position); + if (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 = "!"; + } + _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 && !is_WS_OR_EOL(ch)) { + if (ch === 33) { + if (!isNamed) { + tagHandle = state.input.slice(_position - 1, state.position + 1); + if (!PATTERN_TAG_HANDLE.test(tagHandle)) { + throwError(state, "named tag handle cannot contain such characters"); + } + isNamed = true; + _position = state.position + 1; + } else { + throwError(state, "tag suffix cannot contain exclamation marks"); + } + } + ch = state.input.charCodeAt(++state.position); + } + tagName = state.input.slice(_position, state.position); + if (PATTERN_FLOW_INDICATORS.test(tagName)) { + throwError(state, "tag suffix cannot contain flow indicator characters"); + } + } + if (tagName && !PATTERN_TAG_URI.test(tagName)) { + throwError(state, "tag name cannot contain such characters: " + tagName); + } + if (isVerbatim) { + state.tag = tagName; + } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) { + state.tag = state.tagMap[tagHandle] + tagName; + } else if (tagHandle === "!") { + state.tag = "!" + tagName; + } else if (tagHandle === "!!") { + state.tag = "tag:yaml.org,2002:" + tagName; + } else { + throwError(state, 'undeclared tag handle "' + tagHandle + '"'); + } + return true; + } + function readAnchorProperty(state) { + var _position, ch; + ch = state.input.charCodeAt(state.position); + if (ch !== 38) + return false; + if (state.anchor !== null) { + throwError(state, "duplication of an anchor property"); + } + ch = state.input.charCodeAt(++state.position); + _position = state.position; + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + if (state.position === _position) { + throwError(state, "name of an anchor node must contain at least one character"); + } + state.anchor = state.input.slice(_position, state.position); + return true; + } + function readAlias(state) { + var _position, alias, ch; + ch = state.input.charCodeAt(state.position); + if (ch !== 42) + return false; + ch = state.input.charCodeAt(++state.position); + _position = state.position; + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + if (state.position === _position) { + throwError(state, "name of an alias node must contain at least one character"); + } + alias = state.input.slice(_position, state.position); + if (!_hasOwnProperty.call(state.anchorMap, alias)) { + throwError(state, 'unidentified alias "' + alias + '"'); + } + state.result = state.anchorMap[alias]; + skipSeparationSpace(state, true, -1); + return true; + } + function composeNode2(state, parentIndent, nodeContext, allowToSeek, allowCompact) { + var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, atNewLine = false, hasContent = false, typeIndex, typeQuantity, type, flowIndent, blockIndent; + if (state.listener !== null) { + state.listener("open", state); + } + state.tag = null; + state.anchor = null; + state.kind = null; + state.result = null; + allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext; + if (allowToSeek) { + if (skipSeparationSpace(state, true, -1)) { + atNewLine = true; + if (state.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } + } + if (indentStatus === 1) { + while (readTagProperty(state) || readAnchorProperty(state)) { + if (skipSeparationSpace(state, true, -1)) { + atNewLine = true; + allowBlockCollections = allowBlockStyles; + if (state.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } else { + allowBlockCollections = false; + } + } + } + if (allowBlockCollections) { + allowBlockCollections = atNewLine || allowCompact; + } + if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) { + if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) { + flowIndent = parentIndent; + } else { + flowIndent = parentIndent + 1; + } + blockIndent = state.position - state.lineStart; + if (indentStatus === 1) { + if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) { + hasContent = true; + } else { + if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) { + hasContent = true; + } else if (readAlias(state)) { + hasContent = true; + if (state.tag !== null || state.anchor !== null) { + throwError(state, "alias node should not have any properties"); + } + } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) { + hasContent = true; + if (state.tag === null) { + state.tag = "?"; + } + } + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } else if (indentStatus === 0) { + hasContent = allowBlockCollections && readBlockSequence(state, blockIndent); + } + } + if (state.tag !== null && state.tag !== "!") { + if (state.tag === "?") { + if (state.result !== null && state.kind !== "scalar") { + throwError(state, 'unacceptable node kind for ! tag; it should be "scalar", not "' + state.kind + '"'); + } + for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) { + type = state.implicitTypes[typeIndex]; + if (type.resolve(state.result)) { + state.result = type.construct(state.result); + state.tag = type.tag; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + break; + } + } + } else if (_hasOwnProperty.call(state.typeMap[state.kind || "fallback"], state.tag)) { + type = state.typeMap[state.kind || "fallback"][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)) { + throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag"); + } else { + state.result = type.construct(state.result); + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } else { + throwError(state, "unknown tag !<" + state.tag + ">"); + } + } + if (state.listener !== null) { + state.listener("close", state); + } + return state.tag !== null || state.anchor !== null || hasContent; + } + function readDocument(state) { + var documentStart = state.position, _position, directiveName, directiveArgs, hasDirectives = false, ch; + state.version = null; + state.checkLineBreaks = state.legacy; + state.tagMap = {}; + state.anchorMap = {}; + 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); + _position = state.position; + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + directiveName = state.input.slice(_position, state.position); + directiveArgs = []; + if (directiveName.length < 1) { + throwError(state, "directive name must not be less than one character in length"); + } + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + if (ch === 35) { + do { + ch = state.input.charCodeAt(++state.position); + } while (ch !== 0 && !is_EOL(ch)); + break; + } + if (is_EOL(ch)) + break; + _position = state.position; + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + directiveArgs.push(state.input.slice(_position, state.position)); + } + if (ch !== 0) + readLineBreak(state); + if (_hasOwnProperty.call(directiveHandlers, directiveName)) { + directiveHandlers[directiveName](state, directiveName, directiveArgs); + } else { + throwWarning(state, 'unknown document directive "' + directiveName + '"'); + } + } + skipSeparationSpace(state, true, -1); + 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"); + } + composeNode2(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true); + skipSeparationSpace(state, true, -1); + if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) { + throwWarning(state, "non-ASCII line breaks are interpreted as content"); + } + state.documents.push(state.result); + if (state.position === state.lineStart && testDocumentSeparator(state)) { + if (state.input.charCodeAt(state.position) === 46) { + state.position += 3; + skipSeparationSpace(state, true, -1); + } + return; + } + if (state.position < state.length - 1) { + throwError(state, "end of the stream or a document separator is expected"); + } else { + return; + } + } + function loadDocuments(input, options) { + input = String(input); + options = options || {}; + if (input.length !== 0) { + if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) { + input += "\n"; + } + if (input.charCodeAt(0) === 65279) { + input = input.slice(1); + } + } + var state = new State(input, options); + var nullpos = input.indexOf("\0"); + if (nullpos !== -1) { + state.position = nullpos; + throwError(state, "null byte is not allowed in input"); + } + state.input += "\0"; + while (state.input.charCodeAt(state.position) === 32) { + state.lineIndent += 1; + state.position += 1; + } + while (state.position < state.length - 1) { + readDocument(state); + } + return state.documents; + } + function loadAll(input, iterator, options) { + if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") { + options = iterator; + iterator = null; + } + var documents = loadDocuments(input, options); + if (typeof iterator !== "function") { + return documents; + } + for (var index = 0, length = documents.length; index < length; index += 1) { + iterator(documents[index]); + } + } + function load(input, options) { + var documents = loadDocuments(input, options); + if (documents.length === 0) { + return void 0; + } else if (documents.length === 1) { + return documents[0]; + } + throw new YAMLException("expected a single document in the stream, but found more"); + } + function safeLoadAll(input, iterator, options) { + if (typeof iterator === "object" && iterator !== null && typeof options === "undefined") { + options = iterator; + iterator = null; + } + return loadAll(input, iterator, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); + } + function safeLoad(input, options) { + return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); + } + module2.exports.loadAll = loadAll; + module2.exports.load = load; + module2.exports.safeLoadAll = safeLoadAll; + module2.exports.safeLoad = safeLoad; + } +}); + +// node_modules/js-yaml/lib/js-yaml/dumper.js +var require_dumper = __commonJS({ + "node_modules/js-yaml/lib/js-yaml/dumper.js"(exports, module2) { + "use strict"; + var common = require_common2(); + var YAMLException = require_exception(); + var DEFAULT_FULL_SCHEMA = require_default_full(); + var DEFAULT_SAFE_SCHEMA = require_default_safe(); + var _toString = Object.prototype.toString; + var _hasOwnProperty = Object.prototype.hasOwnProperty; + var CHAR_TAB = 9; + var CHAR_LINE_FEED = 10; + var CHAR_CARRIAGE_RETURN = 13; + var CHAR_SPACE = 32; + var CHAR_EXCLAMATION = 33; + var CHAR_DOUBLE_QUOTE = 34; + var CHAR_SHARP = 35; + var CHAR_PERCENT = 37; + var CHAR_AMPERSAND = 38; + var CHAR_SINGLE_QUOTE = 39; + var CHAR_ASTERISK = 42; + var CHAR_COMMA = 44; + var CHAR_MINUS = 45; + var CHAR_COLON = 58; + var CHAR_EQUALS = 61; + var CHAR_GREATER_THAN = 62; + var CHAR_QUESTION = 63; + var CHAR_COMMERCIAL_AT = 64; + var CHAR_LEFT_SQUARE_BRACKET = 91; + var CHAR_RIGHT_SQUARE_BRACKET = 93; + var CHAR_GRAVE_ACCENT = 96; + var CHAR_LEFT_CURLY_BRACKET = 123; + var CHAR_VERTICAL_LINE = 124; + var CHAR_RIGHT_CURLY_BRACKET = 125; + var ESCAPE_SEQUENCES = {}; + ESCAPE_SEQUENCES[0] = "\\0"; + ESCAPE_SEQUENCES[7] = "\\a"; + ESCAPE_SEQUENCES[8] = "\\b"; + ESCAPE_SEQUENCES[9] = "\\t"; + ESCAPE_SEQUENCES[10] = "\\n"; + ESCAPE_SEQUENCES[11] = "\\v"; + ESCAPE_SEQUENCES[12] = "\\f"; + ESCAPE_SEQUENCES[13] = "\\r"; + ESCAPE_SEQUENCES[27] = "\\e"; + ESCAPE_SEQUENCES[34] = '\\"'; + ESCAPE_SEQUENCES[92] = "\\\\"; + ESCAPE_SEQUENCES[133] = "\\N"; + ESCAPE_SEQUENCES[160] = "\\_"; + ESCAPE_SEQUENCES[8232] = "\\L"; + ESCAPE_SEQUENCES[8233] = "\\P"; + var DEPRECATED_BOOLEANS_SYNTAX = [ + "y", + "Y", + "yes", + "Yes", + "YES", + "on", + "On", + "ON", + "n", + "N", + "no", + "No", + "NO", + "off", + "Off", + "OFF" + ]; + function compileStyleMap(schema4, map2) { + var result, keys, index, length, tag, style, type; + if (map2 === null) + return {}; + result = {}; + keys = Object.keys(map2); + for (index = 0, length = keys.length; index < length; index += 1) { + tag = keys[index]; + style = String(map2[tag]); + if (tag.slice(0, 2) === "!!") { + tag = "tag:yaml.org,2002:" + tag.slice(2); + } + type = schema4.compiledTypeMap["fallback"][tag]; + if (type && _hasOwnProperty.call(type.styleAliases, style)) { + style = type.styleAliases[style]; + } + result[tag] = style; + } + return result; + } + function encodeHex(character) { + var string2, handle, length; + string2 = 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 - string2.length) + string2; + } + function State(options) { + this.schema = options["schema"] || DEFAULT_FULL_SCHEMA; + this.indent = Math.max(1, options["indent"] || 2); + this.noArrayIndent = options["noArrayIndent"] || false; + this.skipInvalid = options["skipInvalid"] || false; + this.flowLevel = common.isNothing(options["flowLevel"]) ? -1 : options["flowLevel"]; + this.styleMap = compileStyleMap(this.schema, options["styles"] || null); + this.sortKeys = options["sortKeys"] || false; + this.lineWidth = options["lineWidth"] || 80; + this.noRefs = options["noRefs"] || false; + this.noCompatMode = options["noCompatMode"] || false; + this.condenseFlow = options["condenseFlow"] || false; + this.implicitTypes = this.schema.compiledImplicit; + this.explicitTypes = this.schema.compiledExplicit; + this.tag = null; + this.result = ""; + this.duplicates = []; + this.usedDuplicates = null; + } + function indentString(string2, spaces) { + var ind = common.repeat(" ", spaces), position = 0, next = -1, result = "", line, length = string2.length; + while (position < length) { + next = string2.indexOf("\n", position); + if (next === -1) { + line = string2.slice(position); + position = length; + } else { + line = string2.slice(position, next + 1); + position = next + 1; + } + if (line.length && line !== "\n") + result += ind; + result += line; + } + return result; + } + function generateNextLine(state, level) { + return "\n" + common.repeat(" ", state.indent * level); + } + function testImplicitResolving(state, str) { + var index, length, type; + for (index = 0, length = state.implicitTypes.length; index < length; index += 1) { + type = state.implicitTypes[index]; + if (type.resolve(str)) { + return true; + } + } + return false; + } + function isWhitespace(c) { + return c === CHAR_SPACE || c === CHAR_TAB; + } + function isPrintable(c) { + return 32 <= c && c <= 126 || 161 <= c && c <= 55295 && c !== 8232 && c !== 8233 || 57344 <= c && c <= 65533 && c !== 65279 || 65536 <= c && c <= 1114111; + } + function isNsChar(c) { + return isPrintable(c) && !isWhitespace(c) && c !== 65279 && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED; + } + function isPlainSafe(c, prev) { + return isPrintable(c) && c !== 65279 && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_COLON && (c !== CHAR_SHARP || prev && isNsChar(prev)); + } + function isPlainSafeFirst(c) { + return isPrintable(c) && c !== 65279 && !isWhitespace(c) && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT; + } + function needIndentIndicator(string2) { + var leadingSpaceRe = /^\n* /; + return leadingSpaceRe.test(string2); + } + var STYLE_PLAIN = 1; + var STYLE_SINGLE = 2; + var STYLE_LITERAL = 3; + var STYLE_FOLDED = 4; + var STYLE_DOUBLE = 5; + function chooseScalarStyle(string2, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) { + var i; + var char, prev_char; + var hasLineBreak = false; + var hasFoldableLine = false; + var shouldTrackWidth = lineWidth !== -1; + var previousLineBreak = -1; + var plain = isPlainSafeFirst(string2.charCodeAt(0)) && !isWhitespace(string2.charCodeAt(string2.length - 1)); + if (singleLineOnly) { + for (i = 0; i < string2.length; i++) { + char = string2.charCodeAt(i); + if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + prev_char = i > 0 ? string2.charCodeAt(i - 1) : null; + plain = plain && isPlainSafe(char, prev_char); + } + } else { + for (i = 0; i < string2.length; i++) { + char = string2.charCodeAt(i); + if (char === CHAR_LINE_FEED) { + hasLineBreak = true; + if (shouldTrackWidth) { + hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && string2[previousLineBreak + 1] !== " "; + previousLineBreak = i; + } + } else if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + prev_char = i > 0 ? string2.charCodeAt(i - 1) : null; + plain = plain && isPlainSafe(char, prev_char); + } + hasFoldableLine = hasFoldableLine || shouldTrackWidth && (i - previousLineBreak - 1 > lineWidth && string2[previousLineBreak + 1] !== " "); + } + if (!hasLineBreak && !hasFoldableLine) { + return plain && !testAmbiguousType(string2) ? STYLE_PLAIN : STYLE_SINGLE; + } + if (indentPerLevel > 9 && needIndentIndicator(string2)) { + return STYLE_DOUBLE; + } + return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL; + } + function writeScalar(state, string2, level, iskey) { + state.dump = function() { + if (string2.length === 0) { + return "''"; + } + if (!state.noCompatMode && DEPRECATED_BOOLEANS_SYNTAX.indexOf(string2) !== -1) { + return "'" + string2 + "'"; + } + var indent = state.indent * Math.max(1, level); + var lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent); + var singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel; + function testAmbiguity(string3) { + return testImplicitResolving(state, string3); + } + switch (chooseScalarStyle(string2, singleLineOnly, state.indent, lineWidth, testAmbiguity)) { + case STYLE_PLAIN: + return string2; + case STYLE_SINGLE: + return "'" + string2.replace(/'/g, "''") + "'"; + case STYLE_LITERAL: + return "|" + blockHeader(string2, state.indent) + dropEndingNewline(indentString(string2, indent)); + case STYLE_FOLDED: + return ">" + blockHeader(string2, state.indent) + dropEndingNewline(indentString(foldString(string2, lineWidth), indent)); + case STYLE_DOUBLE: + return '"' + escapeString(string2, lineWidth) + '"'; + default: + throw new YAMLException("impossible error: invalid scalar style"); + } + }(); + } + function blockHeader(string2, indentPerLevel) { + var indentIndicator = needIndentIndicator(string2) ? String(indentPerLevel) : ""; + var clip = string2[string2.length - 1] === "\n"; + var keep = clip && (string2[string2.length - 2] === "\n" || string2 === "\n"); + var chomp = keep ? "+" : clip ? "" : "-"; + return indentIndicator + chomp + "\n"; + } + function dropEndingNewline(string2) { + return string2[string2.length - 1] === "\n" ? string2.slice(0, -1) : string2; + } + function foldString(string2, width) { + var lineRe = /(\n+)([^\n]*)/g; + var result = function() { + var nextLF = string2.indexOf("\n"); + nextLF = nextLF !== -1 ? nextLF : string2.length; + lineRe.lastIndex = nextLF; + return foldLine(string2.slice(0, nextLF), width); + }(); + var prevMoreIndented = string2[0] === "\n" || string2[0] === " "; + var moreIndented; + var match; + while (match = lineRe.exec(string2)) { + var prefix = match[1], line = match[2]; + moreIndented = line[0] === " "; + result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width); + prevMoreIndented = moreIndented; + } + return result; + } + function foldLine(line, width) { + if (line === "" || line[0] === " ") + return line; + var breakRe = / [^ ]/g; + var match; + var start = 0, end, curr = 0, next = 0; + var result = ""; + while (match = breakRe.exec(line)) { + next = match.index; + if (next - start > width) { + end = curr > start ? curr : next; + result += "\n" + line.slice(start, end); + start = end + 1; + } + curr = next; + } + result += "\n"; + if (line.length - start > width && curr > start) { + result += line.slice(start, curr) + "\n" + line.slice(curr + 1); + } else { + result += line.slice(start); + } + return result.slice(1); + } + function escapeString(string2) { + var result = ""; + var char, nextChar; + var escapeSeq; + for (var i = 0; i < string2.length; i++) { + char = string2.charCodeAt(i); + if (char >= 55296 && char <= 56319) { + nextChar = string2.charCodeAt(i + 1); + if (nextChar >= 56320 && nextChar <= 57343) { + result += encodeHex((char - 55296) * 1024 + nextChar - 56320 + 65536); + i++; + continue; + } + } + escapeSeq = ESCAPE_SEQUENCES[char]; + result += !escapeSeq && isPrintable(char) ? string2[i] : escapeSeq || encodeHex(char); + } + return result; + } + function writeFlowSequence(state, level, object) { + var _result = "", _tag = state.tag, index, length; + for (index = 0, length = object.length; index < length; index += 1) { + if (writeNode(state, level, object[index], false, false)) { + if (index !== 0) + _result += "," + (!state.condenseFlow ? " " : ""); + _result += state.dump; + } + } + state.tag = _tag; + state.dump = "[" + _result + "]"; + } + function writeBlockSequence(state, level, object, compact) { + var _result = "", _tag = state.tag, index, length; + for (index = 0, length = object.length; index < length; index += 1) { + if (writeNode(state, level + 1, object[index], true, true)) { + if (!compact || index !== 0) { + _result += generateNextLine(state, level); + } + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + _result += "-"; + } else { + _result += "- "; + } + _result += state.dump; + } + } + state.tag = _tag; + state.dump = _result || "[]"; + } + function writeFlowMapping(state, level, object) { + var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, pairBuffer; + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + pairBuffer = ""; + if (index !== 0) + pairBuffer += ", "; + if (state.condenseFlow) + pairBuffer += '"'; + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; + if (!writeNode(state, level, objectKey, false, false)) { + continue; + } + if (state.dump.length > 1024) + pairBuffer += "? "; + pairBuffer += state.dump + (state.condenseFlow ? '"' : "") + ":" + (state.condenseFlow ? "" : " "); + if (!writeNode(state, level, objectValue, false, false)) { + continue; + } + pairBuffer += state.dump; + _result += pairBuffer; + } + state.tag = _tag; + state.dump = "{" + _result + "}"; + } + function writeBlockMapping(state, level, object, compact) { + var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, explicitPair, pairBuffer; + if (state.sortKeys === true) { + objectKeyList.sort(); + } else if (typeof state.sortKeys === "function") { + objectKeyList.sort(state.sortKeys); + } else if (state.sortKeys) { + throw new YAMLException("sortKeys must be a boolean or a function"); + } + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + pairBuffer = ""; + if (!compact || index !== 0) { + pairBuffer += generateNextLine(state, level); + } + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; + if (!writeNode(state, level + 1, objectKey, true, true, true)) { + continue; + } + explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024; + if (explicitPair) { + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += "?"; + } else { + pairBuffer += "? "; + } + } + pairBuffer += state.dump; + if (explicitPair) { + pairBuffer += generateNextLine(state, level); + } + if (!writeNode(state, level + 1, objectValue, true, explicitPair)) { + continue; + } + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += ":"; + } else { + pairBuffer += ": "; + } + pairBuffer += state.dump; + _result += pairBuffer; + } + state.tag = _tag; + state.dump = _result || "{}"; + } + function detectType(state, object, explicit) { + var _result, typeList, index, length, type, style; + typeList = explicit ? state.explicitTypes : state.implicitTypes; + for (index = 0, length = typeList.length; index < length; index += 1) { + type = typeList[index]; + if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === "object" && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) { + state.tag = explicit ? type.tag : "?"; + if (type.represent) { + style = state.styleMap[type.tag] || type.defaultStyle; + if (_toString.call(type.represent) === "[object Function]") { + _result = type.represent(object, style); + } else if (_hasOwnProperty.call(type.represent, style)) { + _result = type.represent[style](object, style); + } else { + throw new YAMLException("!<" + type.tag + '> tag resolver accepts not "' + style + '" style'); + } + state.dump = _result; + } + return true; + } + } + return false; + } + function writeNode(state, level, object, block, compact, iskey) { + state.tag = null; + state.dump = object; + if (!detectType(state, object, false)) { + detectType(state, object, true); + } + var type = _toString.call(state.dump); + if (block) { + block = state.flowLevel < 0 || state.flowLevel > level; + } + var objectOrArray = type === "[object Object]" || type === "[object Array]", duplicateIndex, duplicate; + if (objectOrArray) { + duplicateIndex = state.duplicates.indexOf(object); + duplicate = duplicateIndex !== -1; + } + if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) { + compact = false; + } + if (duplicate && state.usedDuplicates[duplicateIndex]) { + state.dump = "*ref_" + duplicateIndex; + } else { + if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) { + state.usedDuplicates[duplicateIndex] = true; + } + if (type === "[object Object]") { + if (block && Object.keys(state.dump).length !== 0) { + writeBlockMapping(state, level, state.dump, compact); + if (duplicate) { + state.dump = "&ref_" + duplicateIndex + state.dump; + } + } else { + writeFlowMapping(state, level, state.dump); + if (duplicate) { + state.dump = "&ref_" + duplicateIndex + " " + state.dump; + } + } + } else if (type === "[object Array]") { + var arrayLevel = state.noArrayIndent && level > 0 ? level - 1 : level; + if (block && state.dump.length !== 0) { + writeBlockSequence(state, arrayLevel, state.dump, compact); + if (duplicate) { + state.dump = "&ref_" + duplicateIndex + state.dump; + } + } else { + writeFlowSequence(state, arrayLevel, state.dump); + if (duplicate) { + state.dump = "&ref_" + duplicateIndex + " " + state.dump; + } + } + } else if (type === "[object String]") { + if (state.tag !== "?") { + writeScalar(state, state.dump, level, iskey); + } + } else { + if (state.skipInvalid) + return false; + throw new YAMLException("unacceptable kind of an object to dump " + type); + } + if (state.tag !== null && state.tag !== "?") { + state.dump = "!<" + state.tag + "> " + state.dump; + } + } + return true; + } + function getDuplicateReferences(object, state) { + var objects = [], duplicatesIndexes = [], index, length; + inspectNode(object, objects, duplicatesIndexes); + for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) { + state.duplicates.push(objects[duplicatesIndexes[index]]); + } + state.usedDuplicates = new Array(length); + } + function inspectNode(object, objects, duplicatesIndexes) { + var objectKeyList, index, length; + if (object !== null && typeof object === "object") { + index = objects.indexOf(object); + if (index !== -1) { + if (duplicatesIndexes.indexOf(index) === -1) { + duplicatesIndexes.push(index); + } + } else { + objects.push(object); + if (Array.isArray(object)) { + for (index = 0, length = object.length; index < length; index += 1) { + inspectNode(object[index], objects, duplicatesIndexes); + } + } else { + objectKeyList = Object.keys(object); + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes); + } + } + } + } + } + function dump(input, options) { + options = options || {}; + var state = new State(options); + if (!state.noRefs) + getDuplicateReferences(input, state); + if (writeNode(state, 0, input, true, true)) + return state.dump + "\n"; + return ""; + } + function safeDump(input, options) { + return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); + } + module2.exports.dump = dump; + module2.exports.safeDump = safeDump; + } +}); + +// node_modules/js-yaml/lib/js-yaml.js +var require_js_yaml = __commonJS({ + "node_modules/js-yaml/lib/js-yaml.js"(exports, module2) { + "use strict"; + var loader = require_loader(); + var dumper = require_dumper(); + function deprecated(name) { + return function() { + throw new Error("Function " + name + " is deprecated and cannot be used."); + }; + } + module2.exports.Type = require_type(); + module2.exports.Schema = require_schema(); + module2.exports.FAILSAFE_SCHEMA = require_failsafe(); + module2.exports.JSON_SCHEMA = require_json(); + module2.exports.CORE_SCHEMA = require_core2(); + module2.exports.DEFAULT_SAFE_SCHEMA = require_default_safe(); + module2.exports.DEFAULT_FULL_SCHEMA = require_default_full(); + module2.exports.load = loader.load; + module2.exports.loadAll = loader.loadAll; + module2.exports.safeLoad = loader.safeLoad; + module2.exports.safeLoadAll = loader.safeLoadAll; + module2.exports.dump = dumper.dump; + module2.exports.safeDump = dumper.safeDump; + module2.exports.YAMLException = require_exception(); + module2.exports.MINIMAL_SCHEMA = require_failsafe(); + module2.exports.SAFE_SCHEMA = require_default_safe(); + module2.exports.DEFAULT_SCHEMA = require_default_full(); + module2.exports.scan = deprecated("scan"); + module2.exports.parse = deprecated("parse"); + module2.exports.compose = deprecated("compose"); + module2.exports.addConstructor = deprecated("addConstructor"); + } +}); + +// node_modules/js-yaml/index.js +var require_js_yaml2 = __commonJS({ + "node_modules/js-yaml/index.js"(exports, module2) { + "use strict"; + var yaml2 = require_js_yaml(); + module2.exports = yaml2; + } +}); + +// main.ts +__export(exports, { + default: () => MyPlugin +}); +var import_obsidian3 = __toModule(require("obsidian")); +var import_path = __toModule(require("path")); +var fs2 = __toModule(require("fs")); + +// icon.ts +var import_obsidian = __toModule(require("obsidian")); +var icons = { + "notion-logo": ` + + + + + + ` +}; +var addIcons = () => { + Object.keys(icons).forEach((key) => { + (0, import_obsidian.addIcon)(key, icons[key]); + }); +}; + +// Upload2Notion.ts +var import_obsidian2 = __toModule(require("obsidian")); +var import_martian = __toModule(require_src()); +var fs = __toModule(require("fs")); + +// node_modules/yaml-front-matter/src/index.js +var jsYaml = require_js_yaml2(); +function parse(text, options, loadSafe) { + let contentKeyName = options && typeof options === "string" ? options : options && options.contentKeyName ? options.contentKeyName : "__content"; + let passThroughOptions = options && typeof options === "object" ? options : void 0; + let re = /^(-{3}(?:\n|\r)([\w\W]+?)(?:\n|\r)-{3})?([\w\W]*)*/, results = re.exec(text), conf = {}, yamlOrJson; + if (yamlOrJson = results[2]) { + if (yamlOrJson.charAt(0) === "{") { + conf = JSON.parse(yamlOrJson); + } else { + if (loadSafe) { + conf = jsYaml.safeLoad(yamlOrJson, passThroughOptions); + } else { + conf = jsYaml.load(yamlOrJson, passThroughOptions); + } + } + } + conf[contentKeyName] = results[3] || ""; + return conf; +} +function loadFront(content, options) { + return parse(content, options, false); +} + +// node_modules/yaml/browser/dist/nodes/Node.js +var ALIAS = Symbol.for("yaml.alias"); +var DOC = Symbol.for("yaml.document"); +var MAP = Symbol.for("yaml.map"); +var PAIR = Symbol.for("yaml.pair"); +var SCALAR = Symbol.for("yaml.scalar"); +var SEQ = Symbol.for("yaml.seq"); +var NODE_TYPE = Symbol.for("yaml.node.type"); +var isAlias = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === ALIAS; +var isDocument = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === DOC; +var isMap = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === MAP; +var isPair = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === PAIR; +var isScalar = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SCALAR; +var isSeq = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SEQ; +function isCollection(node) { + if (node && typeof node === "object") + switch (node[NODE_TYPE]) { + case MAP: + case SEQ: + return true; + } + return false; +} +function isNode(node) { + if (node && typeof node === "object") + switch (node[NODE_TYPE]) { + case ALIAS: + case MAP: + case SCALAR: + case SEQ: + return true; + } + return false; +} +var hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor; +var NodeBase = class { + constructor(type) { + Object.defineProperty(this, NODE_TYPE, { value: type }); + } + clone() { + const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this)); + if (this.range) + copy.range = this.range.slice(); + return copy; + } +}; + +// node_modules/yaml/browser/dist/visit.js +var BREAK = Symbol("break visit"); +var SKIP = Symbol("skip children"); +var REMOVE = Symbol("remove node"); +function visit(node, visitor) { + const visitor_ = initVisitor(visitor); + if (isDocument(node)) { + const cd = visit_(null, node.contents, visitor_, Object.freeze([node])); + if (cd === REMOVE) + node.contents = null; + } else + visit_(null, node, visitor_, Object.freeze([])); +} +visit.BREAK = BREAK; +visit.SKIP = SKIP; +visit.REMOVE = REMOVE; +function visit_(key, node, visitor, path) { + const ctrl = callVisitor(key, node, visitor, path); + if (isNode(ctrl) || isPair(ctrl)) { + replaceNode(key, path, ctrl); + return visit_(key, ctrl, visitor, path); + } + if (typeof ctrl !== "symbol") { + if (isCollection(node)) { + path = Object.freeze(path.concat(node)); + for (let i = 0; i < node.items.length; ++i) { + const ci = visit_(i, node.items[i], visitor, path); + if (typeof ci === "number") + i = ci - 1; + else if (ci === BREAK) + return BREAK; + else if (ci === REMOVE) { + node.items.splice(i, 1); + i -= 1; + } + } + } else if (isPair(node)) { + path = Object.freeze(path.concat(node)); + const ck = visit_("key", node.key, visitor, path); + if (ck === BREAK) + return BREAK; + else if (ck === REMOVE) + node.key = null; + const cv = visit_("value", node.value, visitor, path); + if (cv === BREAK) + return BREAK; + else if (cv === REMOVE) + node.value = null; + } + } + return ctrl; +} +function visitAsync(node, visitor) { + return __async(this, null, function* () { + const visitor_ = initVisitor(visitor); + if (isDocument(node)) { + const cd = yield visitAsync_(null, node.contents, visitor_, Object.freeze([node])); + if (cd === REMOVE) + node.contents = null; + } else + yield visitAsync_(null, node, visitor_, Object.freeze([])); + }); +} +visitAsync.BREAK = BREAK; +visitAsync.SKIP = SKIP; +visitAsync.REMOVE = REMOVE; +function visitAsync_(key, node, visitor, path) { + return __async(this, null, function* () { + const ctrl = yield callVisitor(key, node, visitor, path); + if (isNode(ctrl) || isPair(ctrl)) { + replaceNode(key, path, ctrl); + return visitAsync_(key, ctrl, visitor, path); + } + if (typeof ctrl !== "symbol") { + if (isCollection(node)) { + path = Object.freeze(path.concat(node)); + for (let i = 0; i < node.items.length; ++i) { + const ci = yield visitAsync_(i, node.items[i], visitor, path); + if (typeof ci === "number") + i = ci - 1; + else if (ci === BREAK) + return BREAK; + else if (ci === REMOVE) { + node.items.splice(i, 1); + i -= 1; + } + } + } else if (isPair(node)) { + path = Object.freeze(path.concat(node)); + const ck = yield visitAsync_("key", node.key, visitor, path); + if (ck === BREAK) + return BREAK; + else if (ck === REMOVE) + node.key = null; + const cv = yield visitAsync_("value", node.value, visitor, path); + if (cv === BREAK) + return BREAK; + else if (cv === REMOVE) + node.value = null; + } + } + return ctrl; + }); +} +function initVisitor(visitor) { + if (typeof visitor === "object" && (visitor.Collection || visitor.Node || visitor.Value)) { + return Object.assign({ + Alias: visitor.Node, + Map: visitor.Node, + Scalar: visitor.Node, + Seq: visitor.Node + }, visitor.Value && { + Map: visitor.Value, + Scalar: visitor.Value, + Seq: visitor.Value + }, visitor.Collection && { + Map: visitor.Collection, + Seq: visitor.Collection + }, visitor); + } + return visitor; +} +function callVisitor(key, node, visitor, path) { + var _a, _b, _c, _d, _e; + if (typeof visitor === "function") + return visitor(key, node, path); + if (isMap(node)) + return (_a = visitor.Map) == null ? void 0 : _a.call(visitor, key, node, path); + if (isSeq(node)) + return (_b = visitor.Seq) == null ? void 0 : _b.call(visitor, key, node, path); + if (isPair(node)) + return (_c = visitor.Pair) == null ? void 0 : _c.call(visitor, key, node, path); + if (isScalar(node)) + return (_d = visitor.Scalar) == null ? void 0 : _d.call(visitor, key, node, path); + if (isAlias(node)) + return (_e = visitor.Alias) == null ? void 0 : _e.call(visitor, key, node, path); + return void 0; +} +function replaceNode(key, path, node) { + const parent = path[path.length - 1]; + if (isCollection(parent)) { + parent.items[key] = node; + } else if (isPair(parent)) { + if (key === "key") + parent.key = node; + else + parent.value = node; + } else if (isDocument(parent)) { + parent.contents = node; + } else { + const pt = isAlias(parent) ? "alias" : "scalar"; + throw new Error(`Cannot replace node with ${pt} parent`); + } +} + +// node_modules/yaml/browser/dist/doc/directives.js +var escapeChars = { + "!": "%21", + ",": "%2C", + "[": "%5B", + "]": "%5D", + "{": "%7B", + "}": "%7D" +}; +var escapeTagName = (tn) => tn.replace(/[!,[\]{}]/g, (ch) => escapeChars[ch]); +var Directives = class { + constructor(yaml2, tags) { + this.docStart = null; + this.docEnd = false; + this.yaml = Object.assign({}, Directives.defaultYaml, yaml2); + this.tags = Object.assign({}, Directives.defaultTags, tags); + } + clone() { + const copy = new Directives(this.yaml, this.tags); + copy.docStart = this.docStart; + return copy; + } + atDocument() { + const res = new Directives(this.yaml, this.tags); + switch (this.yaml.version) { + case "1.1": + this.atNextDocument = true; + break; + case "1.2": + this.atNextDocument = false; + this.yaml = { + explicit: Directives.defaultYaml.explicit, + version: "1.2" + }; + this.tags = Object.assign({}, Directives.defaultTags); + break; + } + return res; + } + add(line, onError) { + if (this.atNextDocument) { + this.yaml = { explicit: Directives.defaultYaml.explicit, version: "1.1" }; + this.tags = Object.assign({}, Directives.defaultTags); + this.atNextDocument = false; + } + const parts = line.trim().split(/[ \t]+/); + const name = parts.shift(); + switch (name) { + case "%TAG": { + if (parts.length !== 2) { + onError(0, "%TAG directive should contain exactly two parts"); + if (parts.length < 2) + return false; + } + const [handle, prefix] = parts; + this.tags[handle] = prefix; + return true; + } + case "%YAML": { + this.yaml.explicit = true; + if (parts.length !== 1) { + onError(0, "%YAML directive should contain exactly one part"); + return false; + } + const [version] = parts; + if (version === "1.1" || version === "1.2") { + this.yaml.version = version; + return true; + } else { + const isValid = /^\d+\.\d+$/.test(version); + onError(6, `Unsupported YAML version ${version}`, isValid); + return false; + } + } + default: + onError(0, `Unknown directive ${name}`, true); + return false; + } + } + tagName(source, onError) { + if (source === "!") + return "!"; + if (source[0] !== "!") { + onError(`Not a valid tag: ${source}`); + return null; + } + if (source[1] === "<") { + const verbatim = source.slice(2, -1); + if (verbatim === "!" || verbatim === "!!") { + onError(`Verbatim tags aren't resolved, so ${source} is invalid.`); + return null; + } + if (source[source.length - 1] !== ">") + onError("Verbatim tags must end with a >"); + return verbatim; + } + const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/); + if (!suffix) + onError(`The ${source} tag has no suffix`); + const prefix = this.tags[handle]; + if (prefix) + return prefix + decodeURIComponent(suffix); + if (handle === "!") + return source; + onError(`Could not resolve tag: ${source}`); + return null; + } + tagString(tag) { + for (const [handle, prefix] of Object.entries(this.tags)) { + if (tag.startsWith(prefix)) + return handle + escapeTagName(tag.substring(prefix.length)); + } + return tag[0] === "!" ? tag : `!<${tag}>`; + } + toString(doc) { + const lines = this.yaml.explicit ? [`%YAML ${this.yaml.version || "1.2"}`] : []; + const tagEntries = Object.entries(this.tags); + let tagNames; + if (doc && tagEntries.length > 0 && isNode(doc.contents)) { + const tags = {}; + visit(doc.contents, (_key, node) => { + if (isNode(node) && node.tag) + tags[node.tag] = true; + }); + tagNames = Object.keys(tags); + } else + tagNames = []; + for (const [handle, prefix] of tagEntries) { + if (handle === "!!" && prefix === "tag:yaml.org,2002:") + continue; + if (!doc || tagNames.some((tn) => tn.startsWith(prefix))) + lines.push(`%TAG ${handle} ${prefix}`); + } + return lines.join("\n"); + } +}; +Directives.defaultYaml = { explicit: false, version: "1.2" }; +Directives.defaultTags = { "!!": "tag:yaml.org,2002:" }; + +// node_modules/yaml/browser/dist/doc/anchors.js +function anchorIsValid(anchor) { + if (/[\x00-\x19\s,[\]{}]/.test(anchor)) { + const sa = JSON.stringify(anchor); + const msg = `Anchor must not contain whitespace or control characters: ${sa}`; + throw new Error(msg); + } + return true; +} +function anchorNames(root) { + const anchors = new Set(); + visit(root, { + Value(_key, node) { + if (node.anchor) + anchors.add(node.anchor); + } + }); + return anchors; +} +function findNewAnchor(prefix, exclude) { + for (let i = 1; true; ++i) { + const name = `${prefix}${i}`; + if (!exclude.has(name)) + return name; + } +} +function createNodeAnchors(doc, prefix) { + const aliasObjects = []; + const sourceObjects = new Map(); + let prevAnchors = null; + return { + onAnchor: (source) => { + aliasObjects.push(source); + if (!prevAnchors) + prevAnchors = anchorNames(doc); + const anchor = findNewAnchor(prefix, prevAnchors); + prevAnchors.add(anchor); + return anchor; + }, + setAnchors: () => { + for (const source of aliasObjects) { + const ref = sourceObjects.get(source); + if (typeof ref === "object" && ref.anchor && (isScalar(ref.node) || isCollection(ref.node))) { + ref.node.anchor = ref.anchor; + } else { + const error = new Error("Failed to resolve repeated object (this should not happen)"); + error.source = source; + throw error; + } + } + }, + sourceObjects + }; +} + +// node_modules/yaml/browser/dist/nodes/Alias.js +var Alias = class extends NodeBase { + constructor(source) { + super(ALIAS); + this.source = source; + Object.defineProperty(this, "tag", { + set() { + throw new Error("Alias nodes cannot have tags"); + } + }); + } + resolve(doc) { + let found = void 0; + visit(doc, { + Node: (_key, node) => { + if (node === this) + return visit.BREAK; + if (node.anchor === this.source) + found = node; + } + }); + return found; + } + toJSON(_arg, ctx) { + if (!ctx) + return { source: this.source }; + const { anchors, doc, maxAliasCount } = ctx; + const source = this.resolve(doc); + if (!source) { + const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`; + throw new ReferenceError(msg); + } + const data = anchors.get(source); + if (!data || data.res === void 0) { + const msg = "This should not happen: Alias anchor was not resolved?"; + throw new ReferenceError(msg); + } + if (maxAliasCount >= 0) { + data.count += 1; + if (data.aliasCount === 0) + data.aliasCount = getAliasCount(doc, source, anchors); + if (data.count * data.aliasCount > maxAliasCount) { + const msg = "Excessive alias count indicates a resource exhaustion attack"; + throw new ReferenceError(msg); + } + } + return data.res; + } + toString(ctx, _onComment, _onChompKeep) { + const src = `*${this.source}`; + if (ctx) { + anchorIsValid(this.source); + if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) { + const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`; + throw new Error(msg); + } + if (ctx.implicitKey) + return `${src} `; + } + return src; + } +}; +function getAliasCount(doc, node, anchors) { + if (isAlias(node)) { + const source = node.resolve(doc); + const anchor = anchors && source && anchors.get(source); + return anchor ? anchor.count * anchor.aliasCount : 0; + } else if (isCollection(node)) { + let count = 0; + for (const item of node.items) { + const c = getAliasCount(doc, item, anchors); + if (c > count) + count = c; + } + return count; + } else if (isPair(node)) { + const kc = getAliasCount(doc, node.key, anchors); + const vc = getAliasCount(doc, node.value, anchors); + return Math.max(kc, vc); + } + return 1; +} + +// node_modules/yaml/browser/dist/nodes/toJS.js +function toJS(value, arg, ctx) { + if (Array.isArray(value)) + return value.map((v, i) => toJS(v, String(i), ctx)); + if (value && typeof value.toJSON === "function") { + if (!ctx || !hasAnchor(value)) + return value.toJSON(arg, ctx); + const data = { aliasCount: 0, count: 1, res: void 0 }; + ctx.anchors.set(value, data); + ctx.onCreate = (res2) => { + data.res = res2; + delete ctx.onCreate; + }; + const res = value.toJSON(arg, ctx); + if (ctx.onCreate) + ctx.onCreate(res); + return res; + } + if (typeof value === "bigint" && !(ctx == null ? void 0 : ctx.keep)) + return Number(value); + return value; +} + +// node_modules/yaml/browser/dist/nodes/Scalar.js +var isScalarValue = (value) => !value || typeof value !== "function" && typeof value !== "object"; +var Scalar = class extends NodeBase { + constructor(value) { + super(SCALAR); + this.value = value; + } + toJSON(arg, ctx) { + return (ctx == null ? void 0 : ctx.keep) ? this.value : toJS(this.value, arg, ctx); + } + toString() { + return String(this.value); + } +}; +Scalar.BLOCK_FOLDED = "BLOCK_FOLDED"; +Scalar.BLOCK_LITERAL = "BLOCK_LITERAL"; +Scalar.PLAIN = "PLAIN"; +Scalar.QUOTE_DOUBLE = "QUOTE_DOUBLE"; +Scalar.QUOTE_SINGLE = "QUOTE_SINGLE"; + +// node_modules/yaml/browser/dist/doc/createNode.js +var defaultTagPrefix = "tag:yaml.org,2002:"; +function findTagObject(value, tagName, tags) { + var _a; + if (tagName) { + const match = tags.filter((t) => t.tag === tagName); + const tagObj = (_a = match.find((t) => !t.format)) != null ? _a : match[0]; + if (!tagObj) + throw new Error(`Tag ${tagName} not found`); + return tagObj; + } + return tags.find((t) => { + var _a2; + return ((_a2 = t.identify) == null ? void 0 : _a2.call(t, value)) && !t.format; + }); +} +function createNode(value, tagName, ctx) { + var _a, _b; + if (isDocument(value)) + value = value.contents; + if (isNode(value)) + return value; + if (isPair(value)) { + const map2 = (_b = (_a = ctx.schema[MAP]).createNode) == null ? void 0 : _b.call(_a, ctx.schema, null, ctx); + map2.items.push(value); + return map2; + } + if (value instanceof String || value instanceof Number || value instanceof Boolean || typeof BigInt === "function" && value instanceof BigInt) { + value = value.valueOf(); + } + const { aliasDuplicateObjects, onAnchor, onTagObj, schema: schema4, sourceObjects } = ctx; + let ref = void 0; + if (aliasDuplicateObjects && value && typeof value === "object") { + ref = sourceObjects.get(value); + if (ref) { + if (!ref.anchor) + ref.anchor = onAnchor(value); + return new Alias(ref.anchor); + } else { + ref = { anchor: null, node: null }; + sourceObjects.set(value, ref); + } + } + if (tagName == null ? void 0 : tagName.startsWith("!!")) + tagName = defaultTagPrefix + tagName.slice(2); + let tagObj = findTagObject(value, tagName, schema4.tags); + if (!tagObj) { + if (value && typeof value.toJSON === "function") { + value = value.toJSON(); + } + if (!value || typeof value !== "object") { + const node2 = new Scalar(value); + if (ref) + ref.node = node2; + return node2; + } + tagObj = value instanceof Map ? schema4[MAP] : Symbol.iterator in Object(value) ? schema4[SEQ] : schema4[MAP]; + } + if (onTagObj) { + onTagObj(tagObj); + delete ctx.onTagObj; + } + const node = (tagObj == null ? void 0 : tagObj.createNode) ? tagObj.createNode(ctx.schema, value, ctx) : new Scalar(value); + if (tagName) + node.tag = tagName; + if (ref) + ref.node = node; + return node; +} + +// node_modules/yaml/browser/dist/nodes/Collection.js +function collectionFromPath(schema4, path, value) { + let v = value; + for (let i = path.length - 1; i >= 0; --i) { + const k = path[i]; + if (typeof k === "number" && Number.isInteger(k) && k >= 0) { + const a = []; + a[k] = v; + v = a; + } else { + v = new Map([[k, v]]); + } + } + return createNode(v, void 0, { + aliasDuplicateObjects: false, + keepUndefined: false, + onAnchor: () => { + throw new Error("This should not happen, please report a bug."); + }, + schema: schema4, + sourceObjects: new Map() + }); +} +var isEmptyPath = (path) => path == null || typeof path === "object" && !!path[Symbol.iterator]().next().done; +var Collection = class extends NodeBase { + constructor(type, schema4) { + super(type); + Object.defineProperty(this, "schema", { + value: schema4, + configurable: true, + enumerable: false, + writable: true + }); + } + clone(schema4) { + const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this)); + if (schema4) + copy.schema = schema4; + copy.items = copy.items.map((it) => isNode(it) || isPair(it) ? it.clone(schema4) : it); + if (this.range) + copy.range = this.range.slice(); + return copy; + } + addIn(path, value) { + if (isEmptyPath(path)) + this.add(value); + else { + const [key, ...rest] = path; + const node = this.get(key, true); + if (isCollection(node)) + node.addIn(rest, value); + else if (node === void 0 && this.schema) + this.set(key, collectionFromPath(this.schema, rest, value)); + else + throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`); + } + } + deleteIn(path) { + const [key, ...rest] = path; + if (rest.length === 0) + return this.delete(key); + const node = this.get(key, true); + if (isCollection(node)) + return node.deleteIn(rest); + else + throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`); + } + getIn(path, keepScalar) { + const [key, ...rest] = path; + const node = this.get(key, true); + if (rest.length === 0) + return !keepScalar && isScalar(node) ? node.value : node; + else + return isCollection(node) ? node.getIn(rest, keepScalar) : void 0; + } + hasAllNullValues(allowScalar) { + return this.items.every((node) => { + if (!isPair(node)) + return false; + const n = node.value; + return n == null || allowScalar && isScalar(n) && n.value == null && !n.commentBefore && !n.comment && !n.tag; + }); + } + hasIn(path) { + const [key, ...rest] = path; + if (rest.length === 0) + return this.has(key); + const node = this.get(key, true); + return isCollection(node) ? node.hasIn(rest) : false; + } + setIn(path, value) { + const [key, ...rest] = path; + if (rest.length === 0) { + this.set(key, value); + } else { + const node = this.get(key, true); + if (isCollection(node)) + node.setIn(rest, value); + else if (node === void 0 && this.schema) + this.set(key, collectionFromPath(this.schema, rest, value)); + else + throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`); + } + } +}; +Collection.maxFlowStringSingleLineLength = 60; + +// node_modules/yaml/browser/dist/stringify/stringifyComment.js +var stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, "#"); +function indentComment(comment, indent) { + if (/^\n+$/.test(comment)) + return comment.substring(1); + return indent ? comment.replace(/^(?! *$)/gm, indent) : comment; +} +var lineComment = (str, indent, comment) => str.endsWith("\n") ? indentComment(comment, indent) : comment.includes("\n") ? "\n" + indentComment(comment, indent) : (str.endsWith(" ") ? "" : " ") + comment; + +// node_modules/yaml/browser/dist/stringify/foldFlowLines.js +var FOLD_FLOW = "flow"; +var FOLD_BLOCK = "block"; +var FOLD_QUOTED = "quoted"; +function foldFlowLines(text, indent, mode = "flow", { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) { + if (!lineWidth || lineWidth < 0) + return text; + const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length); + if (text.length <= endStep) + return text; + const folds = []; + const escapedFolds = {}; + let end = lineWidth - indent.length; + if (typeof indentAtStart === "number") { + if (indentAtStart > lineWidth - Math.max(2, minContentWidth)) + folds.push(0); + else + end = lineWidth - indentAtStart; + } + let split = void 0; + let prev = void 0; + let overflow = false; + let i = -1; + let escStart = -1; + let escEnd = -1; + if (mode === FOLD_BLOCK) { + i = consumeMoreIndentedLines(text, i); + if (i !== -1) + end = i + endStep; + } + for (let ch; ch = text[i += 1]; ) { + if (mode === FOLD_QUOTED && ch === "\\") { + escStart = i; + switch (text[i + 1]) { + case "x": + i += 3; + break; + case "u": + i += 5; + break; + case "U": + i += 9; + break; + default: + i += 1; + } + escEnd = i; + } + if (ch === "\n") { + if (mode === FOLD_BLOCK) + i = consumeMoreIndentedLines(text, i); + end = i + endStep; + split = void 0; + } else { + if (ch === " " && prev && prev !== " " && prev !== "\n" && prev !== " ") { + const next = text[i + 1]; + if (next && next !== " " && next !== "\n" && next !== " ") + split = i; + } + if (i >= end) { + if (split) { + folds.push(split); + end = split + endStep; + split = void 0; + } else if (mode === FOLD_QUOTED) { + while (prev === " " || prev === " ") { + prev = ch; + ch = text[i += 1]; + overflow = true; + } + const j = i > escEnd + 1 ? i - 2 : escStart - 1; + if (escapedFolds[j]) + return text; + folds.push(j); + escapedFolds[j] = true; + end = j + endStep; + split = void 0; + } else { + overflow = true; + } + } + } + prev = ch; + } + if (overflow && onOverflow) + onOverflow(); + if (folds.length === 0) + return text; + if (onFold) + onFold(); + let res = text.slice(0, folds[0]); + for (let i2 = 0; i2 < folds.length; ++i2) { + const fold = folds[i2]; + const end2 = folds[i2 + 1] || text.length; + if (fold === 0) + res = ` +${indent}${text.slice(0, end2)}`; + else { + if (mode === FOLD_QUOTED && escapedFolds[fold]) + res += `${text[fold]}\\`; + res += ` +${indent}${text.slice(fold + 1, end2)}`; + } + } + return res; +} +function consumeMoreIndentedLines(text, i) { + let ch = text[i + 1]; + while (ch === " " || ch === " ") { + do { + ch = text[i += 1]; + } while (ch && ch !== "\n"); + ch = text[i + 1]; + } + return i; +} + +// node_modules/yaml/browser/dist/stringify/stringifyString.js +var getFoldOptions = (ctx) => ({ + indentAtStart: ctx.indentAtStart, + lineWidth: ctx.options.lineWidth, + minContentWidth: ctx.options.minContentWidth +}); +var containsDocumentMarker = (str) => /^(%|---|\.\.\.)/m.test(str); +function lineLengthOverLimit(str, lineWidth, indentLength) { + if (!lineWidth || lineWidth < 0) + return false; + const limit = lineWidth - indentLength; + const strLen = str.length; + if (strLen <= limit) + return false; + for (let i = 0, start = 0; i < strLen; ++i) { + if (str[i] === "\n") { + if (i - start > limit) + return true; + start = i + 1; + if (strLen - start <= limit) + return false; + } + } + return true; +} +function doubleQuotedString(value, ctx) { + const json = JSON.stringify(value); + if (ctx.options.doubleQuotedAsJSON) + return json; + const { implicitKey } = ctx; + const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength; + const indent = ctx.indent || (containsDocumentMarker(value) ? " " : ""); + let str = ""; + let start = 0; + for (let i = 0, ch = json[i]; ch; ch = json[++i]) { + if (ch === " " && json[i + 1] === "\\" && json[i + 2] === "n") { + str += json.slice(start, i) + "\\ "; + i += 1; + start = i; + ch = "\\"; + } + if (ch === "\\") + switch (json[i + 1]) { + case "u": + { + str += json.slice(start, i); + const code = json.substr(i + 2, 4); + switch (code) { + case "0000": + str += "\\0"; + break; + case "0007": + str += "\\a"; + break; + case "000b": + str += "\\v"; + break; + case "001b": + str += "\\e"; + break; + case "0085": + str += "\\N"; + break; + case "00a0": + str += "\\_"; + break; + case "2028": + str += "\\L"; + break; + case "2029": + str += "\\P"; + break; + default: + if (code.substr(0, 2) === "00") + str += "\\x" + code.substr(2); + else + str += json.substr(i, 6); + } + i += 5; + start = i + 1; + } + break; + case "n": + if (implicitKey || json[i + 2] === '"' || json.length < minMultiLineLength) { + i += 1; + } else { + str += json.slice(start, i) + "\n\n"; + while (json[i + 2] === "\\" && json[i + 3] === "n" && json[i + 4] !== '"') { + str += "\n"; + i += 2; + } + str += indent; + if (json[i + 2] === " ") + str += "\\"; + i += 1; + start = i + 1; + } + break; + default: + i += 1; + } + } + str = start ? str + json.slice(start) : json; + return implicitKey ? str : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx)); +} +function singleQuotedString(value, ctx) { + if (ctx.options.singleQuote === false || ctx.implicitKey && value.includes("\n") || /[ \t]\n|\n[ \t]/.test(value)) + return doubleQuotedString(value, ctx); + const indent = ctx.indent || (containsDocumentMarker(value) ? " " : ""); + const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$& +${indent}`) + "'"; + return ctx.implicitKey ? res : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx)); +} +function quotedString(value, ctx) { + const { singleQuote } = ctx.options; + let qs; + if (singleQuote === false) + qs = doubleQuotedString; + else { + const hasDouble = value.includes('"'); + const hasSingle = value.includes("'"); + if (hasDouble && !hasSingle) + qs = singleQuotedString; + else if (hasSingle && !hasDouble) + qs = doubleQuotedString; + else + qs = singleQuote ? singleQuotedString : doubleQuotedString; + } + return qs(value, ctx); +} +function blockString({ comment, type, value }, ctx, onComment, onChompKeep) { + const { blockQuote, commentString, lineWidth } = ctx.options; + if (!blockQuote || /\n[\t ]+$/.test(value) || /^\s*$/.test(value)) { + return quotedString(value, ctx); + } + const indent = ctx.indent || (ctx.forceBlockIndent || containsDocumentMarker(value) ? " " : ""); + const literal = blockQuote === "literal" ? true : blockQuote === "folded" || type === Scalar.BLOCK_FOLDED ? false : type === Scalar.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, lineWidth, indent.length); + if (!value) + return literal ? "|\n" : ">\n"; + let chomp; + let endStart; + for (endStart = value.length; endStart > 0; --endStart) { + const ch = value[endStart - 1]; + if (ch !== "\n" && ch !== " " && ch !== " ") + break; + } + let end = value.substring(endStart); + const endNlPos = end.indexOf("\n"); + if (endNlPos === -1) { + chomp = "-"; + } else if (value === end || endNlPos !== end.length - 1) { + chomp = "+"; + if (onChompKeep) + onChompKeep(); + } else { + chomp = ""; + } + if (end) { + value = value.slice(0, -end.length); + if (end[end.length - 1] === "\n") + end = end.slice(0, -1); + end = end.replace(/\n+(?!\n|$)/g, `$&${indent}`); + } + let startWithSpace = false; + let startEnd; + let startNlPos = -1; + for (startEnd = 0; startEnd < value.length; ++startEnd) { + const ch = value[startEnd]; + if (ch === " ") + startWithSpace = true; + else if (ch === "\n") + startNlPos = startEnd; + else + break; + } + let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd); + if (start) { + value = value.substring(start.length); + start = start.replace(/\n+/g, `$&${indent}`); + } + const indentSize = indent ? "2" : "1"; + let header = (literal ? "|" : ">") + (startWithSpace ? indentSize : "") + chomp; + if (comment) { + header += " " + commentString(comment.replace(/ ?[\r\n]+/g, " ")); + if (onComment) + onComment(); + } + if (literal) { + value = value.replace(/\n+/g, `$&${indent}`); + return `${header} +${indent}${start}${value}${end}`; + } + value = value.replace(/\n+/g, "\n$&").replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${indent}`); + const body = foldFlowLines(`${start}${value}${end}`, indent, FOLD_BLOCK, getFoldOptions(ctx)); + return `${header} +${indent}${body}`; +} +function plainString(item, ctx, onComment, onChompKeep) { + const { type, value } = item; + const { actualString, implicitKey, indent, inFlow } = ctx; + if (implicitKey && /[\n[\]{},]/.test(value) || inFlow && /[[\]{},]/.test(value)) { + return quotedString(value, ctx); + } + if (!value || /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) { + return implicitKey || inFlow || !value.includes("\n") ? quotedString(value, ctx) : blockString(item, ctx, onComment, onChompKeep); + } + if (!implicitKey && !inFlow && type !== Scalar.PLAIN && value.includes("\n")) { + return blockString(item, ctx, onComment, onChompKeep); + } + if (indent === "" && containsDocumentMarker(value)) { + ctx.forceBlockIndent = true; + return blockString(item, ctx, onComment, onChompKeep); + } + const str = value.replace(/\n+/g, `$& +${indent}`); + if (actualString) { + const test = (tag) => { + var _a; + return tag.default && tag.tag !== "tag:yaml.org,2002:str" && ((_a = tag.test) == null ? void 0 : _a.test(str)); + }; + const { compat, tags } = ctx.doc.schema; + if (tags.some(test) || (compat == null ? void 0 : compat.some(test))) + return quotedString(value, ctx); + } + return implicitKey ? str : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx)); +} +function stringifyString(item, ctx, onComment, onChompKeep) { + const { implicitKey, inFlow } = ctx; + const ss = typeof item.value === "string" ? item : Object.assign({}, item, { value: String(item.value) }); + let { type } = item; + if (type !== Scalar.QUOTE_DOUBLE) { + if (/[\x00-\x08\x0b-\x1f\x7f-\x9f\u{D800}-\u{DFFF}]/u.test(ss.value)) + type = Scalar.QUOTE_DOUBLE; + } + const _stringify = (_type) => { + switch (_type) { + case Scalar.BLOCK_FOLDED: + case Scalar.BLOCK_LITERAL: + return implicitKey || inFlow ? quotedString(ss.value, ctx) : blockString(ss, ctx, onComment, onChompKeep); + case Scalar.QUOTE_DOUBLE: + return doubleQuotedString(ss.value, ctx); + case Scalar.QUOTE_SINGLE: + return singleQuotedString(ss.value, ctx); + case Scalar.PLAIN: + return plainString(ss, ctx, onComment, onChompKeep); + default: + return null; + } + }; + let res = _stringify(type); + if (res === null) { + const { defaultKeyType, defaultStringType } = ctx.options; + const t = implicitKey && defaultKeyType || defaultStringType; + res = _stringify(t); + if (res === null) + throw new Error(`Unsupported default string type ${t}`); + } + return res; +} + +// node_modules/yaml/browser/dist/stringify/stringify.js +function createStringifyContext(doc, options) { + const opt = Object.assign({ + blockQuote: true, + commentString: stringifyComment, + defaultKeyType: null, + defaultStringType: "PLAIN", + directives: null, + doubleQuotedAsJSON: false, + doubleQuotedMinMultiLineLength: 40, + falseStr: "false", + indentSeq: true, + lineWidth: 80, + minContentWidth: 20, + nullStr: "null", + simpleKeys: false, + singleQuote: null, + trueStr: "true", + verifyAliasOrder: true + }, doc.schema.toStringOptions, options); + let inFlow; + switch (opt.collectionStyle) { + case "block": + inFlow = false; + break; + case "flow": + inFlow = true; + break; + default: + inFlow = null; + } + return { + anchors: new Set(), + doc, + indent: "", + indentStep: typeof opt.indent === "number" ? " ".repeat(opt.indent) : " ", + inFlow, + options: opt + }; +} +function getTagObject(tags, item) { + var _a, _b, _c, _d; + if (item.tag) { + const match = tags.filter((t) => t.tag === item.tag); + if (match.length > 0) + return (_a = match.find((t) => t.format === item.format)) != null ? _a : match[0]; + } + let tagObj = void 0; + let obj; + if (isScalar(item)) { + obj = item.value; + const match = tags.filter((t) => { + var _a2; + return (_a2 = t.identify) == null ? void 0 : _a2.call(t, obj); + }); + tagObj = (_b = match.find((t) => t.format === item.format)) != null ? _b : match.find((t) => !t.format); + } else { + obj = item; + tagObj = tags.find((t) => t.nodeClass && obj instanceof t.nodeClass); + } + if (!tagObj) { + const name = (_d = (_c = obj == null ? void 0 : obj.constructor) == null ? void 0 : _c.name) != null ? _d : typeof obj; + throw new Error(`Tag not resolved for ${name} value`); + } + return tagObj; +} +function stringifyProps(node, tagObj, { anchors, doc }) { + if (!doc.directives) + return ""; + const props = []; + const anchor = (isScalar(node) || isCollection(node)) && node.anchor; + if (anchor && anchorIsValid(anchor)) { + anchors.add(anchor); + props.push(`&${anchor}`); + } + const tag = node.tag ? node.tag : tagObj.default ? null : tagObj.tag; + if (tag) + props.push(doc.directives.tagString(tag)); + return props.join(" "); +} +function stringify(item, ctx, onComment, onChompKeep) { + var _a, _b; + if (isPair(item)) + return item.toString(ctx, onComment, onChompKeep); + if (isAlias(item)) { + if (ctx.doc.directives) + return item.toString(ctx); + if ((_a = ctx.resolvedAliases) == null ? void 0 : _a.has(item)) { + throw new TypeError(`Cannot stringify circular structure without alias nodes`); + } else { + if (ctx.resolvedAliases) + ctx.resolvedAliases.add(item); + else + ctx.resolvedAliases = new Set([item]); + item = item.resolve(ctx.doc); + } + } + let tagObj = void 0; + const node = isNode(item) ? item : ctx.doc.createNode(item, { onTagObj: (o) => tagObj = o }); + if (!tagObj) + tagObj = getTagObject(ctx.doc.schema.tags, node); + const props = stringifyProps(node, tagObj, ctx); + if (props.length > 0) + ctx.indentAtStart = ((_b = ctx.indentAtStart) != null ? _b : 0) + props.length + 1; + const str = typeof tagObj.stringify === "function" ? tagObj.stringify(node, ctx, onComment, onChompKeep) : isScalar(node) ? stringifyString(node, ctx, onComment, onChompKeep) : node.toString(ctx, onComment, onChompKeep); + if (!props) + return str; + return isScalar(node) || str[0] === "{" || str[0] === "[" ? `${props} ${str}` : `${props} +${ctx.indent}${str}`; +} + +// node_modules/yaml/browser/dist/stringify/stringifyPair.js +function stringifyPair({ key, value }, ctx, onComment, onChompKeep) { + const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx; + let keyComment = isNode(key) && key.comment || null; + if (simpleKeys) { + if (keyComment) { + throw new Error("With simple keys, key nodes cannot have comments"); + } + if (isCollection(key)) { + const msg = "With simple keys, collection cannot be used as a key value"; + throw new Error(msg); + } + } + let explicitKey = !simpleKeys && (!key || keyComment && value == null && !ctx.inFlow || isCollection(key) || (isScalar(key) ? key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL : typeof key === "object")); + ctx = Object.assign({}, ctx, { + allNullValues: false, + implicitKey: !explicitKey && (simpleKeys || !allNullValues), + indent: indent + indentStep + }); + let keyCommentDone = false; + let chompKeep = false; + let str = stringify(key, ctx, () => keyCommentDone = true, () => chompKeep = true); + if (!explicitKey && !ctx.inFlow && str.length > 1024) { + if (simpleKeys) + throw new Error("With simple keys, single line scalar must not span more than 1024 characters"); + explicitKey = true; + } + if (ctx.inFlow) { + if (allNullValues || value == null) { + if (keyCommentDone && onComment) + onComment(); + return str === "" ? "?" : explicitKey ? `? ${str}` : str; + } + } else if (allNullValues && !simpleKeys || value == null && explicitKey) { + str = `? ${str}`; + if (keyComment && !keyCommentDone) { + str += lineComment(str, ctx.indent, commentString(keyComment)); + } else if (chompKeep && onChompKeep) + onChompKeep(); + return str; + } + if (keyCommentDone) + keyComment = null; + if (explicitKey) { + if (keyComment) + str += lineComment(str, ctx.indent, commentString(keyComment)); + str = `? ${str} +${indent}:`; + } else { + str = `${str}:`; + if (keyComment) + str += lineComment(str, ctx.indent, commentString(keyComment)); + } + let vcb = ""; + let valueComment = null; + if (isNode(value)) { + if (value.spaceBefore) + vcb = "\n"; + if (value.commentBefore) { + const cs = commentString(value.commentBefore); + vcb += ` +${indentComment(cs, ctx.indent)}`; + } + valueComment = value.comment; + } else if (value && typeof value === "object") { + value = doc.createNode(value); + } + ctx.implicitKey = false; + if (!explicitKey && !keyComment && isScalar(value)) + ctx.indentAtStart = str.length + 1; + chompKeep = false; + if (!indentSeq && indentStep.length >= 2 && !ctx.inFlow && !explicitKey && isSeq(value) && !value.flow && !value.tag && !value.anchor) { + ctx.indent = ctx.indent.substr(2); + } + let valueCommentDone = false; + const valueStr = stringify(value, ctx, () => valueCommentDone = true, () => chompKeep = true); + let ws = " "; + if (vcb || keyComment) { + if (valueStr === "" && !ctx.inFlow) + ws = vcb === "\n" ? "\n\n" : vcb; + else + ws = `${vcb} +${ctx.indent}`; + } else if (!explicitKey && isCollection(value)) { + const flow = valueStr[0] === "[" || valueStr[0] === "{"; + if (!flow || valueStr.includes("\n")) + ws = ` +${ctx.indent}`; + } else if (valueStr === "" || valueStr[0] === "\n") + ws = ""; + str += ws + valueStr; + if (ctx.inFlow) { + if (valueCommentDone && onComment) + onComment(); + } else if (valueComment && !valueCommentDone) { + str += lineComment(str, ctx.indent, commentString(valueComment)); + } else if (chompKeep && onChompKeep) { + onChompKeep(); + } + return str; +} + +// node_modules/yaml/browser/dist/log.js +function warn(logLevel, warning) { + if (logLevel === "debug" || logLevel === "warn") { + if (typeof process !== "undefined" && process.emitWarning) + process.emitWarning(warning); + else + console.warn(warning); + } +} + +// node_modules/yaml/browser/dist/nodes/addPairToJSMap.js +var MERGE_KEY = "<<"; +function addPairToJSMap(ctx, map2, { key, value }) { + if ((ctx == null ? void 0 : ctx.doc.schema.merge) && isMergeKey(key)) { + value = isAlias(value) ? value.resolve(ctx.doc) : value; + if (isSeq(value)) + for (const it of value.items) + mergeToJSMap(ctx, map2, it); + else if (Array.isArray(value)) + for (const it of value) + mergeToJSMap(ctx, map2, it); + else + mergeToJSMap(ctx, map2, value); + } else { + const jsKey = toJS(key, "", ctx); + if (map2 instanceof Map) { + map2.set(jsKey, toJS(value, jsKey, ctx)); + } else if (map2 instanceof Set) { + map2.add(jsKey); + } else { + const stringKey = stringifyKey(key, jsKey, ctx); + const jsValue = toJS(value, stringKey, ctx); + if (stringKey in map2) + Object.defineProperty(map2, stringKey, { + value: jsValue, + writable: true, + enumerable: true, + configurable: true + }); + else + map2[stringKey] = jsValue; + } + } + return map2; +} +var isMergeKey = (key) => key === MERGE_KEY || isScalar(key) && key.value === MERGE_KEY && (!key.type || key.type === Scalar.PLAIN); +function mergeToJSMap(ctx, map2, value) { + const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : value; + if (!isMap(source)) + throw new Error("Merge sources must be maps or map aliases"); + const srcMap = source.toJSON(null, ctx, Map); + for (const [key, value2] of srcMap) { + if (map2 instanceof Map) { + if (!map2.has(key)) + map2.set(key, value2); + } else if (map2 instanceof Set) { + map2.add(key); + } else if (!Object.prototype.hasOwnProperty.call(map2, key)) { + Object.defineProperty(map2, key, { + value: value2, + writable: true, + enumerable: true, + configurable: true + }); + } + } + return map2; +} +function stringifyKey(key, jsKey, ctx) { + if (jsKey === null) + return ""; + if (typeof jsKey !== "object") + return String(jsKey); + if (isNode(key) && ctx && ctx.doc) { + const strCtx = createStringifyContext(ctx.doc, {}); + strCtx.anchors = new Set(); + for (const node of ctx.anchors.keys()) + strCtx.anchors.add(node.anchor); + strCtx.inFlow = true; + strCtx.inStringifyKey = true; + const strKey = key.toString(strCtx); + if (!ctx.mapKeyWarned) { + let jsonStr = JSON.stringify(strKey); + if (jsonStr.length > 40) + jsonStr = jsonStr.substring(0, 36) + '..."'; + warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`); + ctx.mapKeyWarned = true; + } + return strKey; + } + return JSON.stringify(jsKey); +} + +// node_modules/yaml/browser/dist/nodes/Pair.js +function createPair(key, value, ctx) { + const k = createNode(key, void 0, ctx); + const v = createNode(value, void 0, ctx); + return new Pair(k, v); +} +var Pair = class { + constructor(key, value = null) { + Object.defineProperty(this, NODE_TYPE, { value: PAIR }); + this.key = key; + this.value = value; + } + clone(schema4) { + let { key, value } = this; + if (isNode(key)) + key = key.clone(schema4); + if (isNode(value)) + value = value.clone(schema4); + return new Pair(key, value); + } + toJSON(_, ctx) { + const pair = (ctx == null ? void 0 : ctx.mapAsMap) ? new Map() : {}; + return addPairToJSMap(ctx, pair, this); + } + toString(ctx, onComment, onChompKeep) { + return (ctx == null ? void 0 : ctx.doc) ? stringifyPair(this, ctx, onComment, onChompKeep) : JSON.stringify(this); + } +}; + +// node_modules/yaml/browser/dist/stringify/stringifyCollection.js +function stringifyCollection(collection, ctx, options) { + var _a; + const flow = (_a = ctx.inFlow) != null ? _a : collection.flow; + const stringify4 = flow ? stringifyFlowCollection : stringifyBlockCollection; + return stringify4(collection, ctx, options); +} +function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) { + const { indent, options: { commentString } } = ctx; + const itemCtx = Object.assign({}, ctx, { indent: itemIndent, type: null }); + let chompKeep = false; + const lines = []; + for (let i = 0; i < items.length; ++i) { + const item = items[i]; + let comment2 = null; + if (isNode(item)) { + if (!chompKeep && item.spaceBefore) + lines.push(""); + addCommentBefore(ctx, lines, item.commentBefore, chompKeep); + if (item.comment) + comment2 = item.comment; + } else if (isPair(item)) { + const ik = isNode(item.key) ? item.key : null; + if (ik) { + if (!chompKeep && ik.spaceBefore) + lines.push(""); + addCommentBefore(ctx, lines, ik.commentBefore, chompKeep); + } + } + chompKeep = false; + let str2 = stringify(item, itemCtx, () => comment2 = null, () => chompKeep = true); + if (comment2) + str2 += lineComment(str2, itemIndent, commentString(comment2)); + if (chompKeep && comment2) + chompKeep = false; + lines.push(blockItemPrefix + str2); + } + let str; + if (lines.length === 0) { + str = flowChars.start + flowChars.end; + } else { + str = lines[0]; + for (let i = 1; i < lines.length; ++i) { + const line = lines[i]; + str += line ? ` +${indent}${line}` : "\n"; + } + } + if (comment) { + str += "\n" + indentComment(commentString(comment), indent); + if (onComment) + onComment(); + } else if (chompKeep && onChompKeep) + onChompKeep(); + return str; +} +function stringifyFlowCollection({ comment, items }, ctx, { flowChars, itemIndent, onComment }) { + const { indent, indentStep, options: { commentString } } = ctx; + itemIndent += indentStep; + const itemCtx = Object.assign({}, ctx, { + indent: itemIndent, + inFlow: true, + type: null + }); + let reqNewline = false; + let linesAtValue = 0; + const lines = []; + for (let i = 0; i < items.length; ++i) { + const item = items[i]; + let comment2 = null; + if (isNode(item)) { + if (item.spaceBefore) + lines.push(""); + addCommentBefore(ctx, lines, item.commentBefore, false); + if (item.comment) + comment2 = item.comment; + } else if (isPair(item)) { + const ik = isNode(item.key) ? item.key : null; + if (ik) { + if (ik.spaceBefore) + lines.push(""); + addCommentBefore(ctx, lines, ik.commentBefore, false); + if (ik.comment) + reqNewline = true; + } + const iv = isNode(item.value) ? item.value : null; + if (iv) { + if (iv.comment) + comment2 = iv.comment; + if (iv.commentBefore) + reqNewline = true; + } else if (item.value == null && ik && ik.comment) { + comment2 = ik.comment; + } + } + if (comment2) + reqNewline = true; + let str2 = stringify(item, itemCtx, () => comment2 = null); + if (i < items.length - 1) + str2 += ","; + if (comment2) + str2 += lineComment(str2, itemIndent, commentString(comment2)); + if (!reqNewline && (lines.length > linesAtValue || str2.includes("\n"))) + reqNewline = true; + lines.push(str2); + linesAtValue = lines.length; + } + let str; + const { start, end } = flowChars; + if (lines.length === 0) { + str = start + end; + } else { + if (!reqNewline) { + const len = lines.reduce((sum, line) => sum + line.length + 2, 2); + reqNewline = len > Collection.maxFlowStringSingleLineLength; + } + if (reqNewline) { + str = start; + for (const line of lines) + str += line ? ` +${indentStep}${indent}${line}` : "\n"; + str += ` +${indent}${end}`; + } else { + str = `${start} ${lines.join(" ")} ${end}`; + } + } + if (comment) { + str += lineComment(str, commentString(comment), indent); + if (onComment) + onComment(); + } + return str; +} +function addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) { + if (comment && chompKeep) + comment = comment.replace(/^\n+/, ""); + if (comment) { + const ic = indentComment(commentString(comment), indent); + lines.push(ic.trimStart()); + } +} + +// node_modules/yaml/browser/dist/nodes/YAMLMap.js +function findPair(items, key) { + const k = isScalar(key) ? key.value : key; + for (const it of items) { + if (isPair(it)) { + if (it.key === key || it.key === k) + return it; + if (isScalar(it.key) && it.key.value === k) + return it; + } + } + return void 0; +} +var YAMLMap = class extends Collection { + constructor(schema4) { + super(MAP, schema4); + this.items = []; + } + static get tagName() { + return "tag:yaml.org,2002:map"; + } + add(pair, overwrite) { + var _a; + let _pair; + if (isPair(pair)) + _pair = pair; + else if (!pair || typeof pair !== "object" || !("key" in pair)) { + _pair = new Pair(pair, pair == null ? void 0 : pair.value); + } else + _pair = new Pair(pair.key, pair.value); + const prev = findPair(this.items, _pair.key); + const sortEntries = (_a = this.schema) == null ? void 0 : _a.sortMapEntries; + if (prev) { + if (!overwrite) + throw new Error(`Key ${_pair.key} already set`); + if (isScalar(prev.value) && isScalarValue(_pair.value)) + prev.value.value = _pair.value; + else + prev.value = _pair.value; + } else if (sortEntries) { + const i = this.items.findIndex((item) => sortEntries(_pair, item) < 0); + if (i === -1) + this.items.push(_pair); + else + this.items.splice(i, 0, _pair); + } else { + this.items.push(_pair); + } + } + delete(key) { + const it = findPair(this.items, key); + if (!it) + return false; + const del = this.items.splice(this.items.indexOf(it), 1); + return del.length > 0; + } + get(key, keepScalar) { + var _a; + const it = findPair(this.items, key); + const node = it == null ? void 0 : it.value; + return (_a = !keepScalar && isScalar(node) ? node.value : node) != null ? _a : void 0; + } + has(key) { + return !!findPair(this.items, key); + } + set(key, value) { + this.add(new Pair(key, value), true); + } + toJSON(_, ctx, Type) { + const map2 = Type ? new Type() : (ctx == null ? void 0 : ctx.mapAsMap) ? new Map() : {}; + if (ctx == null ? void 0 : ctx.onCreate) + ctx.onCreate(map2); + for (const item of this.items) + addPairToJSMap(ctx, map2, item); + return map2; + } + toString(ctx, onComment, onChompKeep) { + if (!ctx) + return JSON.stringify(this); + for (const item of this.items) { + if (!isPair(item)) + throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`); + } + if (!ctx.allNullValues && this.hasAllNullValues(false)) + ctx = Object.assign({}, ctx, { allNullValues: true }); + return stringifyCollection(this, ctx, { + blockItemPrefix: "", + flowChars: { start: "{", end: "}" }, + itemIndent: ctx.indent || "", + onChompKeep, + onComment + }); + } +}; + +// node_modules/yaml/browser/dist/schema/common/map.js +function createMap(schema4, obj, ctx) { + const { keepUndefined, replacer } = ctx; + const map2 = new YAMLMap(schema4); + const add = (key, value) => { + if (typeof replacer === "function") + value = replacer.call(obj, key, value); + else if (Array.isArray(replacer) && !replacer.includes(key)) + return; + if (value !== void 0 || keepUndefined) + map2.items.push(createPair(key, value, ctx)); + }; + if (obj instanceof Map) { + for (const [key, value] of obj) + add(key, value); + } else if (obj && typeof obj === "object") { + for (const key of Object.keys(obj)) + add(key, obj[key]); + } + if (typeof schema4.sortMapEntries === "function") { + map2.items.sort(schema4.sortMapEntries); + } + return map2; +} +var map = { + collection: "map", + createNode: createMap, + default: true, + nodeClass: YAMLMap, + tag: "tag:yaml.org,2002:map", + resolve(map2, onError) { + if (!isMap(map2)) + onError("Expected a mapping for this tag"); + return map2; + } +}; + +// node_modules/yaml/browser/dist/nodes/YAMLSeq.js +var YAMLSeq = class extends Collection { + constructor(schema4) { + super(SEQ, schema4); + this.items = []; + } + static get tagName() { + return "tag:yaml.org,2002:seq"; + } + add(value) { + this.items.push(value); + } + delete(key) { + const idx = asItemIndex(key); + if (typeof idx !== "number") + return false; + const del = this.items.splice(idx, 1); + return del.length > 0; + } + get(key, keepScalar) { + const idx = asItemIndex(key); + if (typeof idx !== "number") + return void 0; + const it = this.items[idx]; + return !keepScalar && isScalar(it) ? it.value : it; + } + has(key) { + const idx = asItemIndex(key); + return typeof idx === "number" && idx < this.items.length; + } + set(key, value) { + const idx = asItemIndex(key); + if (typeof idx !== "number") + throw new Error(`Expected a valid index, not ${key}.`); + const prev = this.items[idx]; + if (isScalar(prev) && isScalarValue(value)) + prev.value = value; + else + this.items[idx] = value; + } + toJSON(_, ctx) { + const seq2 = []; + if (ctx == null ? void 0 : ctx.onCreate) + ctx.onCreate(seq2); + let i = 0; + for (const item of this.items) + seq2.push(toJS(item, String(i++), ctx)); + return seq2; + } + toString(ctx, onComment, onChompKeep) { + if (!ctx) + return JSON.stringify(this); + return stringifyCollection(this, ctx, { + blockItemPrefix: "- ", + flowChars: { start: "[", end: "]" }, + itemIndent: (ctx.indent || "") + " ", + onChompKeep, + onComment + }); + } +}; +function asItemIndex(key) { + let idx = isScalar(key) ? key.value : key; + if (idx && typeof idx === "string") + idx = Number(idx); + return typeof idx === "number" && Number.isInteger(idx) && idx >= 0 ? idx : null; +} + +// node_modules/yaml/browser/dist/schema/common/seq.js +function createSeq(schema4, obj, ctx) { + const { replacer } = ctx; + const seq2 = new YAMLSeq(schema4); + if (obj && Symbol.iterator in Object(obj)) { + let i = 0; + for (let it of obj) { + if (typeof replacer === "function") { + const key = obj instanceof Set ? it : String(i++); + it = replacer.call(obj, key, it); + } + seq2.items.push(createNode(it, void 0, ctx)); + } + } + return seq2; +} +var seq = { + collection: "seq", + createNode: createSeq, + default: true, + nodeClass: YAMLSeq, + tag: "tag:yaml.org,2002:seq", + resolve(seq2, onError) { + if (!isSeq(seq2)) + onError("Expected a sequence for this tag"); + return seq2; + } +}; + +// node_modules/yaml/browser/dist/schema/common/string.js +var string = { + identify: (value) => typeof value === "string", + default: true, + tag: "tag:yaml.org,2002:str", + resolve: (str) => str, + stringify(item, ctx, onComment, onChompKeep) { + ctx = Object.assign({ actualString: true }, ctx); + return stringifyString(item, ctx, onComment, onChompKeep); + } +}; + +// node_modules/yaml/browser/dist/schema/common/null.js +var nullTag = { + identify: (value) => value == null, + createNode: () => new Scalar(null), + default: true, + tag: "tag:yaml.org,2002:null", + test: /^(?:~|[Nn]ull|NULL)?$/, + resolve: () => new Scalar(null), + stringify: ({ source }, ctx) => typeof source === "string" && nullTag.test.test(source) ? source : ctx.options.nullStr +}; + +// node_modules/yaml/browser/dist/schema/core/bool.js +var boolTag = { + identify: (value) => typeof value === "boolean", + default: true, + tag: "tag:yaml.org,2002:bool", + test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/, + resolve: (str) => new Scalar(str[0] === "t" || str[0] === "T"), + stringify({ source, value }, ctx) { + if (source && boolTag.test.test(source)) { + const sv = source[0] === "t" || source[0] === "T"; + if (value === sv) + return source; + } + return value ? ctx.options.trueStr : ctx.options.falseStr; + } +}; + +// node_modules/yaml/browser/dist/stringify/stringifyNumber.js +function stringifyNumber({ format, minFractionDigits, tag, value }) { + if (typeof value === "bigint") + return String(value); + const num = typeof value === "number" ? value : Number(value); + if (!isFinite(num)) + return isNaN(num) ? ".nan" : num < 0 ? "-.inf" : ".inf"; + let n = JSON.stringify(value); + if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^\d/.test(n)) { + let i = n.indexOf("."); + if (i < 0) { + i = n.length; + n += "."; + } + let d = minFractionDigits - (n.length - i - 1); + while (d-- > 0) + n += "0"; + } + return n; +} + +// node_modules/yaml/browser/dist/schema/core/float.js +var floatNaN = { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + test: /^(?:[-+]?\.(?:inf|Inf|INF|nan|NaN|NAN))$/, + resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY, + stringify: stringifyNumber +}; +var floatExp = { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + format: "EXP", + test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/, + resolve: (str) => parseFloat(str), + stringify(node) { + const num = Number(node.value); + return isFinite(num) ? num.toExponential() : stringifyNumber(node); + } +}; +var float = { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/, + resolve(str) { + const node = new Scalar(parseFloat(str)); + const dot = str.indexOf("."); + if (dot !== -1 && str[str.length - 1] === "0") + node.minFractionDigits = str.length - dot - 1; + return node; + }, + stringify: stringifyNumber +}; + +// node_modules/yaml/browser/dist/schema/core/int.js +var intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value); +var intResolve = (str, offset, radix, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix); +function intStringify(node, radix, prefix) { + const { value } = node; + if (intIdentify(value) && value >= 0) + return prefix + value.toString(radix); + return stringifyNumber(node); +} +var intOct = { + identify: (value) => intIdentify(value) && value >= 0, + default: true, + tag: "tag:yaml.org,2002:int", + format: "OCT", + test: /^0o[0-7]+$/, + resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt), + stringify: (node) => intStringify(node, 8, "0o") +}; +var int = { + identify: intIdentify, + default: true, + tag: "tag:yaml.org,2002:int", + test: /^[-+]?[0-9]+$/, + resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt), + stringify: stringifyNumber +}; +var intHex = { + identify: (value) => intIdentify(value) && value >= 0, + default: true, + tag: "tag:yaml.org,2002:int", + format: "HEX", + test: /^0x[0-9a-fA-F]+$/, + resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt), + stringify: (node) => intStringify(node, 16, "0x") +}; + +// node_modules/yaml/browser/dist/schema/core/schema.js +var schema = [ + map, + seq, + string, + nullTag, + boolTag, + intOct, + int, + intHex, + floatNaN, + floatExp, + float +]; + +// node_modules/yaml/browser/dist/schema/json/schema.js +function intIdentify2(value) { + return typeof value === "bigint" || Number.isInteger(value); +} +var stringifyJSON = ({ value }) => JSON.stringify(value); +var jsonScalars = [ + { + identify: (value) => typeof value === "string", + default: true, + tag: "tag:yaml.org,2002:str", + resolve: (str) => str, + stringify: stringifyJSON + }, + { + identify: (value) => value == null, + createNode: () => new Scalar(null), + default: true, + tag: "tag:yaml.org,2002:null", + test: /^null$/, + resolve: () => null, + stringify: stringifyJSON + }, + { + identify: (value) => typeof value === "boolean", + default: true, + tag: "tag:yaml.org,2002:bool", + test: /^true|false$/, + resolve: (str) => str === "true", + stringify: stringifyJSON + }, + { + identify: intIdentify2, + default: true, + tag: "tag:yaml.org,2002:int", + test: /^-?(?:0|[1-9][0-9]*)$/, + resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10), + stringify: ({ value }) => intIdentify2(value) ? value.toString() : JSON.stringify(value) + }, + { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/, + resolve: (str) => parseFloat(str), + stringify: stringifyJSON + } +]; +var jsonError = { + default: true, + tag: "", + test: /^/, + resolve(str, onError) { + onError(`Unresolved plain scalar ${JSON.stringify(str)}`); + return str; + } +}; +var schema2 = [map, seq].concat(jsonScalars, jsonError); + +// node_modules/yaml/browser/dist/schema/yaml-1.1/binary.js +var binary = { + identify: (value) => value instanceof Uint8Array, + default: false, + tag: "tag:yaml.org,2002:binary", + resolve(src, onError) { + if (typeof Buffer === "function") { + return Buffer.from(src, "base64"); + } else if (typeof atob === "function") { + const str = atob(src.replace(/[\n\r]/g, "")); + const buffer = new Uint8Array(str.length); + for (let i = 0; i < str.length; ++i) + buffer[i] = str.charCodeAt(i); + return buffer; + } else { + onError("This environment does not support reading binary tags; either Buffer or atob is required"); + return src; + } + }, + stringify({ comment, type, value }, ctx, onComment, onChompKeep) { + const buf = value; + let str; + if (typeof Buffer === "function") { + str = buf instanceof Buffer ? buf.toString("base64") : Buffer.from(buf.buffer).toString("base64"); + } else if (typeof btoa === "function") { + let s = ""; + for (let i = 0; i < buf.length; ++i) + s += String.fromCharCode(buf[i]); + str = btoa(s); + } else { + throw new Error("This environment does not support writing binary tags; either Buffer or btoa is required"); + } + if (!type) + type = Scalar.BLOCK_LITERAL; + if (type !== Scalar.QUOTE_DOUBLE) { + const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth); + const n = Math.ceil(str.length / lineWidth); + const lines = new Array(n); + for (let i = 0, o = 0; i < n; ++i, o += lineWidth) { + lines[i] = str.substr(o, lineWidth); + } + str = lines.join(type === Scalar.BLOCK_LITERAL ? "\n" : " "); + } + return stringifyString({ comment, type, value: str }, ctx, onComment, onChompKeep); + } +}; + +// node_modules/yaml/browser/dist/schema/yaml-1.1/pairs.js +function resolvePairs(seq2, onError) { + var _a; + if (isSeq(seq2)) { + for (let i = 0; i < seq2.items.length; ++i) { + let item = seq2.items[i]; + if (isPair(item)) + continue; + else if (isMap(item)) { + if (item.items.length > 1) + onError("Each pair must have its own sequence indicator"); + const pair = item.items[0] || new Pair(new Scalar(null)); + if (item.commentBefore) + pair.key.commentBefore = pair.key.commentBefore ? `${item.commentBefore} +${pair.key.commentBefore}` : item.commentBefore; + if (item.comment) { + const cn = (_a = pair.value) != null ? _a : pair.key; + cn.comment = cn.comment ? `${item.comment} +${cn.comment}` : item.comment; + } + item = pair; + } + seq2.items[i] = isPair(item) ? item : new Pair(item); + } + } else + onError("Expected a sequence for this tag"); + return seq2; +} +function createPairs(schema4, iterable, ctx) { + const { replacer } = ctx; + const pairs2 = new YAMLSeq(schema4); + pairs2.tag = "tag:yaml.org,2002:pairs"; + let i = 0; + if (iterable && Symbol.iterator in Object(iterable)) + for (let it of iterable) { + if (typeof replacer === "function") + it = replacer.call(iterable, String(i++), it); + let key, value; + if (Array.isArray(it)) { + if (it.length === 2) { + key = it[0]; + value = it[1]; + } else + throw new TypeError(`Expected [key, value] tuple: ${it}`); + } else if (it && it instanceof Object) { + const keys = Object.keys(it); + if (keys.length === 1) { + key = keys[0]; + value = it[key]; + } else + throw new TypeError(`Expected { key: value } tuple: ${it}`); + } else { + key = it; + } + pairs2.items.push(createPair(key, value, ctx)); + } + return pairs2; +} +var pairs = { + collection: "seq", + default: false, + tag: "tag:yaml.org,2002:pairs", + resolve: resolvePairs, + createNode: createPairs +}; + +// node_modules/yaml/browser/dist/schema/yaml-1.1/omap.js +var YAMLOMap = class extends YAMLSeq { + constructor() { + super(); + this.add = YAMLMap.prototype.add.bind(this); + this.delete = YAMLMap.prototype.delete.bind(this); + this.get = YAMLMap.prototype.get.bind(this); + this.has = YAMLMap.prototype.has.bind(this); + this.set = YAMLMap.prototype.set.bind(this); + this.tag = YAMLOMap.tag; + } + toJSON(_, ctx) { + if (!ctx) + return super.toJSON(_); + const map2 = new Map(); + if (ctx == null ? void 0 : ctx.onCreate) + ctx.onCreate(map2); + for (const pair of this.items) { + let key, value; + if (isPair(pair)) { + key = toJS(pair.key, "", ctx); + value = toJS(pair.value, key, ctx); + } else { + key = toJS(pair, "", ctx); + } + if (map2.has(key)) + throw new Error("Ordered maps must not include duplicate keys"); + map2.set(key, value); + } + return map2; + } +}; +YAMLOMap.tag = "tag:yaml.org,2002:omap"; +var omap = { + collection: "seq", + identify: (value) => value instanceof Map, + nodeClass: YAMLOMap, + default: false, + tag: "tag:yaml.org,2002:omap", + resolve(seq2, onError) { + const pairs2 = resolvePairs(seq2, onError); + const seenKeys = []; + for (const { key } of pairs2.items) { + if (isScalar(key)) { + if (seenKeys.includes(key.value)) { + onError(`Ordered maps must not include duplicate keys: ${key.value}`); + } else { + seenKeys.push(key.value); + } + } + } + return Object.assign(new YAMLOMap(), pairs2); + }, + createNode(schema4, iterable, ctx) { + const pairs2 = createPairs(schema4, iterable, ctx); + const omap2 = new YAMLOMap(); + omap2.items = pairs2.items; + return omap2; + } +}; + +// node_modules/yaml/browser/dist/schema/yaml-1.1/bool.js +function boolStringify({ value, source }, ctx) { + const boolObj = value ? trueTag : falseTag; + if (source && boolObj.test.test(source)) + return source; + return value ? ctx.options.trueStr : ctx.options.falseStr; +} +var trueTag = { + identify: (value) => value === true, + default: true, + tag: "tag:yaml.org,2002:bool", + test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/, + resolve: () => new Scalar(true), + stringify: boolStringify +}; +var falseTag = { + identify: (value) => value === false, + default: true, + tag: "tag:yaml.org,2002:bool", + test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i, + resolve: () => new Scalar(false), + stringify: boolStringify +}; + +// node_modules/yaml/browser/dist/schema/yaml-1.1/float.js +var floatNaN2 = { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + test: /^[-+]?\.(?:inf|Inf|INF|nan|NaN|NAN)$/, + resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY, + stringify: stringifyNumber +}; +var floatExp2 = { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + format: "EXP", + test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/, + resolve: (str) => parseFloat(str.replace(/_/g, "")), + stringify(node) { + const num = Number(node.value); + return isFinite(num) ? num.toExponential() : stringifyNumber(node); + } +}; +var float2 = { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/, + resolve(str) { + const node = new Scalar(parseFloat(str.replace(/_/g, ""))); + const dot = str.indexOf("."); + if (dot !== -1) { + const f = str.substring(dot + 1).replace(/_/g, ""); + if (f[f.length - 1] === "0") + node.minFractionDigits = f.length; + } + return node; + }, + stringify: stringifyNumber +}; + +// node_modules/yaml/browser/dist/schema/yaml-1.1/int.js +var intIdentify3 = (value) => typeof value === "bigint" || Number.isInteger(value); +function intResolve2(str, offset, radix, { intAsBigInt }) { + const sign = str[0]; + if (sign === "-" || sign === "+") + offset += 1; + str = str.substring(offset).replace(/_/g, ""); + if (intAsBigInt) { + switch (radix) { + case 2: + str = `0b${str}`; + break; + case 8: + str = `0o${str}`; + break; + case 16: + str = `0x${str}`; + break; + } + const n2 = BigInt(str); + return sign === "-" ? BigInt(-1) * n2 : n2; + } + const n = parseInt(str, radix); + return sign === "-" ? -1 * n : n; +} +function intStringify2(node, radix, prefix) { + const { value } = node; + if (intIdentify3(value)) { + const str = value.toString(radix); + return value < 0 ? "-" + prefix + str.substr(1) : prefix + str; + } + return stringifyNumber(node); +} +var intBin = { + identify: intIdentify3, + default: true, + tag: "tag:yaml.org,2002:int", + format: "BIN", + test: /^[-+]?0b[0-1_]+$/, + resolve: (str, _onError, opt) => intResolve2(str, 2, 2, opt), + stringify: (node) => intStringify2(node, 2, "0b") +}; +var intOct2 = { + identify: intIdentify3, + default: true, + tag: "tag:yaml.org,2002:int", + format: "OCT", + test: /^[-+]?0[0-7_]+$/, + resolve: (str, _onError, opt) => intResolve2(str, 1, 8, opt), + stringify: (node) => intStringify2(node, 8, "0") +}; +var int2 = { + identify: intIdentify3, + default: true, + tag: "tag:yaml.org,2002:int", + test: /^[-+]?[0-9][0-9_]*$/, + resolve: (str, _onError, opt) => intResolve2(str, 0, 10, opt), + stringify: stringifyNumber +}; +var intHex2 = { + identify: intIdentify3, + default: true, + tag: "tag:yaml.org,2002:int", + format: "HEX", + test: /^[-+]?0x[0-9a-fA-F_]+$/, + resolve: (str, _onError, opt) => intResolve2(str, 2, 16, opt), + stringify: (node) => intStringify2(node, 16, "0x") +}; + +// node_modules/yaml/browser/dist/schema/yaml-1.1/set.js +var YAMLSet = class extends YAMLMap { + constructor(schema4) { + super(schema4); + this.tag = YAMLSet.tag; + } + add(key) { + let pair; + if (isPair(key)) + pair = key; + else if (typeof key === "object" && "key" in key && "value" in key && key.value === null) + pair = new Pair(key.key, null); + else + pair = new Pair(key, null); + const prev = findPair(this.items, pair.key); + if (!prev) + this.items.push(pair); + } + get(key, keepPair) { + const pair = findPair(this.items, key); + return !keepPair && isPair(pair) ? isScalar(pair.key) ? pair.key.value : pair.key : pair; + } + set(key, value) { + if (typeof value !== "boolean") + throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`); + const prev = findPair(this.items, key); + if (prev && !value) { + this.items.splice(this.items.indexOf(prev), 1); + } else if (!prev && value) { + this.items.push(new Pair(key)); + } + } + toJSON(_, ctx) { + return super.toJSON(_, ctx, Set); + } + toString(ctx, onComment, onChompKeep) { + if (!ctx) + return JSON.stringify(this); + if (this.hasAllNullValues(true)) + return super.toString(Object.assign({}, ctx, { allNullValues: true }), onComment, onChompKeep); + else + throw new Error("Set items must all have null values"); + } +}; +YAMLSet.tag = "tag:yaml.org,2002:set"; +var set = { + collection: "map", + identify: (value) => value instanceof Set, + nodeClass: YAMLSet, + default: false, + tag: "tag:yaml.org,2002:set", + resolve(map2, onError) { + if (isMap(map2)) { + if (map2.hasAllNullValues(true)) + return Object.assign(new YAMLSet(), map2); + else + onError("Set items must all have null values"); + } else + onError("Expected a mapping for this tag"); + return map2; + }, + createNode(schema4, iterable, ctx) { + const { replacer } = ctx; + const set2 = new YAMLSet(schema4); + if (iterable && Symbol.iterator in Object(iterable)) + for (let value of iterable) { + if (typeof replacer === "function") + value = replacer.call(iterable, value, value); + set2.items.push(createPair(value, null, ctx)); + } + return set2; + } +}; + +// node_modules/yaml/browser/dist/schema/yaml-1.1/timestamp.js +function parseSexagesimal(str, asBigInt) { + const sign = str[0]; + const parts = sign === "-" || sign === "+" ? str.substring(1) : str; + const num = (n) => asBigInt ? BigInt(n) : Number(n); + const res = parts.replace(/_/g, "").split(":").reduce((res2, p) => res2 * num(60) + num(p), num(0)); + return sign === "-" ? num(-1) * res : res; +} +function stringifySexagesimal(node) { + let { value } = node; + let num = (n) => n; + if (typeof value === "bigint") + num = (n) => BigInt(n); + else if (isNaN(value) || !isFinite(value)) + return stringifyNumber(node); + let sign = ""; + if (value < 0) { + sign = "-"; + value *= num(-1); + } + const _60 = num(60); + const parts = [value % _60]; + if (value < 60) { + parts.unshift(0); + } else { + value = (value - parts[0]) / _60; + parts.unshift(value % _60); + if (value >= 60) { + value = (value - parts[0]) / _60; + parts.unshift(value); + } + } + return sign + parts.map((n) => n < 10 ? "0" + String(n) : String(n)).join(":").replace(/000000\d*$/, ""); +} +var intTime = { + identify: (value) => typeof value === "bigint" || Number.isInteger(value), + default: true, + tag: "tag:yaml.org,2002:int", + format: "TIME", + test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/, + resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt), + stringify: stringifySexagesimal +}; +var floatTime = { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + format: "TIME", + test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/, + resolve: (str) => parseSexagesimal(str, false), + stringify: stringifySexagesimal +}; +var timestamp = { + identify: (value) => value instanceof Date, + default: true, + tag: "tag:yaml.org,2002:timestamp", + test: RegExp("^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})(?:(?:t|T|[ \\t]+)([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?)?$"), + resolve(str) { + const match = str.match(timestamp.test); + if (!match) + throw new Error("!!timestamp expects a date, starting with yyyy-mm-dd"); + const [, year, month, day, hour, minute, second] = match.map(Number); + const millisec = match[7] ? Number((match[7] + "00").substr(1, 3)) : 0; + let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec); + const tz = match[8]; + if (tz && tz !== "Z") { + let d = parseSexagesimal(tz, false); + if (Math.abs(d) < 30) + d *= 60; + date -= 6e4 * d; + } + return new Date(date); + }, + stringify: ({ value }) => value.toISOString().replace(/((T00:00)?:00)?\.000Z$/, "") +}; + +// node_modules/yaml/browser/dist/schema/yaml-1.1/schema.js +var schema3 = [ + map, + seq, + string, + nullTag, + trueTag, + falseTag, + intBin, + intOct2, + int2, + intHex2, + floatNaN2, + floatExp2, + float2, + binary, + omap, + pairs, + set, + intTime, + floatTime, + timestamp +]; + +// node_modules/yaml/browser/dist/schema/tags.js +var schemas = new Map([ + ["core", schema], + ["failsafe", [map, seq, string]], + ["json", schema2], + ["yaml11", schema3], + ["yaml-1.1", schema3] +]); +var tagsByName = { + binary, + bool: boolTag, + float, + floatExp, + floatNaN, + floatTime, + int, + intHex, + intOct, + intTime, + map, + null: nullTag, + omap, + pairs, + seq, + set, + timestamp +}; +var coreKnownTags = { + "tag:yaml.org,2002:binary": binary, + "tag:yaml.org,2002:omap": omap, + "tag:yaml.org,2002:pairs": pairs, + "tag:yaml.org,2002:set": set, + "tag:yaml.org,2002:timestamp": timestamp +}; +function getTags(customTags, schemaName) { + let tags = schemas.get(schemaName); + if (!tags) { + if (Array.isArray(customTags)) + tags = []; + else { + const keys = Array.from(schemas.keys()).filter((key) => key !== "yaml11").map((key) => JSON.stringify(key)).join(", "); + throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`); + } + } + if (Array.isArray(customTags)) { + for (const tag of customTags) + tags = tags.concat(tag); + } else if (typeof customTags === "function") { + tags = customTags(tags.slice()); + } + return tags.map((tag) => { + if (typeof tag !== "string") + return tag; + const tagObj = tagsByName[tag]; + if (tagObj) + return tagObj; + const keys = Object.keys(tagsByName).map((key) => JSON.stringify(key)).join(", "); + throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`); + }); +} + +// node_modules/yaml/browser/dist/schema/Schema.js +var sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0; +var Schema = class { + constructor({ compat, customTags, merge, resolveKnownTags, schema: schema4, sortMapEntries, toStringDefaults }) { + this.compat = Array.isArray(compat) ? getTags(compat, "compat") : compat ? getTags(null, compat) : null; + this.merge = !!merge; + this.name = typeof schema4 === "string" && schema4 || "core"; + this.knownTags = resolveKnownTags ? coreKnownTags : {}; + this.tags = getTags(customTags, this.name); + this.toStringOptions = toStringDefaults != null ? toStringDefaults : null; + Object.defineProperty(this, MAP, { value: map }); + Object.defineProperty(this, SCALAR, { value: string }); + Object.defineProperty(this, SEQ, { value: seq }); + this.sortMapEntries = typeof sortMapEntries === "function" ? sortMapEntries : sortMapEntries === true ? sortMapEntriesByKey : null; + } + clone() { + const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this)); + copy.tags = this.tags.slice(); + return copy; + } +}; + +// node_modules/yaml/browser/dist/stringify/stringifyDocument.js +function stringifyDocument(doc, options) { + var _a; + const lines = []; + let hasDirectives = options.directives === true; + if (options.directives !== false && doc.directives) { + const dir = doc.directives.toString(doc); + if (dir) { + lines.push(dir); + hasDirectives = true; + } else if (doc.directives.docStart) + hasDirectives = true; + } + if (hasDirectives) + lines.push("---"); + const ctx = createStringifyContext(doc, options); + const { commentString } = ctx.options; + if (doc.commentBefore) { + if (lines.length !== 1) + lines.unshift(""); + const cs = commentString(doc.commentBefore); + lines.unshift(indentComment(cs, "")); + } + let chompKeep = false; + let contentComment = null; + if (doc.contents) { + if (isNode(doc.contents)) { + if (doc.contents.spaceBefore && hasDirectives) + lines.push(""); + if (doc.contents.commentBefore) { + const cs = commentString(doc.contents.commentBefore); + lines.push(indentComment(cs, "")); + } + ctx.forceBlockIndent = !!doc.comment; + contentComment = doc.contents.comment; + } + const onChompKeep = contentComment ? void 0 : () => chompKeep = true; + let body = stringify(doc.contents, ctx, () => contentComment = null, onChompKeep); + if (contentComment) + body += lineComment(body, "", commentString(contentComment)); + if ((body[0] === "|" || body[0] === ">") && lines[lines.length - 1] === "---") { + lines[lines.length - 1] = `--- ${body}`; + } else + lines.push(body); + } else { + lines.push(stringify(doc.contents, ctx)); + } + if ((_a = doc.directives) == null ? void 0 : _a.docEnd) { + if (doc.comment) { + const cs = commentString(doc.comment); + if (cs.includes("\n")) { + lines.push("..."); + lines.push(indentComment(cs, "")); + } else { + lines.push(`... ${cs}`); + } + } else { + lines.push("..."); + } + } else { + let dc = doc.comment; + if (dc && chompKeep) + dc = dc.replace(/^\n+/, ""); + if (dc) { + if ((!chompKeep || contentComment) && lines[lines.length - 1] !== "") + lines.push(""); + lines.push(indentComment(commentString(dc), "")); + } + } + return lines.join("\n") + "\n"; +} + +// node_modules/yaml/browser/dist/doc/applyReviver.js +function applyReviver(reviver, obj, key, val) { + if (val && typeof val === "object") { + if (Array.isArray(val)) { + for (let i = 0, len = val.length; i < len; ++i) { + const v0 = val[i]; + const v1 = applyReviver(reviver, val, String(i), v0); + if (v1 === void 0) + delete val[i]; + else if (v1 !== v0) + val[i] = v1; + } + } else if (val instanceof Map) { + for (const k of Array.from(val.keys())) { + const v0 = val.get(k); + const v1 = applyReviver(reviver, val, k, v0); + if (v1 === void 0) + val.delete(k); + else if (v1 !== v0) + val.set(k, v1); + } + } else if (val instanceof Set) { + for (const v0 of Array.from(val)) { + const v1 = applyReviver(reviver, val, v0, v0); + if (v1 === void 0) + val.delete(v0); + else if (v1 !== v0) { + val.delete(v0); + val.add(v1); + } + } + } else { + for (const [k, v0] of Object.entries(val)) { + const v1 = applyReviver(reviver, val, k, v0); + if (v1 === void 0) + delete val[k]; + else if (v1 !== v0) + val[k] = v1; + } + } + } + return reviver.call(obj, key, val); +} + +// node_modules/yaml/browser/dist/doc/Document.js +var Document = class { + constructor(value, replacer, options) { + this.commentBefore = null; + this.comment = null; + this.errors = []; + this.warnings = []; + Object.defineProperty(this, NODE_TYPE, { value: DOC }); + let _replacer = null; + if (typeof replacer === "function" || Array.isArray(replacer)) { + _replacer = replacer; + } else if (options === void 0 && replacer) { + options = replacer; + replacer = void 0; + } + const opt = Object.assign({ + intAsBigInt: false, + keepSourceTokens: false, + logLevel: "warn", + prettyErrors: true, + strict: true, + uniqueKeys: true, + version: "1.2" + }, options); + this.options = opt; + let { version } = opt; + if (options == null ? void 0 : options._directives) { + this.directives = options._directives.atDocument(); + if (this.directives.yaml.explicit) + version = this.directives.yaml.version; + } else + this.directives = new Directives({ version }); + this.setSchema(version, options); + if (value === void 0) + this.contents = null; + else { + this.contents = this.createNode(value, _replacer, options); + } + } + clone() { + const copy = Object.create(Document.prototype, { + [NODE_TYPE]: { value: DOC } + }); + copy.commentBefore = this.commentBefore; + copy.comment = this.comment; + copy.errors = this.errors.slice(); + copy.warnings = this.warnings.slice(); + copy.options = Object.assign({}, this.options); + if (this.directives) + copy.directives = this.directives.clone(); + copy.schema = this.schema.clone(); + copy.contents = isNode(this.contents) ? this.contents.clone(copy.schema) : this.contents; + if (this.range) + copy.range = this.range.slice(); + return copy; + } + add(value) { + if (assertCollection(this.contents)) + this.contents.add(value); + } + addIn(path, value) { + if (assertCollection(this.contents)) + this.contents.addIn(path, value); + } + createAlias(node, name) { + if (!node.anchor) { + const prev = anchorNames(this); + node.anchor = !name || prev.has(name) ? findNewAnchor(name || "a", prev) : name; + } + return new Alias(node.anchor); + } + createNode(value, replacer, options) { + let _replacer = void 0; + if (typeof replacer === "function") { + value = replacer.call({ "": value }, "", value); + _replacer = replacer; + } else if (Array.isArray(replacer)) { + const keyToStr = (v) => typeof v === "number" || v instanceof String || v instanceof Number; + const asStr = replacer.filter(keyToStr).map(String); + if (asStr.length > 0) + replacer = replacer.concat(asStr); + _replacer = replacer; + } else if (options === void 0 && replacer) { + options = replacer; + replacer = void 0; + } + const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options != null ? options : {}; + const { onAnchor, setAnchors, sourceObjects } = createNodeAnchors(this, anchorPrefix || "a"); + const ctx = { + aliasDuplicateObjects: aliasDuplicateObjects != null ? aliasDuplicateObjects : true, + keepUndefined: keepUndefined != null ? keepUndefined : false, + onAnchor, + onTagObj, + replacer: _replacer, + schema: this.schema, + sourceObjects + }; + const node = createNode(value, tag, ctx); + if (flow && isCollection(node)) + node.flow = true; + setAnchors(); + return node; + } + createPair(key, value, options = {}) { + const k = this.createNode(key, null, options); + const v = this.createNode(value, null, options); + return new Pair(k, v); + } + delete(key) { + return assertCollection(this.contents) ? this.contents.delete(key) : false; + } + deleteIn(path) { + if (isEmptyPath(path)) { + if (this.contents == null) + return false; + this.contents = null; + return true; + } + return assertCollection(this.contents) ? this.contents.deleteIn(path) : false; + } + get(key, keepScalar) { + return isCollection(this.contents) ? this.contents.get(key, keepScalar) : void 0; + } + getIn(path, keepScalar) { + if (isEmptyPath(path)) + return !keepScalar && isScalar(this.contents) ? this.contents.value : this.contents; + return isCollection(this.contents) ? this.contents.getIn(path, keepScalar) : void 0; + } + has(key) { + return isCollection(this.contents) ? this.contents.has(key) : false; + } + hasIn(path) { + if (isEmptyPath(path)) + return this.contents !== void 0; + return isCollection(this.contents) ? this.contents.hasIn(path) : false; + } + set(key, value) { + if (this.contents == null) { + this.contents = collectionFromPath(this.schema, [key], value); + } else if (assertCollection(this.contents)) { + this.contents.set(key, value); + } + } + setIn(path, value) { + if (isEmptyPath(path)) + this.contents = value; + else if (this.contents == null) { + this.contents = collectionFromPath(this.schema, Array.from(path), value); + } else if (assertCollection(this.contents)) { + this.contents.setIn(path, value); + } + } + setSchema(version, options = {}) { + if (typeof version === "number") + version = String(version); + let opt; + switch (version) { + case "1.1": + if (this.directives) + this.directives.yaml.version = "1.1"; + else + this.directives = new Directives({ version: "1.1" }); + opt = { merge: true, resolveKnownTags: false, schema: "yaml-1.1" }; + break; + case "1.2": + case "next": + if (this.directives) + this.directives.yaml.version = version; + else + this.directives = new Directives({ version }); + opt = { merge: false, resolveKnownTags: true, schema: "core" }; + break; + case null: + if (this.directives) + delete this.directives; + opt = null; + break; + default: { + const sv = JSON.stringify(version); + throw new Error(`Expected '1.1', '1.2' or null as first argument, but found: ${sv}`); + } + } + if (options.schema instanceof Object) + this.schema = options.schema; + else if (opt) + this.schema = new Schema(Object.assign(opt, options)); + else + throw new Error(`With a null YAML version, the { schema: Schema } option is required`); + } + toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) { + const ctx = { + anchors: new Map(), + doc: this, + keep: !json, + mapAsMap: mapAsMap === true, + mapKeyWarned: false, + maxAliasCount: typeof maxAliasCount === "number" ? maxAliasCount : 100, + stringify + }; + const res = toJS(this.contents, jsonArg != null ? jsonArg : "", ctx); + if (typeof onAnchor === "function") + for (const { count, res: res2 } of ctx.anchors.values()) + onAnchor(res2, count); + return typeof reviver === "function" ? applyReviver(reviver, { "": res }, "", res) : res; + } + toJSON(jsonArg, onAnchor) { + return this.toJS({ json: true, jsonArg, mapAsMap: false, onAnchor }); + } + toString(options = {}) { + if (this.errors.length > 0) + throw new Error("Document with errors cannot be stringified"); + if ("indent" in options && (!Number.isInteger(options.indent) || Number(options.indent) <= 0)) { + const s = JSON.stringify(options.indent); + throw new Error(`"indent" option must be a positive integer, not ${s}`); + } + return stringifyDocument(this, options); + } +}; +function assertCollection(contents) { + if (isCollection(contents)) + return true; + throw new Error("Expected a YAML collection as document contents"); +} + +// node_modules/yaml/browser/dist/parse/cst-visit.js +var BREAK2 = Symbol("break visit"); +var SKIP2 = Symbol("skip children"); +var REMOVE2 = Symbol("remove item"); +function visit2(cst, visitor) { + if ("type" in cst && cst.type === "document") + cst = { start: cst.start, value: cst.value }; + _visit(Object.freeze([]), cst, visitor); +} +visit2.BREAK = BREAK2; +visit2.SKIP = SKIP2; +visit2.REMOVE = REMOVE2; +visit2.itemAtPath = (cst, path) => { + let item = cst; + for (const [field, index] of path) { + const tok = item == null ? void 0 : item[field]; + if (tok && "items" in tok) { + item = tok.items[index]; + } else + return void 0; + } + return item; +}; +visit2.parentCollection = (cst, path) => { + const parent = visit2.itemAtPath(cst, path.slice(0, -1)); + const field = path[path.length - 1][0]; + const coll = parent == null ? void 0 : parent[field]; + if (coll && "items" in coll) + return coll; + throw new Error("Parent collection not found"); +}; +function _visit(path, item, visitor) { + let ctrl = visitor(item, path); + if (typeof ctrl === "symbol") + return ctrl; + for (const field of ["key", "value"]) { + const token = item[field]; + if (token && "items" in token) { + for (let i = 0; i < token.items.length; ++i) { + const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor); + if (typeof ci === "number") + i = ci - 1; + else if (ci === BREAK2) + return BREAK2; + else if (ci === REMOVE2) { + token.items.splice(i, 1); + i -= 1; + } + } + if (typeof ctrl === "function" && field === "key") + ctrl = ctrl(item, path); + } + } + return typeof ctrl === "function" ? ctrl(item, path) : ctrl; +} + +// node_modules/yaml/browser/dist/parse/lexer.js +var hexDigits = "0123456789ABCDEFabcdef".split(""); +var tagChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()".split(""); +var invalidFlowScalarChars = ",[]{}".split(""); +var invalidAnchorChars = " ,[]{}\n\r ".split(""); + +// node_modules/yaml/browser/dist/public-api.js +function stringify3(value, replacer, options) { + var _a; + let _replacer = null; + if (typeof replacer === "function" || Array.isArray(replacer)) { + _replacer = replacer; + } else if (options === void 0 && replacer) { + options = replacer; + } + if (typeof options === "string") + options = options.length; + if (typeof options === "number") { + const indent = Math.round(options); + options = indent < 1 ? void 0 : indent > 8 ? { indent: 8 } : { indent }; + } + if (value === void 0) { + const { keepUndefined } = (_a = options != null ? options : replacer) != null ? _a : {}; + if (!keepUndefined) + return void 0; + } + return new Document(value, _replacer, options).toString(options); +} + +// Upload2Notion.ts +var Upload2Notion = class { + constructor(app) { + this.app = app; + } + createPage(title, childArr) { + return __async(this, null, function* () { + const bodyString = { + parent: { + database_id: this.app.settings.databaseID + }, + properties: { + Name: { + title: [ + { + text: { + content: title + } + } + ] + } + }, + children: childArr + }; + const response = yield (0, import_obsidian2.requestUrl)({ + url: `https://api.notion.com/v1/pages`, + method: "POST", + headers: { + "Content-Type": "application/json", + "Authorization": "Bearer " + this.app.settings.notionAPI, + "Notion-Version": "2021-08-16" + }, + body: JSON.stringify(bodyString) + }); + return response; + }); + } + syncMarkdownToNotion(title, markdown, fullPath) { + return __async(this, null, function* () { + const yamlObj = loadFront(markdown); + const __content = yamlObj.__content; + const file2md = (0, import_martian.markdownToBlocks)(__content); + const res = yield this.createPage(title, file2md); + if (res.status === 200) { + this.updateYamlInfo(markdown, fullPath, res); + } + return res; + }); + } + updateYamlInfo(yamlContent, fullPath, res) { + return __async(this, null, function* () { + const yamlObj = loadFront(yamlContent); + const { url } = res.json; + yamlObj.link = url; + const __content = yamlObj.__content; + delete yamlObj.__content; + const yamlhead = stringify3(yamlObj); + const yamlhead_remove_n = yamlhead.replace(/\n$/, ""); + const __content_remove_n = __content.replace(/^\n/, ""); + const content = "---\n" + yamlhead_remove_n + "\n---\n" + __content_remove_n; + fs.writeFileSync(fullPath, content); + return res; + }); + } +}; + +// main.ts +var DEFAULT_SETTINGS = { + notionAPI: "", + databaseID: "", + proxy: "" +}; +var MyPlugin = class extends import_obsidian3.Plugin { + onload() { + return __async(this, null, function* () { + yield this.loadSettings(); + addIcons(); + const ribbonIconEl = this.addRibbonIcon("notion-logo", "Share to notion", (evt) => __async(this, null, function* () { + this.upload(); + })); + ribbonIconEl.addClass("my-plugin-ribbon-class"); + const statusBarItemEl = this.addStatusBarItem(); + this.addCommand({ + id: "share-to-notion", + name: "share to notion", + editorCallback: (editor, view) => __async(this, null, function* () { + this.upload(); + }) + }); + this.addSettingTab(new SampleSettingTab(this.app, this)); + }); + } + onunload() { + } + upload() { + return __async(this, null, function* () { + const { notionAPI, databaseID } = this.settings; + if (notionAPI === "" || databaseID === "") { + new import_obsidian3.Notice("Please set up the notion API and database ID in the settings tab."); + return; + } + const { nowFile, fileData, fullPath } = yield this.getNowFileMarkdwonContent(this.app); + const { basename } = nowFile; + if (fileData) { + const upload = new Upload2Notion(this); + const res = yield upload.syncMarkdownToNotion(basename, fileData, fullPath); + console.log(res); + if (res.status === 200) { + new import_obsidian3.Notice(`${basename} \u540C\u6B65\u6210\u529F`); + } else { + new import_obsidian3.Notice(`${basename} \u540C\u6B65\u5931\u8D25`); + } + } + }); + } + getNowFileMarkdwonContent(app) { + return __async(this, null, function* () { + const nowFile = app.workspace.getActiveFile(); + if (nowFile) { + const filePath = nowFile.path; + const basePath = nowFile.vault.adapter.basePath; + const fullPath = (0, import_path.join)(basePath, filePath); + console.log("fullpath", fullPath); + const fileData = fs2.readFileSync(fullPath, "utf8"); + return { + fileData, + nowFile, + fullPath + }; + } else { + new import_obsidian3.Notice("\u8BF7\u6253\u5F00\u9700\u8981\u540C\u6B65\u7684\u6587\u4EF6"); + return; + } + }); + } + loadSettings() { + return __async(this, null, function* () { + this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData()); + }); + } + saveSettings() { + return __async(this, null, function* () { + yield this.saveData(this.settings); + }); + } +}; +var SampleSettingTab = class extends import_obsidian3.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + const { containerEl } = this; + containerEl.empty(); + containerEl.createEl("h2", { + text: "Settings for obsidian to notion plugin." + }); + new import_obsidian3.Setting(containerEl).setName("Notion API Token").setDesc("It's a secret").addText((text) => text.setPlaceholder("Enter your Notion API Token").setValue(this.plugin.settings.notionAPI).onChange((value) => __async(this, null, function* () { + console.log("Secret: " + value); + this.plugin.settings.notionAPI = value; + yield this.plugin.saveSettings(); + }))); + new import_obsidian3.Setting(containerEl).setName("Database ID").setDesc("It's a secret").addText((text) => text.setPlaceholder("Enter your Database ID").setValue(this.plugin.settings.databaseID).onChange((value) => __async(this, null, function* () { + console.log("Secret: " + value); + this.plugin.settings.databaseID = value; + yield this.plugin.saveSettings(); + }))); + } +}; +/*! + * Determine if an object is a Buffer + * + * @author Feross Aboukhadijeh + * @license MIT + */ +/*! + * repeat-string + * + * Copyright (c) 2014-2015, Jon Schlinkert. + * Licensed under the MIT License. + */ +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["node_modules/bail/index.js", "node_modules/is-buffer/index.js", "node_modules/extend/index.js", "node_modules/is-plain-obj/index.js", "node_modules/trough/wrap.js", "node_modules/trough/index.js", "node_modules/unist-util-stringify-position/index.js", "node_modules/vfile-message/index.js", "node_modules/vfile/lib/minpath.browser.js", "node_modules/vfile/lib/minproc.browser.js", "node_modules/vfile/lib/core.js", "node_modules/vfile/lib/index.js", "node_modules/vfile/index.js", "node_modules/unified/index.js", "node_modules/mdast-util-to-string/index.js", "node_modules/micromark/dist/constant/assign.js", "node_modules/micromark/dist/constant/has-own-property.js", "node_modules/micromark/dist/util/normalize-identifier.js", "node_modules/micromark/dist/constant/from-char-code.js", "node_modules/micromark/dist/util/safe-from-int.js", "node_modules/micromark/dist/character/markdown-line-ending.js", "node_modules/micromark/dist/character/markdown-space.js", "node_modules/micromark/dist/tokenize/factory-space.js", "node_modules/micromark/dist/initialize/content.js", "node_modules/micromark/dist/tokenize/partial-blank-line.js", "node_modules/micromark/dist/initialize/document.js", "node_modules/micromark/dist/util/size-chunks.js", "node_modules/micromark/dist/util/prefix-size.js", "node_modules/micromark/dist/constant/splice.js", "node_modules/micromark/dist/util/chunked-splice.js", "node_modules/micromark/dist/util/shallow.js", "node_modules/micromark/dist/util/subtokenize.js", "node_modules/micromark/dist/tokenize/content.js", "node_modules/micromark/dist/initialize/flow.js", "node_modules/micromark/dist/initialize/text.js", "node_modules/micromark/dist/util/miniflat.js", "node_modules/micromark/dist/util/combine-extensions.js", "node_modules/micromark/dist/util/chunked-push.js", "node_modules/micromark/dist/util/resolve-all.js", "node_modules/micromark/dist/util/serialize-chunks.js", "node_modules/micromark/dist/util/slice-chunks.js", "node_modules/micromark/dist/util/create-tokenizer.js", "node_modules/micromark/dist/character/markdown-line-ending-or-space.js", "node_modules/micromark/dist/constant/unicode-punctuation-regex.js", "node_modules/micromark/dist/util/regex-check.js", "node_modules/micromark/dist/character/unicode-punctuation.js", "node_modules/micromark/dist/character/unicode-whitespace.js", "node_modules/micromark/dist/util/classify-character.js", "node_modules/micromark/dist/util/move-point.js", "node_modules/micromark/dist/tokenize/attention.js", "node_modules/micromark/dist/character/ascii-alpha.js", "node_modules/micromark/dist/character/ascii-alphanumeric.js", "node_modules/micromark/dist/character/ascii-atext.js", "node_modules/micromark/dist/character/ascii-control.js", "node_modules/micromark/dist/tokenize/autolink.js", "node_modules/micromark/dist/tokenize/block-quote.js", "node_modules/micromark/dist/character/ascii-punctuation.js", "node_modules/micromark/dist/tokenize/character-escape.js", "node_modules/parse-entities/decode-entity.browser.js", "node_modules/micromark/dist/character/ascii-digit.js", "node_modules/micromark/dist/character/ascii-hex-digit.js", "node_modules/micromark/dist/tokenize/character-reference.js", "node_modules/micromark/dist/tokenize/code-fenced.js", "node_modules/micromark/dist/tokenize/code-indented.js", "node_modules/micromark/dist/tokenize/code-text.js", "node_modules/micromark/dist/tokenize/factory-destination.js", "node_modules/micromark/dist/tokenize/factory-label.js", "node_modules/micromark/dist/tokenize/factory-whitespace.js", "node_modules/micromark/dist/tokenize/factory-title.js", "node_modules/micromark/dist/tokenize/definition.js", "node_modules/micromark/dist/tokenize/hard-break-escape.js", "node_modules/micromark/dist/tokenize/heading-atx.js", "node_modules/micromark/dist/constant/html-block-names.js", "node_modules/micromark/dist/constant/html-raw-names.js", "node_modules/micromark/dist/tokenize/html-flow.js", "node_modules/micromark/dist/tokenize/html-text.js", "node_modules/micromark/dist/tokenize/label-end.js", "node_modules/micromark/dist/tokenize/label-start-image.js", "node_modules/micromark/dist/tokenize/label-start-link.js", "node_modules/micromark/dist/tokenize/line-ending.js", "node_modules/micromark/dist/tokenize/thematic-break.js", "node_modules/micromark/dist/tokenize/list.js", "node_modules/micromark/dist/tokenize/setext-underline.js", "node_modules/micromark/dist/constructs.js", "node_modules/micromark/dist/parse.js", "node_modules/micromark/dist/preprocess.js", "node_modules/micromark/dist/postprocess.js", "node_modules/mdast-util-from-markdown/dist/index.js", "node_modules/mdast-util-from-markdown/index.js", "node_modules/remark-parse/index.js", "node_modules/@tryfabric/martian/src/notion/blocks.ts", "node_modules/@tryfabric/martian/src/notion/common.ts", "node_modules/@tryfabric/martian/src/notion/index.ts", "node_modules/@tryfabric/martian/src/parser/internal.ts", "node_modules/micromark-extension-gfm-autolink-literal/syntax.js", "node_modules/micromark-extension-gfm-autolink-literal/index.js", "node_modules/micromark-extension-gfm-strikethrough/index.js", "node_modules/micromark-extension-gfm-table/syntax.js", "node_modules/micromark-extension-gfm-table/index.js", "node_modules/micromark-extension-gfm-task-list-item/syntax.js", "node_modules/micromark-extension-gfm-task-list-item/index.js", "node_modules/micromark-extension-gfm/syntax.js", "node_modules/micromark-extension-gfm/index.js", "node_modules/ccount/index.js", "node_modules/unist-util-is/convert.js", "node_modules/unist-util-visit-parents/color.browser.js", "node_modules/unist-util-visit-parents/index.js", "node_modules/escape-string-regexp/index.js", "node_modules/mdast-util-find-and-replace/index.js", "node_modules/mdast-util-gfm-autolink-literal/from-markdown.js", "node_modules/mdast-util-gfm-strikethrough/from-markdown.js", "node_modules/mdast-util-gfm-table/from-markdown.js", "node_modules/mdast-util-gfm-task-list-item/from-markdown.js", "node_modules/mdast-util-gfm/from-markdown.js", "node_modules/mdast-util-gfm-autolink-literal/to-markdown.js", "node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js", "node_modules/mdast-util-gfm-strikethrough/to-markdown.js", "node_modules/mdast-util-to-markdown/lib/util/pattern-compile.js", "node_modules/mdast-util-to-markdown/lib/handle/inline-code.js", "node_modules/repeat-string/index.js", "node_modules/markdown-table/index.js", "node_modules/mdast-util-gfm-table/to-markdown.js", "node_modules/mdast-util-to-markdown/lib/util/check-bullet.js", "node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js", "node_modules/mdast-util-to-markdown/lib/util/container-flow.js", "node_modules/mdast-util-to-markdown/lib/util/indent-lines.js", "node_modules/mdast-util-to-markdown/lib/handle/list-item.js", "node_modules/mdast-util-gfm-task-list-item/to-markdown.js", "node_modules/mdast-util-to-markdown/lib/configure.js", "node_modules/mdast-util-gfm/to-markdown.js", "node_modules/remark-gfm/index.js", "node_modules/@tryfabric/martian/src/index.ts", "node_modules/js-yaml/lib/js-yaml/common.js", "node_modules/js-yaml/lib/js-yaml/exception.js", "node_modules/js-yaml/lib/js-yaml/mark.js", "node_modules/js-yaml/lib/js-yaml/type.js", "node_modules/js-yaml/lib/js-yaml/schema.js", "node_modules/js-yaml/lib/js-yaml/type/str.js", "node_modules/js-yaml/lib/js-yaml/type/seq.js", "node_modules/js-yaml/lib/js-yaml/type/map.js", "node_modules/js-yaml/lib/js-yaml/schema/failsafe.js", "node_modules/js-yaml/lib/js-yaml/type/null.js", "node_modules/js-yaml/lib/js-yaml/type/bool.js", "node_modules/js-yaml/lib/js-yaml/type/int.js", "node_modules/js-yaml/lib/js-yaml/type/float.js", "node_modules/js-yaml/lib/js-yaml/schema/json.js", "node_modules/js-yaml/lib/js-yaml/schema/core.js", "node_modules/js-yaml/lib/js-yaml/type/timestamp.js", "node_modules/js-yaml/lib/js-yaml/type/merge.js", "node_modules/js-yaml/lib/js-yaml/type/binary.js", "node_modules/js-yaml/lib/js-yaml/type/omap.js", "node_modules/js-yaml/lib/js-yaml/type/pairs.js", "node_modules/js-yaml/lib/js-yaml/type/set.js", "node_modules/js-yaml/lib/js-yaml/schema/default_safe.js", "node_modules/js-yaml/lib/js-yaml/type/js/undefined.js", "node_modules/js-yaml/lib/js-yaml/type/js/regexp.js", "node_modules/js-yaml/lib/js-yaml/type/js/function.js", "node_modules/js-yaml/lib/js-yaml/schema/default_full.js", "node_modules/js-yaml/lib/js-yaml/loader.js", "node_modules/js-yaml/lib/js-yaml/dumper.js", "node_modules/js-yaml/lib/js-yaml.js", "node_modules/js-yaml/index.js", "main.ts", "icon.ts", "Upload2Notion.ts", "node_modules/yaml-front-matter/src/index.js", "node_modules/yaml/browser/dist/nodes/Node.js", "node_modules/yaml/browser/dist/visit.js", "node_modules/yaml/browser/dist/doc/directives.js", "node_modules/yaml/browser/dist/doc/anchors.js", "node_modules/yaml/browser/dist/nodes/Alias.js", "node_modules/yaml/browser/dist/nodes/toJS.js", "node_modules/yaml/browser/dist/nodes/Scalar.js", "node_modules/yaml/browser/dist/doc/createNode.js", "node_modules/yaml/browser/dist/nodes/Collection.js", "node_modules/yaml/browser/dist/stringify/stringifyComment.js", "node_modules/yaml/browser/dist/stringify/foldFlowLines.js", "node_modules/yaml/browser/dist/stringify/stringifyString.js", "node_modules/yaml/browser/dist/stringify/stringify.js", "node_modules/yaml/browser/dist/stringify/stringifyPair.js", "node_modules/yaml/browser/dist/log.js", "node_modules/yaml/browser/dist/nodes/addPairToJSMap.js", "node_modules/yaml/browser/dist/nodes/Pair.js", "node_modules/yaml/browser/dist/stringify/stringifyCollection.js", "node_modules/yaml/browser/dist/nodes/YAMLMap.js", "node_modules/yaml/browser/dist/schema/common/map.js", "node_modules/yaml/browser/dist/nodes/YAMLSeq.js", "node_modules/yaml/browser/dist/schema/common/seq.js", "node_modules/yaml/browser/dist/schema/common/string.js", "node_modules/yaml/browser/dist/schema/common/null.js", "node_modules/yaml/browser/dist/schema/core/bool.js", "node_modules/yaml/browser/dist/stringify/stringifyNumber.js", "node_modules/yaml/browser/dist/schema/core/float.js", "node_modules/yaml/browser/dist/schema/core/int.js", "node_modules/yaml/browser/dist/schema/core/schema.js", "node_modules/yaml/browser/dist/schema/json/schema.js", "node_modules/yaml/browser/dist/schema/yaml-1.1/binary.js", "node_modules/yaml/browser/dist/schema/yaml-1.1/pairs.js", "node_modules/yaml/browser/dist/schema/yaml-1.1/omap.js", "node_modules/yaml/browser/dist/schema/yaml-1.1/bool.js", "node_modules/yaml/browser/dist/schema/yaml-1.1/float.js", "node_modules/yaml/browser/dist/schema/yaml-1.1/int.js", "node_modules/yaml/browser/dist/schema/yaml-1.1/set.js", "node_modules/yaml/browser/dist/schema/yaml-1.1/timestamp.js", "node_modules/yaml/browser/dist/schema/yaml-1.1/schema.js", "node_modules/yaml/browser/dist/schema/tags.js", "node_modules/yaml/browser/dist/schema/Schema.js", "node_modules/yaml/browser/dist/stringify/stringifyDocument.js", "node_modules/yaml/browser/dist/doc/applyReviver.js", "node_modules/yaml/browser/dist/doc/Document.js", "node_modules/yaml/browser/dist/parse/cst-visit.js", "node_modules/yaml/browser/dist/parse/lexer.js", "node_modules/yaml/browser/dist/public-api.js"],
  "sourcesContent": ["'use strict'\n\nmodule.exports = bail\n\nfunction bail(err) {\n  if (err) {\n    throw err\n  }\n}\n", "/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n\nmodule.exports = function isBuffer (obj) {\n  return obj != null && obj.constructor != null &&\n    typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n", "'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n", "'use strict';\n\nmodule.exports = value => {\n\tif (Object.prototype.toString.call(value) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn prototype === null || prototype === Object.prototype;\n};\n", "'use strict'\n\nvar slice = [].slice\n\nmodule.exports = wrap\n\n// Wrap `fn`.\n// Can be sync or async; return a promise, receive a completion handler, return\n// new values and errors.\nfunction wrap(fn, callback) {\n  var invoked\n\n  return wrapped\n\n  function wrapped() {\n    var params = slice.call(arguments, 0)\n    var callback = fn.length > params.length\n    var result\n\n    if (callback) {\n      params.push(done)\n    }\n\n    try {\n      result = fn.apply(null, params)\n    } catch (error) {\n      // Well, this is quite the pickle.\n      // `fn` received a callback and invoked it (thus continuing the pipeline),\n      // but later also threw an error.\n      // We\u2019re not about to restart the pipeline again, so the only thing left\n      // to do is to throw the thing instead.\n      if (callback && invoked) {\n        throw error\n      }\n\n      return done(error)\n    }\n\n    if (!callback) {\n      if (result && typeof result.then === 'function') {\n        result.then(then, done)\n      } else if (result instanceof Error) {\n        done(result)\n      } else {\n        then(result)\n      }\n    }\n  }\n\n  // Invoke `next`, only once.\n  function done() {\n    if (!invoked) {\n      invoked = true\n\n      callback.apply(null, arguments)\n    }\n  }\n\n  // Invoke `done` with one value.\n  // Tracks if an error is passed, too.\n  function then(value) {\n    done(null, value)\n  }\n}\n", "'use strict'\n\nvar wrap = require('./wrap.js')\n\nmodule.exports = trough\n\ntrough.wrap = wrap\n\nvar slice = [].slice\n\n// Create new middleware.\nfunction trough() {\n  var fns = []\n  var middleware = {}\n\n  middleware.run = run\n  middleware.use = use\n\n  return middleware\n\n  // Run `fns`.  Last argument must be a completion handler.\n  function run() {\n    var index = -1\n    var input = slice.call(arguments, 0, -1)\n    var done = arguments[arguments.length - 1]\n\n    if (typeof done !== 'function') {\n      throw new Error('Expected function as last argument, not ' + done)\n    }\n\n    next.apply(null, [null].concat(input))\n\n    // Run the next `fn`, if any.\n    function next(err) {\n      var fn = fns[++index]\n      var params = slice.call(arguments, 0)\n      var values = params.slice(1)\n      var length = input.length\n      var pos = -1\n\n      if (err) {\n        done(err)\n        return\n      }\n\n      // Copy non-nully input into values.\n      while (++pos < length) {\n        if (values[pos] === null || values[pos] === undefined) {\n          values[pos] = input[pos]\n        }\n      }\n\n      input = values\n\n      // Next or done.\n      if (fn) {\n        wrap(fn, next).apply(null, input)\n      } else {\n        done.apply(null, [null].concat(input))\n      }\n    }\n  }\n\n  // Add `fn` to the list.\n  function use(fn) {\n    if (typeof fn !== 'function') {\n      throw new Error('Expected `fn` to be a function, not ' + fn)\n    }\n\n    fns.push(fn)\n\n    return middleware\n  }\n}\n", "'use strict'\n\nvar own = {}.hasOwnProperty\n\nmodule.exports = stringify\n\nfunction stringify(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return ''\n  }\n\n  // Node.\n  if (own.call(value, 'position') || own.call(value, 'type')) {\n    return position(value.position)\n  }\n\n  // Position.\n  if (own.call(value, 'start') || own.call(value, 'end')) {\n    return position(value)\n  }\n\n  // Point.\n  if (own.call(value, 'line') || own.call(value, 'column')) {\n    return point(value)\n  }\n\n  // ?\n  return ''\n}\n\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {}\n  }\n\n  return index(point.line) + ':' + index(point.column)\n}\n\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {}\n  }\n\n  return point(pos.start) + '-' + point(pos.end)\n}\n\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1\n}\n", "'use strict'\n\nvar stringify = require('unist-util-stringify-position')\n\nmodule.exports = VMessage\n\n// Inherit from `Error#`.\nfunction VMessagePrototype() {}\nVMessagePrototype.prototype = Error.prototype\nVMessage.prototype = new VMessagePrototype()\n\n// Message properties.\nvar proto = VMessage.prototype\n\nproto.file = ''\nproto.name = ''\nproto.reason = ''\nproto.message = ''\nproto.stack = ''\nproto.fatal = null\nproto.column = null\nproto.line = null\n\n// Construct a new VMessage.\n//\n// Note: We cannot invoke `Error` on the created context, as that adds readonly\n// `line` and `column` attributes on Safari 9, thus throwing and failing the\n// data.\nfunction VMessage(reason, position, origin) {\n  var parts\n  var range\n  var location\n\n  if (typeof position === 'string') {\n    origin = position\n    position = null\n  }\n\n  parts = parseOrigin(origin)\n  range = stringify(position) || '1:1'\n\n  location = {\n    start: {line: null, column: null},\n    end: {line: null, column: null}\n  }\n\n  // Node.\n  if (position && position.position) {\n    position = position.position\n  }\n\n  if (position) {\n    // Position.\n    if (position.start) {\n      location = position\n      position = position.start\n    } else {\n      // Point.\n      location.start = position\n    }\n  }\n\n  if (reason.stack) {\n    this.stack = reason.stack\n    reason = reason.message\n  }\n\n  this.message = reason\n  this.name = range\n  this.reason = reason\n  this.line = position ? position.line : null\n  this.column = position ? position.column : null\n  this.location = location\n  this.source = parts[0]\n  this.ruleId = parts[1]\n}\n\nfunction parseOrigin(origin) {\n  var result = [null, null]\n  var index\n\n  if (typeof origin === 'string') {\n    index = origin.indexOf(':')\n\n    if (index === -1) {\n      result[1] = origin\n    } else {\n      result[0] = origin.slice(0, index)\n      result[1] = origin.slice(index + 1)\n    }\n  }\n\n  return result\n}\n", "'use strict'\n\n// A derivative work based on:\n// <https://github.com/browserify/path-browserify>.\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node\u2019s internal `path` module:\n// <https://github.com/nodejs/node/blob/master/lib/path.js>.\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexports.basename = basename\nexports.dirname = dirname\nexports.extname = extname\nexports.join = join\nexports.sep = '/'\n\nfunction basename(path, ext) {\n  var start = 0\n  var end = -1\n  var index\n  var firstNonSlashEnd\n  var seenNonSlash\n  var extIndex\n\n  if (ext !== undefined && typeof ext !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string')\n  }\n\n  assertPath(path)\n  index = path.length\n\n  if (ext === undefined || !ext.length || ext.length > path.length) {\n    while (index--) {\n      if (path.charCodeAt(index) === 47 /* `/` */) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (seenNonSlash) {\n          start = index + 1\n          break\n        }\n      } else if (end < 0) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component.\n        seenNonSlash = true\n        end = index + 1\n      }\n    }\n\n    return end < 0 ? '' : path.slice(start, end)\n  }\n\n  if (ext === path) {\n    return ''\n  }\n\n  firstNonSlashEnd = -1\n  extIndex = ext.length - 1\n\n  while (index--) {\n    if (path.charCodeAt(index) === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (seenNonSlash) {\n        start = index + 1\n        break\n      }\n    } else {\n      if (firstNonSlashEnd < 0) {\n        // We saw the first non-path separator, remember this index in case\n        // we need it if the extension ends up not matching.\n        seenNonSlash = true\n        firstNonSlashEnd = index + 1\n      }\n\n      if (extIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n          if (extIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extIndex = -1\n          end = firstNonSlashEnd\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd\n  } else if (end < 0) {\n    end = path.length\n  }\n\n  return path.slice(start, end)\n}\n\nfunction dirname(path) {\n  var end\n  var unmatchedSlash\n  var index\n\n  assertPath(path)\n\n  if (!path.length) {\n    return '.'\n  }\n\n  end = -1\n  index = path.length\n\n  // Prefix `--` is important to not run on `0`.\n  while (--index) {\n    if (path.charCodeAt(index) === 47 /* `/` */) {\n      if (unmatchedSlash) {\n        end = index\n        break\n      }\n    } else if (!unmatchedSlash) {\n      // We saw the first non-path separator\n      unmatchedSlash = true\n    }\n  }\n\n  return end < 0\n    ? path.charCodeAt(0) === 47 /* `/` */\n      ? '/'\n      : '.'\n    : end === 1 && path.charCodeAt(0) === 47 /* `/` */\n    ? '//'\n    : path.slice(0, end)\n}\n\nfunction extname(path) {\n  var startDot = -1\n  var startPart = 0\n  var end = -1\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n  var preDotState = 0\n  var unmatchedSlash\n  var code\n  var index\n\n  assertPath(path)\n\n  index = path.length\n\n  while (index--) {\n    code = path.charCodeAt(index)\n\n    if (code === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (unmatchedSlash) {\n        startPart = index + 1\n        break\n      }\n\n      continue\n    }\n\n    if (end < 0) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension.\n      unmatchedSlash = true\n      end = index + 1\n    }\n\n    if (code === 46 /* `.` */) {\n      // If this is our first dot, mark it as the start of our extension.\n      if (startDot < 0) {\n        startDot = index\n      } else if (preDotState !== 1) {\n        preDotState = 1\n      }\n    } else if (startDot > -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension.\n      preDotState = -1\n    }\n  }\n\n  if (\n    startDot < 0 ||\n    end < 0 ||\n    // We saw a non-dot character immediately before the dot.\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly `..`.\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return ''\n  }\n\n  return path.slice(startDot, end)\n}\n\nfunction join() {\n  var index = -1\n  var joined\n\n  while (++index < arguments.length) {\n    assertPath(arguments[index])\n\n    if (arguments[index]) {\n      joined =\n        joined === undefined\n          ? arguments[index]\n          : joined + '/' + arguments[index]\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined)\n}\n\n// Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\nfunction normalize(path) {\n  var absolute\n  var value\n\n  assertPath(path)\n\n  absolute = path.charCodeAt(0) === 47 /* `/` */\n\n  // Normalize the path according to POSIX rules.\n  value = normalizeString(path, !absolute)\n\n  if (!value.length && !absolute) {\n    value = '.'\n  }\n\n  if (value.length && path.charCodeAt(path.length - 1) === 47 /* / */) {\n    value += '/'\n  }\n\n  return absolute ? '/' + value : value\n}\n\n// Resolve `.` and `..` elements in a path with directory names.\nfunction normalizeString(path, allowAboveRoot) {\n  var result = ''\n  var lastSegmentLength = 0\n  var lastSlash = -1\n  var dots = 0\n  var index = -1\n  var code\n  var lastSlashIndex\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.charCodeAt(index)\n    } else if (code === 47 /* `/` */) {\n      break\n    } else {\n      code = 47 /* `/` */\n    }\n\n    if (code === 47 /* `/` */) {\n      if (lastSlash === index - 1 || dots === 1) {\n        // Empty.\n      } else if (lastSlash !== index - 1 && dots === 2) {\n        if (\n          result.length < 2 ||\n          lastSegmentLength !== 2 ||\n          result.charCodeAt(result.length - 1) !== 46 /* `.` */ ||\n          result.charCodeAt(result.length - 2) !== 46 /* `.` */\n        ) {\n          if (result.length > 2) {\n            lastSlashIndex = result.lastIndexOf('/')\n\n            /* istanbul ignore else - No clue how to cover it. */\n            if (lastSlashIndex !== result.length - 1) {\n              if (lastSlashIndex < 0) {\n                result = ''\n                lastSegmentLength = 0\n              } else {\n                result = result.slice(0, lastSlashIndex)\n                lastSegmentLength = result.length - 1 - result.lastIndexOf('/')\n              }\n\n              lastSlash = index\n              dots = 0\n              continue\n            }\n          } else if (result.length) {\n            result = ''\n            lastSegmentLength = 0\n            lastSlash = index\n            dots = 0\n            continue\n          }\n        }\n\n        if (allowAboveRoot) {\n          result = result.length ? result + '/..' : '..'\n          lastSegmentLength = 2\n        }\n      } else {\n        if (result.length) {\n          result += '/' + path.slice(lastSlash + 1, index)\n        } else {\n          result = path.slice(lastSlash + 1, index)\n        }\n\n        lastSegmentLength = index - lastSlash - 1\n      }\n\n      lastSlash = index\n      dots = 0\n    } else if (code === 46 /* `.` */ && dots > -1) {\n      dots++\n    } else {\n      dots = -1\n    }\n  }\n\n  return result\n}\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError(\n      'Path must be a string. Received ' + JSON.stringify(path)\n    )\n  }\n}\n", "'use strict'\n\n// Somewhat based on:\n// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.\n// But I don\u2019t think one tiny line of code can be copyrighted. \uD83D\uDE05\nexports.cwd = cwd\n\nfunction cwd() {\n  return '/'\n}\n", "'use strict'\n\nvar p = require('./minpath')\nvar proc = require('./minproc')\nvar buffer = require('is-buffer')\n\nmodule.exports = VFile\n\nvar own = {}.hasOwnProperty\n\n// Order of setting (least specific to most), we need this because otherwise\n// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n// stem can be set.\nvar order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname']\n\nVFile.prototype.toString = toString\n\n// Access full path (`~/index.min.js`).\nObject.defineProperty(VFile.prototype, 'path', {get: getPath, set: setPath})\n\n// Access parent path (`~`).\nObject.defineProperty(VFile.prototype, 'dirname', {\n  get: getDirname,\n  set: setDirname\n})\n\n// Access basename (`index.min.js`).\nObject.defineProperty(VFile.prototype, 'basename', {\n  get: getBasename,\n  set: setBasename\n})\n\n// Access extname (`.js`).\nObject.defineProperty(VFile.prototype, 'extname', {\n  get: getExtname,\n  set: setExtname\n})\n\n// Access stem (`index.min`).\nObject.defineProperty(VFile.prototype, 'stem', {get: getStem, set: setStem})\n\n// Construct a new file.\nfunction VFile(options) {\n  var prop\n  var index\n\n  if (!options) {\n    options = {}\n  } else if (typeof options === 'string' || buffer(options)) {\n    options = {contents: options}\n  } else if ('message' in options && 'messages' in options) {\n    return options\n  }\n\n  if (!(this instanceof VFile)) {\n    return new VFile(options)\n  }\n\n  this.data = {}\n  this.messages = []\n  this.history = []\n  this.cwd = proc.cwd()\n\n  // Set path related properties in the correct order.\n  index = -1\n\n  while (++index < order.length) {\n    prop = order[index]\n\n    if (own.call(options, prop)) {\n      this[prop] = options[prop]\n    }\n  }\n\n  // Set non-path related properties.\n  for (prop in options) {\n    if (order.indexOf(prop) < 0) {\n      this[prop] = options[prop]\n    }\n  }\n}\n\nfunction getPath() {\n  return this.history[this.history.length - 1]\n}\n\nfunction setPath(path) {\n  assertNonEmpty(path, 'path')\n\n  if (this.path !== path) {\n    this.history.push(path)\n  }\n}\n\nfunction getDirname() {\n  return typeof this.path === 'string' ? p.dirname(this.path) : undefined\n}\n\nfunction setDirname(dirname) {\n  assertPath(this.path, 'dirname')\n  this.path = p.join(dirname || '', this.basename)\n}\n\nfunction getBasename() {\n  return typeof this.path === 'string' ? p.basename(this.path) : undefined\n}\n\nfunction setBasename(basename) {\n  assertNonEmpty(basename, 'basename')\n  assertPart(basename, 'basename')\n  this.path = p.join(this.dirname || '', basename)\n}\n\nfunction getExtname() {\n  return typeof this.path === 'string' ? p.extname(this.path) : undefined\n}\n\nfunction setExtname(extname) {\n  assertPart(extname, 'extname')\n  assertPath(this.path, 'extname')\n\n  if (extname) {\n    if (extname.charCodeAt(0) !== 46 /* `.` */) {\n      throw new Error('`extname` must start with `.`')\n    }\n\n    if (extname.indexOf('.', 1) > -1) {\n      throw new Error('`extname` cannot contain multiple dots')\n    }\n  }\n\n  this.path = p.join(this.dirname, this.stem + (extname || ''))\n}\n\nfunction getStem() {\n  return typeof this.path === 'string'\n    ? p.basename(this.path, this.extname)\n    : undefined\n}\n\nfunction setStem(stem) {\n  assertNonEmpty(stem, 'stem')\n  assertPart(stem, 'stem')\n  this.path = p.join(this.dirname || '', stem + (this.extname || ''))\n}\n\n// Get the value of the file.\nfunction toString(encoding) {\n  return (this.contents || '').toString(encoding)\n}\n\n// Assert that `part` is not a path (i.e., does not contain `p.sep`).\nfunction assertPart(part, name) {\n  if (part && part.indexOf(p.sep) > -1) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + p.sep + '`'\n    )\n  }\n}\n\n// Assert that `part` is not empty.\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty')\n  }\n}\n\n// Assert `path` exists.\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too')\n  }\n}\n", "'use strict'\n\nvar VMessage = require('vfile-message')\nvar VFile = require('./core.js')\n\nmodule.exports = VFile\n\nVFile.prototype.message = message\nVFile.prototype.info = info\nVFile.prototype.fail = fail\n\n// Create a message with `reason` at `position`.\n// When an error is passed in as `reason`, copies the stack.\nfunction message(reason, position, origin) {\n  var message = new VMessage(reason, position, origin)\n\n  if (this.path) {\n    message.name = this.path + ':' + message.name\n    message.file = this.path\n  }\n\n  message.fatal = false\n\n  this.messages.push(message)\n\n  return message\n}\n\n// Fail: creates a vmessage, associates it with the file, and throws it.\nfunction fail() {\n  var message = this.message.apply(this, arguments)\n\n  message.fatal = true\n\n  throw message\n}\n\n// Info: creates a vmessage, associates it with the file, and marks the fatality\n// as null.\nfunction info() {\n  var message = this.message.apply(this, arguments)\n\n  message.fatal = null\n\n  return message\n}\n", "'use strict'\n\nmodule.exports = require('./lib')\n", "'use strict'\n\nvar bail = require('bail')\nvar buffer = require('is-buffer')\nvar extend = require('extend')\nvar plain = require('is-plain-obj')\nvar trough = require('trough')\nvar vfile = require('vfile')\n\n// Expose a frozen processor.\nmodule.exports = unified().freeze()\n\nvar slice = [].slice\nvar own = {}.hasOwnProperty\n\n// Process pipeline.\nvar pipeline = trough()\n  .use(pipelineParse)\n  .use(pipelineRun)\n  .use(pipelineStringify)\n\nfunction pipelineParse(p, ctx) {\n  ctx.tree = p.parse(ctx.file)\n}\n\nfunction pipelineRun(p, ctx, next) {\n  p.run(ctx.tree, ctx.file, done)\n\n  function done(error, tree, file) {\n    if (error) {\n      next(error)\n    } else {\n      ctx.tree = tree\n      ctx.file = file\n      next()\n    }\n  }\n}\n\nfunction pipelineStringify(p, ctx) {\n  var result = p.stringify(ctx.tree, ctx.file)\n\n  if (result === undefined || result === null) {\n    // Empty.\n  } else if (typeof result === 'string' || buffer(result)) {\n    if ('value' in ctx.file) {\n      ctx.file.value = result\n    }\n\n    ctx.file.contents = result\n  } else {\n    ctx.file.result = result\n  }\n}\n\n// Function to create the first processor.\nfunction unified() {\n  var attachers = []\n  var transformers = trough()\n  var namespace = {}\n  var freezeIndex = -1\n  var frozen\n\n  // Data management.\n  processor.data = data\n\n  // Lock.\n  processor.freeze = freeze\n\n  // Plugins.\n  processor.attachers = attachers\n  processor.use = use\n\n  // API.\n  processor.parse = parse\n  processor.stringify = stringify\n  processor.run = run\n  processor.runSync = runSync\n  processor.process = process\n  processor.processSync = processSync\n\n  // Expose.\n  return processor\n\n  // Create a new processor based on the processor in the current scope.\n  function processor() {\n    var destination = unified()\n    var index = -1\n\n    while (++index < attachers.length) {\n      destination.use.apply(null, attachers[index])\n    }\n\n    destination.data(extend(true, {}, namespace))\n\n    return destination\n  }\n\n  // Freeze: used to signal a processor that has finished configuration.\n  //\n  // For example, take unified itself: it\u2019s frozen.\n  // Plugins should not be added to it.\n  // Rather, it should be extended, by invoking it, before modifying it.\n  //\n  // In essence, always invoke this when exporting a processor.\n  function freeze() {\n    var values\n    var transformer\n\n    if (frozen) {\n      return processor\n    }\n\n    while (++freezeIndex < attachers.length) {\n      values = attachers[freezeIndex]\n\n      if (values[1] === false) {\n        continue\n      }\n\n      if (values[1] === true) {\n        values[1] = undefined\n      }\n\n      transformer = values[0].apply(processor, values.slice(1))\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer)\n      }\n    }\n\n    frozen = true\n    freezeIndex = Infinity\n\n    return processor\n  }\n\n  // Data management.\n  // Getter / setter for processor-specific informtion.\n  function data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen)\n        namespace[key] = value\n        return processor\n      }\n\n      // Get `key`.\n      return (own.call(namespace, key) && namespace[key]) || null\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', frozen)\n      namespace = key\n      return processor\n    }\n\n    // Get space.\n    return namespace\n  }\n\n  // Plugin management.\n  //\n  // Pass it:\n  // *   an attacher and options,\n  // *   a preset,\n  // *   a list of presets, attachers, and arguments (list of attachers and\n  //     options).\n  function use(value) {\n    var settings\n\n    assertUnfrozen('use', frozen)\n\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin.apply(null, arguments)\n    } else if (typeof value === 'object') {\n      if ('length' in value) {\n        addList(value)\n      } else {\n        addPreset(value)\n      }\n    } else {\n      throw new Error('Expected usable value, not `' + value + '`')\n    }\n\n    if (settings) {\n      namespace.settings = extend(namespace.settings || {}, settings)\n    }\n\n    return processor\n\n    function addPreset(result) {\n      addList(result.plugins)\n\n      if (result.settings) {\n        settings = extend(settings || {}, result.settings)\n      }\n    }\n\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value)\n      } else if (typeof value === 'object') {\n        if ('length' in value) {\n          addPlugin.apply(null, value)\n        } else {\n          addPreset(value)\n        }\n      } else {\n        throw new Error('Expected usable value, not `' + value + '`')\n      }\n    }\n\n    function addList(plugins) {\n      var index = -1\n\n      if (plugins === null || plugins === undefined) {\n        // Empty.\n      } else if (typeof plugins === 'object' && 'length' in plugins) {\n        while (++index < plugins.length) {\n          add(plugins[index])\n        }\n      } else {\n        throw new Error('Expected a list of plugins, not `' + plugins + '`')\n      }\n    }\n\n    function addPlugin(plugin, value) {\n      var entry = find(plugin)\n\n      if (entry) {\n        if (plain(entry[1]) && plain(value)) {\n          value = extend(true, entry[1], value)\n        }\n\n        entry[1] = value\n      } else {\n        attachers.push(slice.call(arguments))\n      }\n    }\n  }\n\n  function find(plugin) {\n    var index = -1\n\n    while (++index < attachers.length) {\n      if (attachers[index][0] === plugin) {\n        return attachers[index]\n      }\n    }\n  }\n\n  // Parse a file (in string or vfile representation) into a unist node using\n  // the `Parser` on the processor.\n  function parse(doc) {\n    var file = vfile(doc)\n    var Parser\n\n    freeze()\n    Parser = processor.Parser\n    assertParser('parse', Parser)\n\n    if (newable(Parser, 'parse')) {\n      return new Parser(String(file), file).parse()\n    }\n\n    return Parser(String(file), file) // eslint-disable-line new-cap\n  }\n\n  // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), async.\n  function run(node, file, cb) {\n    assertNode(node)\n    freeze()\n\n    if (!cb && typeof file === 'function') {\n      cb = file\n      file = null\n    }\n\n    if (!cb) {\n      return new Promise(executor)\n    }\n\n    executor(null, cb)\n\n    function executor(resolve, reject) {\n      transformers.run(node, vfile(file), done)\n\n      function done(error, tree, file) {\n        tree = tree || node\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(tree)\n        } else {\n          cb(null, tree, file)\n        }\n      }\n    }\n  }\n\n  // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), sync.\n  function runSync(node, file) {\n    var result\n    var complete\n\n    run(node, file, done)\n\n    assertDone('runSync', 'run', complete)\n\n    return result\n\n    function done(error, tree) {\n      complete = true\n      result = tree\n      bail(error)\n    }\n  }\n\n  // Stringify a unist node representation of a file (in string or vfile\n  // representation) into a string using the `Compiler` on the processor.\n  function stringify(node, doc) {\n    var file = vfile(doc)\n    var Compiler\n\n    freeze()\n    Compiler = processor.Compiler\n    assertCompiler('stringify', Compiler)\n    assertNode(node)\n\n    if (newable(Compiler, 'compile')) {\n      return new Compiler(node, file).compile()\n    }\n\n    return Compiler(node, file) // eslint-disable-line new-cap\n  }\n\n  // Parse a file (in string or vfile representation) into a unist node using\n  // the `Parser` on the processor, then run transforms on that node, and\n  // compile the resulting node using the `Compiler` on the processor, and\n  // store that result on the vfile.\n  function process(doc, cb) {\n    freeze()\n    assertParser('process', processor.Parser)\n    assertCompiler('process', processor.Compiler)\n\n    if (!cb) {\n      return new Promise(executor)\n    }\n\n    executor(null, cb)\n\n    function executor(resolve, reject) {\n      var file = vfile(doc)\n\n      pipeline.run(processor, {file: file}, done)\n\n      function done(error) {\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          cb(null, file)\n        }\n      }\n    }\n  }\n\n  // Process the given document (in string or vfile representation), sync.\n  function processSync(doc) {\n    var file\n    var complete\n\n    freeze()\n    assertParser('processSync', processor.Parser)\n    assertCompiler('processSync', processor.Compiler)\n    file = vfile(doc)\n\n    process(file, done)\n\n    assertDone('processSync', 'process', complete)\n\n    return file\n\n    function done(error) {\n      complete = true\n      bail(error)\n    }\n  }\n}\n\n// Check if `value` is a constructor.\nfunction newable(value, name) {\n  return (\n    typeof value === 'function' &&\n    value.prototype &&\n    // A function with keys in its prototype is probably a constructor.\n    // Classes\u2019 prototype methods are not enumerable, so we check if some value\n    // exists in the prototype.\n    (keys(value.prototype) || name in value.prototype)\n  )\n}\n\n// Check if `value` is an object with keys.\nfunction keys(value) {\n  var key\n  for (key in value) {\n    return true\n  }\n\n  return false\n}\n\n// Assert a parser is available.\nfunction assertParser(name, Parser) {\n  if (typeof Parser !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Parser`')\n  }\n}\n\n// Assert a compiler is available.\nfunction assertCompiler(name, Compiler) {\n  if (typeof Compiler !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Compiler`')\n  }\n}\n\n// Assert the processor is not frozen.\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error(\n      'Cannot invoke `' +\n        name +\n        '` on a frozen processor.\\nCreate a new processor first, by invoking it: use `processor()` instead of `processor`.'\n    )\n  }\n}\n\n// Assert `node` is a unist node.\nfunction assertNode(node) {\n  if (!node || typeof node.type !== 'string') {\n    throw new Error('Expected node, got `' + node + '`')\n  }\n}\n\n// Assert that `complete` is `true`.\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error(\n      '`' + name + '` finished async. Use `' + asyncName + '` instead'\n    )\n  }\n}\n", "'use strict'\n\nmodule.exports = toString\n\n// Get the text content of a node.\n// Prefer the node\u2019s plain-text fields, otherwise serialize its children,\n// and if the given value is an array, serialize the nodes in it.\nfunction toString(node) {\n  return (\n    (node &&\n      (node.value ||\n        node.alt ||\n        node.title ||\n        ('children' in node && all(node.children)) ||\n        ('length' in node && all(node)))) ||\n    ''\n  )\n}\n\nfunction all(values) {\n  var result = []\n  var index = -1\n\n  while (++index < values.length) {\n    result[index] = toString(values[index])\n  }\n\n  return result.join('')\n}\n", "'use strict'\n\nvar assign = Object.assign\n\nmodule.exports = assign\n", "'use strict'\n\nvar own = {}.hasOwnProperty\n\nmodule.exports = own\n", "'use strict'\n\nfunction normalizeIdentifier(value) {\n  return (\n    value // Collapse Markdown whitespace.\n      .replace(/[\\t\\n\\r ]+/g, ' ') // Trim.\n      .replace(/^ | $/g, '') // Some characters are considered \u201Cuppercase\u201D, but if their lowercase\n      // counterpart is uppercased will result in a different uppercase\n      // character.\n      // Hence, to get that form, we perform both lower- and uppercase.\n      // Upper case makes sure keys will not interact with default prototypal\n      // methods: no object method is uppercase.\n      .toLowerCase()\n      .toUpperCase()\n  )\n}\n\nmodule.exports = normalizeIdentifier\n", "'use strict'\n\nvar fromCharCode = String.fromCharCode\n\nmodule.exports = fromCharCode\n", "'use strict'\n\nvar fromCharCode = require('../constant/from-char-code.js')\n\nfunction safeFromInt(value, base) {\n  var code = parseInt(value, base)\n\n  if (\n    // C0 except for HT, LF, FF, CR, space\n    code < 9 ||\n    code === 11 ||\n    (code > 13 && code < 32) || // Control character (DEL) of the basic block and C1 controls.\n    (code > 126 && code < 160) || // Lone high surrogates and low surrogates.\n    (code > 55295 && code < 57344) || // Noncharacters.\n    (code > 64975 && code < 65008) ||\n    (code & 65535) === 65535 ||\n    (code & 65535) === 65534 || // Out of range\n    code > 1114111\n  ) {\n    return '\\uFFFD'\n  }\n\n  return fromCharCode(code)\n}\n\nmodule.exports = safeFromInt\n", "'use strict'\n\nfunction markdownLineEnding(code) {\n  return code < -2\n}\n\nmodule.exports = markdownLineEnding\n", "'use strict'\n\nfunction markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\n}\n\nmodule.exports = markdownSpace\n", "'use strict'\n\nvar markdownSpace = require('../character/markdown-space.js')\n\nfunction spaceFactory(effects, ok, type, max) {\n  var limit = max ? max - 1 : Infinity\n  var size = 0\n  return start\n\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n\n    return ok(code)\n  }\n\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n\n    effects.exit(type)\n    return ok(code)\n  }\n}\n\nmodule.exports = spaceFactory\n", "'use strict'\n\nObject.defineProperty(exports, '__esModule', {value: true})\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar factorySpace = require('../tokenize/factory-space.js')\n\nvar tokenize = initializeContent\n\nfunction initializeContent(effects) {\n  var contentStart = effects.attempt(\n    this.parser.constructs.contentInitial,\n    afterContentStartConstruct,\n    paragraphInitial\n  )\n  var previous\n  return contentStart\n\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, contentStart, 'linePrefix')\n  }\n\n  function paragraphInitial(code) {\n    effects.enter('paragraph')\n    return lineStart(code)\n  }\n\n  function lineStart(code) {\n    var token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous: previous\n    })\n\n    if (previous) {\n      previous.next = token\n    }\n\n    previous = token\n    return data(code)\n  }\n\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText')\n      effects.exit('paragraph')\n      effects.consume(code)\n      return\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      effects.exit('chunkText')\n      return lineStart\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n}\n\nexports.tokenize = tokenize\n", "'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar factorySpace = require('./factory-space.js')\n\nvar partialBlankLine = {\n  tokenize: tokenizePartialBlankLine,\n  partial: true\n}\n\nfunction tokenizePartialBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix')\n\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n\nmodule.exports = partialBlankLine\n", "'use strict'\n\nObject.defineProperty(exports, '__esModule', {value: true})\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar factorySpace = require('../tokenize/factory-space.js')\nvar partialBlankLine = require('../tokenize/partial-blank-line.js')\n\nvar tokenize = initializeDocument\nvar containerConstruct = {\n  tokenize: tokenizeContainer\n}\nvar lazyFlowConstruct = {\n  tokenize: tokenizeLazyFlow\n}\n\nfunction initializeDocument(effects) {\n  var self = this\n  var stack = []\n  var continued = 0\n  var inspectConstruct = {\n    tokenize: tokenizeInspect,\n    partial: true\n  }\n  var inspectResult\n  var childFlow\n  var childToken\n  return start\n\n  function start(code) {\n    if (continued < stack.length) {\n      self.containerState = stack[continued][1]\n      return effects.attempt(\n        stack[continued][0].continuation,\n        documentContinue,\n        documentContinued\n      )(code)\n    }\n\n    return documentContinued(code)\n  }\n\n  function documentContinue(code) {\n    continued++\n    return start(code)\n  }\n\n  function documentContinued(code) {\n    // If we\u2019re in a concrete construct (such as when expecting another line of\n    // HTML, or we resulted in lazy content), we can immediately start flow.\n    if (inspectResult && inspectResult.flowContinue) {\n      return flowStart(code)\n    }\n\n    self.interrupt =\n      childFlow &&\n      childFlow.currentConstruct &&\n      childFlow.currentConstruct.interruptible\n    self.containerState = {}\n    return effects.attempt(\n      containerConstruct,\n      containerContinue,\n      flowStart\n    )(code)\n  }\n\n  function containerContinue(code) {\n    stack.push([self.currentConstruct, self.containerState])\n    self.containerState = undefined\n    return documentContinued(code)\n  }\n\n  function flowStart(code) {\n    if (code === null) {\n      exitContainers(0, true)\n      effects.consume(code)\n      return\n    }\n\n    childFlow = childFlow || self.parser.flow(self.now())\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    })\n    return flowContinue(code)\n  }\n\n  function flowContinue(code) {\n    if (code === null) {\n      continueFlow(effects.exit('chunkFlow'))\n      return flowStart(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      continueFlow(effects.exit('chunkFlow'))\n      return effects.check(inspectConstruct, documentAfterPeek)\n    }\n\n    effects.consume(code)\n    return flowContinue\n  }\n\n  function documentAfterPeek(code) {\n    exitContainers(\n      inspectResult.continued,\n      inspectResult && inspectResult.flowEnd\n    )\n    continued = 0\n    return start(code)\n  }\n\n  function continueFlow(token) {\n    if (childToken) childToken.next = token\n    childToken = token\n    childFlow.lazy = inspectResult && inspectResult.lazy\n    childFlow.defineSkip(token.start)\n    childFlow.write(self.sliceStream(token))\n  }\n\n  function exitContainers(size, end) {\n    var index = stack.length // Close the flow.\n\n    if (childFlow && end) {\n      childFlow.write([null])\n      childToken = childFlow = undefined\n    } // Exit open containers.\n\n    while (index-- > size) {\n      self.containerState = stack[index][1]\n      stack[index][0].exit.call(self, effects)\n    }\n\n    stack.length = size\n  }\n\n  function tokenizeInspect(effects, ok) {\n    var subcontinued = 0\n    inspectResult = {}\n    return inspectStart\n\n    function inspectStart(code) {\n      if (subcontinued < stack.length) {\n        self.containerState = stack[subcontinued][1]\n        return effects.attempt(\n          stack[subcontinued][0].continuation,\n          inspectContinue,\n          inspectLess\n        )(code)\n      } // If we\u2019re continued but in a concrete flow, we can\u2019t have more\n      // containers.\n\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        inspectResult.flowContinue = true\n        return inspectDone(code)\n      }\n\n      self.interrupt =\n        childFlow.currentConstruct && childFlow.currentConstruct.interruptible\n      self.containerState = {}\n      return effects.attempt(\n        containerConstruct,\n        inspectFlowEnd,\n        inspectDone\n      )(code)\n    }\n\n    function inspectContinue(code) {\n      subcontinued++\n      return self.containerState._closeFlow\n        ? inspectFlowEnd(code)\n        : inspectStart(code)\n    }\n\n    function inspectLess(code) {\n      if (childFlow.currentConstruct && childFlow.currentConstruct.lazy) {\n        // Maybe another container?\n        self.containerState = {}\n        return effects.attempt(\n          containerConstruct,\n          inspectFlowEnd, // Maybe flow, or a blank line?\n          effects.attempt(\n            lazyFlowConstruct,\n            inspectFlowEnd,\n            effects.check(partialBlankLine, inspectFlowEnd, inspectLazy)\n          )\n        )(code)\n      } // Otherwise we\u2019re interrupting.\n\n      return inspectFlowEnd(code)\n    }\n\n    function inspectLazy(code) {\n      // Act as if all containers are continued.\n      subcontinued = stack.length\n      inspectResult.lazy = true\n      inspectResult.flowContinue = true\n      return inspectDone(code)\n    } // We\u2019re done with flow if we have more containers, or an interruption.\n\n    function inspectFlowEnd(code) {\n      inspectResult.flowEnd = true\n      return inspectDone(code)\n    }\n\n    function inspectDone(code) {\n      inspectResult.continued = subcontinued\n      self.interrupt = self.containerState = undefined\n      return ok(code)\n    }\n  }\n}\n\nfunction tokenizeContainer(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(this.parser.constructs.document, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.indexOf('codeIndented') > -1\n      ? undefined\n      : 4\n  )\n}\n\nfunction tokenizeLazyFlow(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.lazy(this.parser.constructs.flow, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.indexOf('codeIndented') > -1\n      ? undefined\n      : 4\n  )\n}\n\nexports.tokenize = tokenize\n", "'use strict'\n\n// Counts tabs based on their expanded size, and CR+LF as one character.\n\nfunction sizeChunks(chunks) {\n  var index = -1\n  var size = 0\n\n  while (++index < chunks.length) {\n    size += typeof chunks[index] === 'string' ? chunks[index].length : 1\n  }\n\n  return size\n}\n\nmodule.exports = sizeChunks\n", "'use strict'\n\nvar sizeChunks = require('./size-chunks.js')\n\nfunction prefixSize(events, type) {\n  var tail = events[events.length - 1]\n  if (!tail || tail[1].type !== type) return 0\n  return sizeChunks(tail[2].sliceStream(tail[1]))\n}\n\nmodule.exports = prefixSize\n", "'use strict'\n\nvar splice = [].splice\n\nmodule.exports = splice\n", "'use strict'\n\nvar splice = require('../constant/splice.js')\n\n// causes a stack overflow in V8 when trying to insert 100k items for instance.\n\nfunction chunkedSplice(list, start, remove, items) {\n  var end = list.length\n  var chunkStart = 0\n  var parameters // Make start between zero and `end` (included).\n\n  if (start < 0) {\n    start = -start > end ? 0 : end + start\n  } else {\n    start = start > end ? end : start\n  }\n\n  remove = remove > 0 ? remove : 0 // No need to chunk the items if there\u2019s only a couple (10k) items.\n\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove)\n    splice.apply(list, parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) splice.apply(list, [start, remove]) // Insert the items in chunks to not cause stack overflows.\n\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0)\n      splice.apply(list, parameters)\n      chunkStart += 10000\n      start += 10000\n    }\n  }\n}\n\nmodule.exports = chunkedSplice\n", "'use strict'\n\nvar assign = require('../constant/assign.js')\n\nfunction shallow(object) {\n  return assign({}, object)\n}\n\nmodule.exports = shallow\n", "'use strict'\n\nvar assign = require('../constant/assign.js')\nvar chunkedSplice = require('./chunked-splice.js')\nvar shallow = require('./shallow.js')\n\nfunction subtokenize(events) {\n  var jumps = {}\n  var index = -1\n  var event\n  var lineIndex\n  var otherIndex\n  var otherEvent\n  var parameters\n  var subevents\n  var more\n\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index]\n    }\n\n    event = events[index] // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n\n    if (\n      index &&\n      event[1].type === 'chunkFlow' &&\n      events[index - 1][1].type === 'listItemPrefix'\n    ) {\n      subevents = event[1]._tokenizer.events\n      otherIndex = 0\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'lineEndingBlank'\n      ) {\n        otherIndex += 2\n      }\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'content'\n      ) {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break\n          }\n\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1].isInFirstContentOfListItem = true\n            otherIndex++\n          }\n        }\n      }\n    } // Enter.\n\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        assign(jumps, subcontent(events, index))\n        index = jumps[index]\n        more = true\n      }\n    } // Exit.\n    else if (event[1]._container || event[1]._movePreviousLineEndings) {\n      otherIndex = index\n      lineIndex = undefined\n\n      while (otherIndex--) {\n        otherEvent = events[otherIndex]\n\n        if (\n          otherEvent[1].type === 'lineEnding' ||\n          otherEvent[1].type === 'lineEndingBlank'\n        ) {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank'\n            }\n\n            otherEvent[1].type = 'lineEnding'\n            lineIndex = otherIndex\n          }\n        } else {\n          break\n        }\n      }\n\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = shallow(events[lineIndex][1].start) // Switch container exit w/ line endings.\n\n        parameters = events.slice(lineIndex, index)\n        parameters.unshift(event)\n        chunkedSplice(events, lineIndex, index - lineIndex + 1, parameters)\n      }\n    }\n  }\n\n  return !more\n}\n\nfunction subcontent(events, eventIndex) {\n  var token = events[eventIndex][1]\n  var context = events[eventIndex][2]\n  var startPosition = eventIndex - 1\n  var startPositions = []\n  var tokenizer =\n    token._tokenizer || context.parser[token.contentType](token.start)\n  var childEvents = tokenizer.events\n  var jumps = []\n  var gaps = {}\n  var stream\n  var previous\n  var index\n  var entered\n  var end\n  var adjust // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n\n  while (token) {\n    // Find the position of the event for this token.\n    while (events[++startPosition][1] !== token) {\n      // Empty.\n    }\n\n    startPositions.push(startPosition)\n\n    if (!token._tokenizer) {\n      stream = context.sliceStream(token)\n\n      if (!token.next) {\n        stream.push(null)\n      }\n\n      if (previous) {\n        tokenizer.defineSkip(token.start)\n      }\n\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true\n      }\n\n      tokenizer.write(stream)\n\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined\n      }\n    } // Unravel the next token.\n\n    previous = token\n    token = token.next\n  } // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n\n  token = previous\n  index = childEvents.length\n\n  while (index--) {\n    // Make sure we\u2019ve at least seen something (final eol is part of the last\n    // token).\n    if (childEvents[index][0] === 'enter') {\n      entered = true\n    } else if (\n      // Find a void token that includes a break.\n      entered &&\n      childEvents[index][1].type === childEvents[index - 1][1].type &&\n      childEvents[index][1].start.line !== childEvents[index][1].end.line\n    ) {\n      add(childEvents.slice(index + 1, end))\n      // Help GC.\n      token._tokenizer = token.next = undefined\n      token = token.previous\n      end = index + 1\n    }\n  }\n\n  // Help GC.\n  tokenizer.events = token._tokenizer = token.next = undefined // Do head:\n\n  add(childEvents.slice(0, end))\n  index = -1\n  adjust = 0\n\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]\n    adjust += jumps[index][1] - jumps[index][0] - 1\n  }\n\n  return gaps\n\n  function add(slice) {\n    var start = startPositions.pop()\n    jumps.unshift([start, start + slice.length - 1])\n    chunkedSplice(events, start, 2, slice)\n  }\n}\n\nmodule.exports = subtokenize\n", "'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar prefixSize = require('../util/prefix-size.js')\nvar subtokenize = require('../util/subtokenize.js')\nvar factorySpace = require('./factory-space.js')\n\n// No name because it must not be turned off.\nvar content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent,\n  interruptible: true,\n  lazy: true\n}\nvar continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n} // Content is transparent: it\u2019s parsed right now. That way, definitions are also\n// parsed right now: before text in paragraphs (specifically, media) are parsed.\n\nfunction resolveContent(events) {\n  subtokenize(events)\n  return events\n}\n\nfunction tokenizeContent(effects, ok) {\n  var previous\n  return start\n\n  function start(code) {\n    effects.enter('content')\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    })\n    return data(code)\n  }\n\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.check(\n        continuationConstruct,\n        contentContinue,\n        contentEnd\n      )(code)\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n\n  function contentEnd(code) {\n    effects.exit('chunkContent')\n    effects.exit('content')\n    return ok(code)\n  }\n\n  function contentContinue(code) {\n    effects.consume(code)\n    effects.exit('chunkContent')\n    previous = previous.next = effects.enter('chunkContent', {\n      contentType: 'content',\n      previous: previous\n    })\n    return data\n  }\n}\n\nfunction tokenizeContinuation(effects, ok, nok) {\n  var self = this\n  return startLookahead\n\n  function startLookahead(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, prefixed, 'linePrefix')\n  }\n\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    if (\n      self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ||\n      prefixSize(self.events, 'linePrefix') < 4\n    ) {\n      return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)\n    }\n\n    return ok(code)\n  }\n}\n\nmodule.exports = content\n", "'use strict'\n\nObject.defineProperty(exports, '__esModule', {value: true})\n\nvar content = require('../tokenize/content.js')\nvar factorySpace = require('../tokenize/factory-space.js')\nvar partialBlankLine = require('../tokenize/partial-blank-line.js')\n\nvar tokenize = initializeFlow\n\nfunction initializeFlow(effects) {\n  var self = this\n  var initial = effects.attempt(\n    // Try to parse a blank line.\n    partialBlankLine,\n    atBlankEnding, // Try to parse initial flow (essentially, only code).\n    effects.attempt(\n      this.parser.constructs.flowInitial,\n      afterConstruct,\n      factorySpace(\n        effects,\n        effects.attempt(\n          this.parser.constructs.flow,\n          afterConstruct,\n          effects.attempt(content, afterConstruct)\n        ),\n        'linePrefix'\n      )\n    )\n  )\n  return initial\n\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    self.currentConstruct = undefined\n    return initial\n  }\n\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    self.currentConstruct = undefined\n    return initial\n  }\n}\n\nexports.tokenize = tokenize\n", "'use strict'\n\nObject.defineProperty(exports, '__esModule', {value: true})\n\nvar assign = require('../constant/assign.js')\nvar shallow = require('../util/shallow.js')\n\nvar text = initializeFactory('text')\nvar string = initializeFactory('string')\nvar resolver = {\n  resolveAll: createResolver()\n}\n\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(\n      field === 'text' ? resolveAllLineSuffixes : undefined\n    )\n  }\n\n  function initializeText(effects) {\n    var self = this\n    var constructs = this.parser.constructs[field]\n    var text = effects.attempt(constructs, start, notText)\n    return start\n\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code)\n    }\n\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code)\n        return\n      }\n\n      effects.enter('data')\n      effects.consume(code)\n      return data\n    }\n\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data')\n        return text(code)\n      } // Data.\n\n      effects.consume(code)\n      return data\n    }\n\n    function atBreak(code) {\n      var list = constructs[code]\n      var index = -1\n\n      if (code === null) {\n        return true\n      }\n\n      if (list) {\n        while (++index < list.length) {\n          if (\n            !list[index].previous ||\n            list[index].previous.call(self, self.previous)\n          ) {\n            return true\n          }\n        }\n      }\n    }\n  }\n}\n\nfunction createResolver(extraResolver) {\n  return resolveAllText\n\n  function resolveAllText(events, context) {\n    var index = -1\n    var enter // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === 'data') {\n          enter = index\n          index++\n        }\n      } else if (!events[index] || events[index][1].type !== 'data') {\n        // Don\u2019t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end\n          events.splice(enter + 2, index - enter - 2)\n          index = enter + 2\n        }\n\n        enter = undefined\n      }\n    }\n\n    return extraResolver ? extraResolver(events, context) : events\n  }\n} // A rather ugly set of instructions which again looks at chunks in the input\n// stream.\n// The reason to do this here is that it is *much* faster to parse in reverse.\n// And that we can\u2019t hook into `null` to split the line suffix before an EOF.\n// To do: figure out if we can make this into a clean utility, or even in core.\n// As it will be useful for GFMs literal autolink extension (and maybe even\n// tables?)\n\nfunction resolveAllLineSuffixes(events, context) {\n  var eventIndex = -1\n  var chunks\n  var data\n  var chunk\n  var index\n  var bufferIndex\n  var size\n  var tabs\n  var token\n\n  while (++eventIndex <= events.length) {\n    if (\n      (eventIndex === events.length ||\n        events[eventIndex][1].type === 'lineEnding') &&\n      events[eventIndex - 1][1].type === 'data'\n    ) {\n      data = events[eventIndex - 1][1]\n      chunks = context.sliceStream(data)\n      index = chunks.length\n      bufferIndex = -1\n      size = 0\n      tabs = undefined\n\n      while (index--) {\n        chunk = chunks[index]\n\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length\n\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++\n            bufferIndex--\n          }\n\n          if (bufferIndex) break\n          bufferIndex = -1\n        } // Number\n        else if (chunk === -2) {\n          tabs = true\n          size++\n        } else if (chunk === -1);\n        else {\n          // Replacement character, exit.\n          index++\n          break\n        }\n      }\n\n      if (size) {\n        token = {\n          type:\n            eventIndex === events.length || tabs || size < 2\n              ? 'lineSuffix'\n              : 'hardBreakTrailing',\n          start: {\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size,\n            _index: data.start._index + index,\n            _bufferIndex: index\n              ? bufferIndex\n              : data.start._bufferIndex + bufferIndex\n          },\n          end: shallow(data.end)\n        }\n        data.end = shallow(token.start)\n\n        if (data.start.offset === data.end.offset) {\n          assign(data, token)\n        } else {\n          events.splice(\n            eventIndex,\n            0,\n            ['enter', token, context],\n            ['exit', token, context]\n          )\n          eventIndex += 2\n        }\n      }\n\n      eventIndex++\n    }\n  }\n\n  return events\n}\n\nexports.resolver = resolver\nexports.string = string\nexports.text = text\n", "'use strict'\n\nfunction miniflat(value) {\n  return value === null || value === undefined\n    ? []\n    : 'length' in value\n    ? value\n    : [value]\n}\n\nmodule.exports = miniflat\n", "'use strict'\n\nvar hasOwnProperty = require('../constant/has-own-property.js')\nvar chunkedSplice = require('./chunked-splice.js')\nvar miniflat = require('./miniflat.js')\n\nfunction combineExtensions(extensions) {\n  var all = {}\n  var index = -1\n\n  while (++index < extensions.length) {\n    extension(all, extensions[index])\n  }\n\n  return all\n}\n\nfunction extension(all, extension) {\n  var hook\n  var left\n  var right\n  var code\n\n  for (hook in extension) {\n    left = hasOwnProperty.call(all, hook) ? all[hook] : (all[hook] = {})\n    right = extension[hook]\n\n    for (code in right) {\n      left[code] = constructs(\n        miniflat(right[code]),\n        hasOwnProperty.call(left, code) ? left[code] : []\n      )\n    }\n  }\n}\n\nfunction constructs(list, existing) {\n  var index = -1\n  var before = []\n\n  while (++index < list.length) {\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  chunkedSplice(existing, 0, 0, before)\n  return existing\n}\n\nmodule.exports = combineExtensions\n", "'use strict'\n\nvar chunkedSplice = require('./chunked-splice.js')\n\nfunction chunkedPush(list, items) {\n  if (list.length) {\n    chunkedSplice(list, list.length, 0, items)\n    return list\n  }\n\n  return items\n}\n\nmodule.exports = chunkedPush\n", "'use strict'\n\nfunction resolveAll(constructs, events, context) {\n  var called = []\n  var index = -1\n  var resolve\n\n  while (++index < constructs.length) {\n    resolve = constructs[index].resolveAll\n\n    if (resolve && called.indexOf(resolve) < 0) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n\nmodule.exports = resolveAll\n", "'use strict'\n\nvar fromCharCode = require('../constant/from-char-code.js')\n\nfunction serializeChunks(chunks) {\n  var index = -1\n  var result = []\n  var chunk\n  var value\n  var atTab\n\n  while (++index < chunks.length) {\n    chunk = chunks[index]\n\n    if (typeof chunk === 'string') {\n      value = chunk\n    } else if (chunk === -5) {\n      value = '\\r'\n    } else if (chunk === -4) {\n      value = '\\n'\n    } else if (chunk === -3) {\n      value = '\\r' + '\\n'\n    } else if (chunk === -2) {\n      value = '\\t'\n    } else if (chunk === -1) {\n      if (atTab) continue\n      value = ' '\n    } else {\n      // Currently only replacement character.\n      value = fromCharCode(chunk)\n    }\n\n    atTab = chunk === -2\n    result.push(value)\n  }\n\n  return result.join('')\n}\n\nmodule.exports = serializeChunks\n", "'use strict'\n\nfunction sliceChunks(chunks, token) {\n  var startIndex = token.start._index\n  var startBufferIndex = token.start._bufferIndex\n  var endIndex = token.end._index\n  var endBufferIndex = token.end._bufferIndex\n  var view\n\n  if (startIndex === endIndex) {\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]\n  } else {\n    view = chunks.slice(startIndex, endIndex)\n\n    if (startBufferIndex > -1) {\n      view[0] = view[0].slice(startBufferIndex)\n    }\n\n    if (endBufferIndex > 0) {\n      view.push(chunks[endIndex].slice(0, endBufferIndex))\n    }\n  }\n\n  return view\n}\n\nmodule.exports = sliceChunks\n", "'use strict'\n\nvar assign = require('../constant/assign.js')\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar chunkedPush = require('./chunked-push.js')\nvar chunkedSplice = require('./chunked-splice.js')\nvar miniflat = require('./miniflat.js')\nvar resolveAll = require('./resolve-all.js')\nvar serializeChunks = require('./serialize-chunks.js')\nvar shallow = require('./shallow.js')\nvar sliceChunks = require('./slice-chunks.js')\n\n// Create a tokenizer.\n// Tokenizers deal with one type of data (e.g., containers, flow, text).\n// The parser is the object dealing with it all.\n// `initialize` works like other constructs, except that only its `tokenize`\n// function is used, in which case it doesn\u2019t receive an `ok` or `nok`.\n// `from` can be given to set the point before the first character, although\n// when further lines are indented, they must be set with `defineSkip`.\nfunction createTokenizer(parser, initialize, from) {\n  var point = from\n    ? shallow(from)\n    : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }\n  var columnStart = {}\n  var resolveAllConstructs = []\n  var chunks = []\n  var stack = []\n\n  var effects = {\n    consume: consume,\n    enter: enter,\n    exit: exit,\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    }),\n    lazy: constructFactory(onsuccessfulcheck, {\n      lazy: true\n    })\n  } // State and tools for resolving and serializing.\n\n  var context = {\n    previous: null,\n    events: [],\n    parser: parser,\n    sliceStream: sliceStream,\n    sliceSerialize: sliceSerialize,\n    now: now,\n    defineSkip: skip,\n    write: write\n  } // The state function.\n\n  var state = initialize.tokenize.call(context, effects) // Track which character we expect to be consumed, to catch bugs.\n\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize)\n  } // Store where we are in the input stream.\n\n  point._index = 0\n  point._bufferIndex = -1\n  return context\n\n  function write(slice) {\n    chunks = chunkedPush(chunks, slice)\n    main() // Exit if we\u2019re not done, resolve might change stuff.\n\n    if (chunks[chunks.length - 1] !== null) {\n      return []\n    }\n\n    addResult(initialize, 0) // Otherwise, resolve, and exit.\n\n    context.events = resolveAll(resolveAllConstructs, context.events, context)\n    return context.events\n  } //\n  // Tools.\n  //\n\n  function sliceSerialize(token) {\n    return serializeChunks(sliceStream(token))\n  }\n\n  function sliceStream(token) {\n    return sliceChunks(chunks, token)\n  }\n\n  function now() {\n    return shallow(point)\n  }\n\n  function skip(value) {\n    columnStart[value.line] = value.column\n    accountForPotentialSkip()\n  } //\n  // State management.\n  //\n  // Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n  // `consume`).\n  // Here is where we walk through the chunks, which either include strings of\n  // several characters, or numerical character codes.\n  // The reason to do this in a loop instead of a call is so the stack can\n  // drain.\n\n  function main() {\n    var chunkIndex\n    var chunk\n\n    while (point._index < chunks.length) {\n      chunk = chunks[point._index] // If we\u2019re in a buffer chunk, loop through it.\n\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index\n\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0\n        }\n\n        while (\n          point._index === chunkIndex &&\n          point._bufferIndex < chunk.length\n        ) {\n          go(chunk.charCodeAt(point._bufferIndex))\n        }\n      } else {\n        go(chunk)\n      }\n    }\n  } // Deal with one code.\n\n  function go(code) {\n    state = state(code)\n  } // Move a character forward.\n\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++\n      point.column = 1\n      point.offset += code === -3 ? 2 : 1\n      accountForPotentialSkip()\n    } else if (code !== -1) {\n      point.column++\n      point.offset++\n    } // Not in a string chunk.\n\n    if (point._bufferIndex < 0) {\n      point._index++\n    } else {\n      point._bufferIndex++ // At end of string chunk.\n\n      if (point._bufferIndex === chunks[point._index].length) {\n        point._bufferIndex = -1\n        point._index++\n      }\n    } // Expose the previous character.\n\n    context.previous = code // Mark as consumed.\n  } // Start a token.\n\n  function enter(type, fields) {\n    var token = fields || {}\n    token.type = type\n    token.start = now()\n    context.events.push(['enter', token, context])\n    stack.push(token)\n    return token\n  } // Stop a token.\n\n  function exit(type) {\n    var token = stack.pop()\n    token.end = now()\n    context.events.push(['exit', token, context])\n    return token\n  } // Use results.\n\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from)\n  } // Discard results.\n\n  function onsuccessfulcheck(construct, info) {\n    info.restore()\n  } // Factory to attempt/check/interrupt.\n\n  function constructFactory(onreturn, fields) {\n    return hook // Handle either an object mapping codes to constructs, a list of\n    // constructs, or a single construct.\n\n    function hook(constructs, returnState, bogusState) {\n      var listOfConstructs\n      var constructIndex\n      var currentConstruct\n      var info\n      return constructs.tokenize || 'length' in constructs\n        ? handleListOfConstructs(miniflat(constructs))\n        : handleMapOfConstructs\n\n      function handleMapOfConstructs(code) {\n        if (code in constructs || null in constructs) {\n          return handleListOfConstructs(\n            constructs.null\n              ? /* c8 ignore next */\n                miniflat(constructs[code]).concat(miniflat(constructs.null))\n              : constructs[code]\n          )(code)\n        }\n\n        return bogusState(code)\n      }\n\n      function handleListOfConstructs(list) {\n        listOfConstructs = list\n        constructIndex = 0\n        return handleConstruct(list[constructIndex])\n      }\n\n      function handleConstruct(construct) {\n        return start\n\n        function start(code) {\n          // To do: not nede to store if there is no bogus state, probably?\n          // Currently doesn\u2019t work because `inspect` in document does a check\n          // w/o a bogus, which doesn\u2019t make sense. But it does seem to help perf\n          // by not storing.\n          info = store()\n          currentConstruct = construct\n\n          if (!construct.partial) {\n            context.currentConstruct = construct\n          }\n\n          if (\n            construct.name &&\n            context.parser.constructs.disable.null.indexOf(construct.name) > -1\n          ) {\n            return nok()\n          }\n\n          return construct.tokenize.call(\n            fields ? assign({}, context, fields) : context,\n            effects,\n            ok,\n            nok\n          )(code)\n        }\n      }\n\n      function ok(code) {\n        onreturn(currentConstruct, info)\n        return returnState\n      }\n\n      function nok(code) {\n        info.restore()\n\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex])\n        }\n\n        return bogusState\n      }\n    }\n  }\n\n  function addResult(construct, from) {\n    if (construct.resolveAll && resolveAllConstructs.indexOf(construct) < 0) {\n      resolveAllConstructs.push(construct)\n    }\n\n    if (construct.resolve) {\n      chunkedSplice(\n        context.events,\n        from,\n        context.events.length - from,\n        construct.resolve(context.events.slice(from), context)\n      )\n    }\n\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context)\n    }\n  }\n\n  function store() {\n    var startPoint = now()\n    var startPrevious = context.previous\n    var startCurrentConstruct = context.currentConstruct\n    var startEventsIndex = context.events.length\n    var startStack = Array.from(stack)\n    return {\n      restore: restore,\n      from: startEventsIndex\n    }\n\n    function restore() {\n      point = startPoint\n      context.previous = startPrevious\n      context.currentConstruct = startCurrentConstruct\n      context.events.length = startEventsIndex\n      stack = startStack\n      accountForPotentialSkip()\n    }\n  }\n\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line]\n      point.offset += columnStart[point.line] - 1\n    }\n  }\n}\n\nmodule.exports = createTokenizer\n", "'use strict'\n\nfunction markdownLineEndingOrSpace(code) {\n  return code < 0 || code === 32\n}\n\nmodule.exports = markdownLineEndingOrSpace\n", "'use strict'\n\n// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\nvar unicodePunctuation = /[!-\\/:-@\\[-`\\{-~\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n\nmodule.exports = unicodePunctuation\n", "'use strict'\n\nvar fromCharCode = require('../constant/from-char-code.js')\n\nfunction regexCheck(regex) {\n  return check\n\n  function check(code) {\n    return regex.test(fromCharCode(code))\n  }\n}\n\nmodule.exports = regexCheck\n", "'use strict'\n\nvar unicodePunctuationRegex = require('../constant/unicode-punctuation-regex.js')\nvar regexCheck = require('../util/regex-check.js')\n\n// In fact adds to the bundle size.\n\nvar unicodePunctuation = regexCheck(unicodePunctuationRegex)\n\nmodule.exports = unicodePunctuation\n", "'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar unicodeWhitespace = regexCheck(/\\s/)\n\nmodule.exports = unicodeWhitespace\n", "'use strict'\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar unicodePunctuation = require('../character/unicode-punctuation.js')\nvar unicodeWhitespace = require('../character/unicode-whitespace.js')\n\n// Classify whether a character is unicode whitespace, unicode punctuation, or\n// anything else.\n// Used for attention (emphasis, strong), whose sequences can open or close\n// based on the class of surrounding characters.\nfunction classifyCharacter(code) {\n  if (\n    code === null ||\n    markdownLineEndingOrSpace(code) ||\n    unicodeWhitespace(code)\n  ) {\n    return 1\n  }\n\n  if (unicodePunctuation(code)) {\n    return 2\n  }\n}\n\nmodule.exports = classifyCharacter\n", "'use strict'\n\n// chunks (replacement characters, tabs, or line endings).\n\nfunction movePoint(point, offset) {\n  point.column += offset\n  point.offset += offset\n  point._bufferIndex += offset\n  return point\n}\n\nmodule.exports = movePoint\n", "'use strict'\n\nvar chunkedPush = require('../util/chunked-push.js')\nvar chunkedSplice = require('../util/chunked-splice.js')\nvar classifyCharacter = require('../util/classify-character.js')\nvar movePoint = require('../util/move-point.js')\nvar resolveAll = require('../util/resolve-all.js')\nvar shallow = require('../util/shallow.js')\n\nvar attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n}\n\nfunction resolveAllAttention(events, context) {\n  var index = -1\n  var open\n  var group\n  var text\n  var openingSequence\n  var closingSequence\n  var use\n  var nextEvents\n  var offset // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it\u2019s\n  // a bottleneck for malicious stuff.\n\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (\n      events[index][0] === 'enter' &&\n      events[index][1].type === 'attentionSequence' &&\n      events[index][1]._close\n    ) {\n      open = index // Now walk back to find an opener.\n\n      while (open--) {\n        // Find a token that can open the closer.\n        if (\n          events[open][0] === 'exit' &&\n          events[open][1].type === 'attentionSequence' &&\n          events[open][1]._open && // If the markers are the same:\n          context.sliceSerialize(events[open][1]).charCodeAt(0) ===\n            context.sliceSerialize(events[index][1]).charCodeAt(0)\n        ) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don\u2019t match.\n          if (\n            (events[open][1]._close || events[index][1]._open) &&\n            (events[index][1].end.offset - events[index][1].start.offset) % 3 &&\n            !(\n              (events[open][1].end.offset -\n                events[open][1].start.offset +\n                events[index][1].end.offset -\n                events[index][1].start.offset) %\n              3\n            )\n          ) {\n            continue\n          } // Number of markers to use from the sequence.\n\n          use =\n            events[open][1].end.offset - events[open][1].start.offset > 1 &&\n            events[index][1].end.offset - events[index][1].start.offset > 1\n              ? 2\n              : 1\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: movePoint(shallow(events[open][1].end), -use),\n            end: shallow(events[open][1].end)\n          }\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: shallow(events[index][1].start),\n            end: movePoint(shallow(events[index][1].start), use)\n          }\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: shallow(events[open][1].end),\n            end: shallow(events[index][1].start)\n          }\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: shallow(openingSequence.start),\n            end: shallow(closingSequence.end)\n          }\n          events[open][1].end = shallow(openingSequence.start)\n          events[index][1].start = shallow(closingSequence.end)\n          nextEvents = [] // If there are more markers in the opening, add them before.\n\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = chunkedPush(nextEvents, [\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context]\n            ])\n          } // Opening.\n\n          nextEvents = chunkedPush(nextEvents, [\n            ['enter', group, context],\n            ['enter', openingSequence, context],\n            ['exit', openingSequence, context],\n            ['enter', text, context]\n          ]) // Between.\n\n          nextEvents = chunkedPush(\n            nextEvents,\n            resolveAll(\n              context.parser.constructs.insideSpan.null,\n              events.slice(open + 1, index),\n              context\n            )\n          ) // Closing.\n\n          nextEvents = chunkedPush(nextEvents, [\n            ['exit', text, context],\n            ['enter', closingSequence, context],\n            ['exit', closingSequence, context],\n            ['exit', group, context]\n          ]) // If there are more markers in the closing, add them after.\n\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2\n            nextEvents = chunkedPush(nextEvents, [\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context]\n            ])\n          } else {\n            offset = 0\n          }\n\n          chunkedSplice(events, open - 1, index - open + 3, nextEvents)\n          index = open + nextEvents.length - offset - 2\n          break\n        }\n      }\n    }\n  } // Remove remaining sequences.\n\n  index = -1\n\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data'\n    }\n  }\n\n  return events\n}\n\nfunction tokenizeAttention(effects, ok) {\n  var before = classifyCharacter(this.previous)\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter('attentionSequence')\n    marker = code\n    return sequence(code)\n  }\n\n  function sequence(code) {\n    var token\n    var after\n    var open\n    var close\n\n    if (code === marker) {\n      effects.consume(code)\n      return sequence\n    }\n\n    token = effects.exit('attentionSequence')\n    after = classifyCharacter(code)\n    open = !after || (after === 2 && before)\n    close = !before || (before === 2 && after)\n    token._open = marker === 42 ? open : open && (before || !close)\n    token._close = marker === 42 ? close : close && (after || !open)\n    return ok(code)\n  }\n}\n\nmodule.exports = attention\n", "'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiAlpha = regexCheck(/[A-Za-z]/)\n\nmodule.exports = asciiAlpha\n", "'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\n\nmodule.exports = asciiAlphanumeric\n", "'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\n\nmodule.exports = asciiAtext\n", "'use strict'\n\n// Note: EOF is seen as ASCII control here, because `null < 32 == true`.\nfunction asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code < 32 || code === 127\n  )\n}\n\nmodule.exports = asciiControl\n", "'use strict'\n\nvar asciiAlpha = require('../character/ascii-alpha.js')\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js')\nvar asciiAtext = require('../character/ascii-atext.js')\nvar asciiControl = require('../character/ascii-control.js')\n\nvar autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n}\n\nfunction tokenizeAutolink(effects, ok, nok) {\n  var size = 1\n  return start\n\n  function start(code) {\n    effects.enter('autolink')\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.enter('autolinkProtocol')\n    return open\n  }\n\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return schemeOrEmailAtext\n    }\n\n    return asciiAtext(code) ? emailAtext(code) : nok(code)\n  }\n\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)\n      ? schemeInsideOrEmailAtext(code)\n      : emailAtext(code)\n  }\n\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code)\n      return urlInside\n    }\n\n    if (\n      (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&\n      size++ < 32\n    ) {\n      effects.consume(code)\n      return schemeInsideOrEmailAtext\n    }\n\n    return emailAtext(code)\n  }\n\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol')\n      return end(code)\n    }\n\n    if (code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return urlInside\n  }\n\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n\n    if (asciiAtext(code)) {\n      effects.consume(code)\n      return emailAtext\n    }\n\n    return nok(code)\n  }\n\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)\n  }\n\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail'\n      return end(code)\n    }\n\n    return emailValue(code)\n  }\n\n  function emailValue(code) {\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      effects.consume(code)\n      return code === 45 ? emailValue : emailLabel\n    }\n\n    return nok(code)\n  }\n\n  function end(code) {\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.exit('autolink')\n    return ok\n  }\n}\n\nmodule.exports = autolink\n", "'use strict'\n\nvar markdownSpace = require('../character/markdown-space.js')\nvar factorySpace = require('./factory-space.js')\n\nvar blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit: exit\n}\n\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  var self = this\n  return start\n\n  function start(code) {\n    if (code === 62) {\n      if (!self.containerState.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        })\n        self.containerState.open = true\n      }\n\n      effects.enter('blockQuotePrefix')\n      effects.enter('blockQuoteMarker')\n      effects.consume(code)\n      effects.exit('blockQuoteMarker')\n      return after\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter('blockQuotePrefixWhitespace')\n      effects.consume(code)\n      effects.exit('blockQuotePrefixWhitespace')\n      effects.exit('blockQuotePrefix')\n      return ok\n    }\n\n    effects.exit('blockQuotePrefix')\n    return ok(code)\n  }\n}\n\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(blockQuote, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.indexOf('codeIndented') > -1\n      ? undefined\n      : 4\n  )\n}\n\nfunction exit(effects) {\n  effects.exit('blockQuote')\n}\n\nmodule.exports = blockQuote\n", "'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\n\nmodule.exports = asciiPunctuation\n", "'use strict'\n\nvar asciiPunctuation = require('../character/ascii-punctuation.js')\n\nvar characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n}\n\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.enter('characterEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    effects.exit('escapeMarker')\n    return open\n  }\n\n  function open(code) {\n    if (asciiPunctuation(code)) {\n      effects.enter('characterEscapeValue')\n      effects.consume(code)\n      effects.exit('characterEscapeValue')\n      effects.exit('characterEscape')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = characterEscape\n", "'use strict'\n\n/* eslint-env browser */\n\nvar el\n\nvar semicolon = 59 //  ';'\n\nmodule.exports = decodeEntity\n\nfunction decodeEntity(characters) {\n  var entity = '&' + characters + ';'\n  var char\n\n  el = el || document.createElement('i')\n  el.innerHTML = entity\n  char = el.textContent\n\n  // Some entities do not require the closing semicolon (`&not` - for instance),\n  // which leads to situations where parsing the assumed entity of &notit; will\n  // result in the string `\u00ACit;`.  When we encounter a trailing semicolon after\n  // parsing and the entity to decode was not a semicolon (`&semi;`), we can\n  // assume that the matching was incomplete\n  if (char.charCodeAt(char.length - 1) === semicolon && characters !== 'semi') {\n    return false\n  }\n\n  // If the decoded string is equal to the input, the entity was not valid\n  return char === entity ? false : char\n}\n", "'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiDigit = regexCheck(/\\d/)\n\nmodule.exports = asciiDigit\n", "'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\n\nmodule.exports = asciiHexDigit\n", "'use strict'\n\nvar decodeEntity = require('parse-entities/decode-entity.js')\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js')\nvar asciiDigit = require('../character/ascii-digit.js')\nvar asciiHexDigit = require('../character/ascii-hex-digit.js')\n\nfunction _interopDefaultLegacy(e) {\n  return e && typeof e === 'object' && 'default' in e ? e : {default: e}\n}\n\nvar decodeEntity__default = /*#__PURE__*/ _interopDefaultLegacy(decodeEntity)\n\nvar characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n}\n\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  var self = this\n  var size = 0\n  var max\n  var test\n  return start\n\n  function start(code) {\n    effects.enter('characterReference')\n    effects.enter('characterReferenceMarker')\n    effects.consume(code)\n    effects.exit('characterReferenceMarker')\n    return open\n  }\n\n  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerNumeric')\n      return numeric\n    }\n\n    effects.enter('characterReferenceValue')\n    max = 31\n    test = asciiAlphanumeric\n    return value(code)\n  }\n\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter('characterReferenceMarkerHexadecimal')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerHexadecimal')\n      effects.enter('characterReferenceValue')\n      max = 6\n      test = asciiHexDigit\n      return value\n    }\n\n    effects.enter('characterReferenceValue')\n    max = 7\n    test = asciiDigit\n    return value(code)\n  }\n\n  function value(code) {\n    var token\n\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue')\n\n      if (\n        test === asciiAlphanumeric &&\n        !decodeEntity__default['default'](self.sliceSerialize(token))\n      ) {\n        return nok(code)\n      }\n\n      effects.enter('characterReferenceMarker')\n      effects.consume(code)\n      effects.exit('characterReferenceMarker')\n      effects.exit('characterReference')\n      return ok\n    }\n\n    if (test(code) && size++ < max) {\n      effects.consume(code)\n      return value\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = characterReference\n", "'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar prefixSize = require('../util/prefix-size.js')\nvar factorySpace = require('./factory-space.js')\n\nvar codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n}\n\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  var self = this\n  var closingFenceConstruct = {\n    tokenize: tokenizeClosingFence,\n    partial: true\n  }\n  var initialPrefix = prefixSize(this.events, 'linePrefix')\n  var sizeOpen = 0\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter('codeFenced')\n    effects.enter('codeFencedFence')\n    effects.enter('codeFencedFenceSequence')\n    marker = code\n    return sequenceOpen(code)\n  }\n\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code)\n      sizeOpen++\n      return sequenceOpen\n    }\n\n    effects.exit('codeFencedFenceSequence')\n    return sizeOpen < 3\n      ? nok(code)\n      : factorySpace(effects, infoOpen, 'whitespace')(code)\n  }\n\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceInfo')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return info(code)\n  }\n\n  function info(code) {\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceInfo')\n      return factorySpace(effects, infoAfter, 'whitespace')(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return info\n  }\n\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceMeta')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return meta(code)\n  }\n\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceMeta')\n      return openAfter(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return meta\n  }\n\n  function openAfter(code) {\n    effects.exit('codeFencedFence')\n    return self.interrupt ? ok(code) : content(code)\n  }\n\n  function content(code) {\n    if (code === null) {\n      return after(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return effects.attempt(\n        closingFenceConstruct,\n        after,\n        initialPrefix\n          ? factorySpace(effects, content, 'linePrefix', initialPrefix + 1)\n          : content\n      )\n    }\n\n    effects.enter('codeFlowValue')\n    return contentContinue(code)\n  }\n\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return content(code)\n    }\n\n    effects.consume(code)\n    return contentContinue\n  }\n\n  function after(code) {\n    effects.exit('codeFenced')\n    return ok(code)\n  }\n\n  function tokenizeClosingFence(effects, ok, nok) {\n    var size = 0\n    return factorySpace(\n      effects,\n      closingSequenceStart,\n      'linePrefix',\n      this.parser.constructs.disable.null.indexOf('codeIndented') > -1\n        ? undefined\n        : 4\n    )\n\n    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence')\n      effects.enter('codeFencedFenceSequence')\n      return closingSequence(code)\n    }\n\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code)\n        size++\n        return closingSequence\n      }\n\n      if (size < sizeOpen) return nok(code)\n      effects.exit('codeFencedFenceSequence')\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code)\n    }\n\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence')\n        return ok(code)\n      }\n\n      return nok(code)\n    }\n  }\n}\n\nmodule.exports = codeFenced\n", "'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar chunkedSplice = require('../util/chunked-splice.js')\nvar prefixSize = require('../util/prefix-size.js')\nvar factorySpace = require('./factory-space.js')\n\nvar codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented,\n  resolve: resolveCodeIndented\n}\nvar indentedContentConstruct = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\n}\n\nfunction resolveCodeIndented(events, context) {\n  var code = {\n    type: 'codeIndented',\n    start: events[0][1].start,\n    end: events[events.length - 1][1].end\n  }\n  chunkedSplice(events, 0, 0, [['enter', code, context]])\n  chunkedSplice(events, events.length, 0, [['exit', code, context]])\n  return events\n}\n\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  return effects.attempt(indentedContentConstruct, afterPrefix, nok)\n\n  function afterPrefix(code) {\n    if (code === null) {\n      return ok(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContentConstruct, afterPrefix, ok)(code)\n    }\n\n    effects.enter('codeFlowValue')\n    return content(code)\n  }\n\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return afterPrefix(code)\n    }\n\n    effects.consume(code)\n    return content\n  }\n}\n\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  var self = this\n  return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)\n\n  function afterPrefix(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)\n    }\n\n    return prefixSize(self.events, 'linePrefix') < 4 ? nok(code) : ok(code)\n  }\n}\n\nmodule.exports = codeIndented\n", "'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\n\nvar codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous: previous\n}\n\nfunction resolveCodeText(events) {\n  var tailExitIndex = events.length - 4\n  var headEnterIndex = 3\n  var index\n  var enter // If we start and end with an EOL or a space.\n\n  if (\n    (events[headEnterIndex][1].type === 'lineEnding' ||\n      events[headEnterIndex][1].type === 'space') &&\n    (events[tailExitIndex][1].type === 'lineEnding' ||\n      events[tailExitIndex][1].type === 'space')\n  ) {\n    index = headEnterIndex // And we have data.\n\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === 'codeTextData') {\n        // Then we have padding.\n        events[tailExitIndex][1].type = events[headEnterIndex][1].type =\n          'codeTextPadding'\n        headEnterIndex += 2\n        tailExitIndex -= 2\n        break\n      }\n    }\n  } // Merge adjacent spaces and data.\n\n  index = headEnterIndex - 1\n  tailExitIndex++\n\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index\n      }\n    } else if (\n      index === tailExitIndex ||\n      events[index][1].type === 'lineEnding'\n    ) {\n      events[enter][1].type = 'codeTextData'\n\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end\n        events.splice(enter + 2, index - enter - 2)\n        tailExitIndex -= index - enter - 2\n        index = enter + 2\n      }\n\n      enter = undefined\n    }\n  }\n\n  return events\n}\n\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return (\n    code !== 96 ||\n    this.events[this.events.length - 1][1].type === 'characterEscape'\n  )\n}\n\nfunction tokenizeCodeText(effects, ok, nok) {\n  var sizeOpen = 0\n  var size\n  var token\n  return start\n\n  function start(code) {\n    effects.enter('codeText')\n    effects.enter('codeTextSequence')\n    return openingSequence(code)\n  }\n\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code)\n      sizeOpen++\n      return openingSequence\n    }\n\n    effects.exit('codeTextSequence')\n    return gap(code)\n  }\n\n  function gap(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code)\n    } // Closing fence?\n    // Could also be data.\n\n    if (code === 96) {\n      token = effects.enter('codeTextSequence')\n      size = 0\n      return closingSequence(code)\n    } // Tabs don\u2019t work, and virtual spaces don\u2019t make sense.\n\n    if (code === 32) {\n      effects.enter('space')\n      effects.consume(code)\n      effects.exit('space')\n      return gap\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return gap\n    } // Data.\n\n    effects.enter('codeTextData')\n    return data(code)\n  } // In code.\n\n  function data(code) {\n    if (\n      code === null ||\n      code === 32 ||\n      code === 96 ||\n      markdownLineEnding(code)\n    ) {\n      effects.exit('codeTextData')\n      return gap(code)\n    }\n\n    effects.consume(code)\n    return data\n  } // Closing fence.\n\n  function closingSequence(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code)\n      size++\n      return closingSequence\n    } // Done!\n\n    if (size === sizeOpen) {\n      effects.exit('codeTextSequence')\n      effects.exit('codeText')\n      return ok(code)\n    } // More or less accents: mark as data.\n\n    token.type = 'codeTextData'\n    return data(code)\n  }\n}\n\nmodule.exports = codeText\n", "'use strict'\n\nvar asciiControl = require('../character/ascii-control.js')\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\n\n// eslint-disable-next-line max-params\nfunction destinationFactory(\n  effects,\n  ok,\n  nok,\n  type,\n  literalType,\n  literalMarkerType,\n  rawType,\n  stringType,\n  max\n) {\n  var limit = max || Infinity\n  var balance = 0\n  return start\n\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type)\n      effects.enter(literalType)\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      return destinationEnclosedBefore\n    }\n\n    if (asciiControl(code) || code === 41) {\n      return nok(code)\n    }\n\n    effects.enter(type)\n    effects.enter(rawType)\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationRaw(code)\n  }\n\n  function destinationEnclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      effects.exit(literalType)\n      effects.exit(type)\n      return ok\n    }\n\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationEnclosed(code)\n  }\n\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      return destinationEnclosedBefore(code)\n    }\n\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed\n  }\n\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code)\n      return destinationEnclosed\n    }\n\n    return destinationEnclosed(code)\n  }\n\n  function destinationRaw(code) {\n    if (code === 40) {\n      if (++balance > limit) return nok(code)\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === 41) {\n      if (!balance--) {\n        effects.exit('chunkString')\n        effects.exit(stringType)\n        effects.exit(rawType)\n        effects.exit(type)\n        return ok(code)\n      }\n\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      if (balance) return nok(code)\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      effects.exit(rawType)\n      effects.exit(type)\n      return ok(code)\n    }\n\n    if (asciiControl(code)) return nok(code)\n    effects.consume(code)\n    return code === 92 ? destinationRawEscape : destinationRaw\n  }\n\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    return destinationRaw(code)\n  }\n}\n\nmodule.exports = destinationFactory\n", "'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownSpace = require('../character/markdown-space.js')\n\n// eslint-disable-next-line max-params\nfunction labelFactory(effects, ok, nok, type, markerType, stringType) {\n  var self = this\n  var size = 0\n  var data\n  return start\n\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    effects.enter(stringType)\n    return atBreak\n  }\n\n  function atBreak(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      (code === 93 && !data) ||\n      /* c8 ignore next */\n      (code === 94 &&\n        /* c8 ignore next */\n        !size &&\n        /* c8 ignore next */\n        '_hiddenFootnoteSupport' in self.parser.constructs) ||\n      size > 999\n    ) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.exit(stringType)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return atBreak\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return label(code)\n  }\n\n  function label(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      code === 93 ||\n      markdownLineEnding(code) ||\n      size++ > 999\n    ) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n\n    effects.consume(code)\n    data = data || !markdownSpace(code)\n    return code === 92 ? labelEscape : label\n  }\n\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return label\n    }\n\n    return label(code)\n  }\n}\n\nmodule.exports = labelFactory\n", "'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownSpace = require('../character/markdown-space.js')\nvar factorySpace = require('./factory-space.js')\n\nfunction whitespaceFactory(effects, ok) {\n  var seen\n  return start\n\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      seen = true\n      return start\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        start,\n        seen ? 'linePrefix' : 'lineSuffix'\n      )(code)\n    }\n\n    return ok(code)\n  }\n}\n\nmodule.exports = whitespaceFactory\n", "'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar factorySpace = require('./factory-space.js')\n\nfunction titleFactory(effects, ok, nok, type, markerType, stringType) {\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    marker = code === 40 ? 41 : code\n    return atFirstTitleBreak\n  }\n\n  function atFirstTitleBreak(code) {\n    if (code === marker) {\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    effects.enter(stringType)\n    return atTitleBreak(code)\n  }\n\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType)\n      return atFirstTitleBreak(marker)\n    }\n\n    if (code === null) {\n      return nok(code)\n    } // Note: blank lines can\u2019t exist in content.\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, atTitleBreak, 'linePrefix')\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return title(code)\n  }\n\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      return atTitleBreak(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? titleEscape : title\n  }\n\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code)\n      return title\n    }\n\n    return title(code)\n  }\n}\n\nmodule.exports = titleFactory\n", "'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar normalizeIdentifier = require('../util/normalize-identifier.js')\nvar factoryDestination = require('./factory-destination.js')\nvar factoryLabel = require('./factory-label.js')\nvar factorySpace = require('./factory-space.js')\nvar factoryWhitespace = require('./factory-whitespace.js')\nvar factoryTitle = require('./factory-title.js')\n\nvar definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n}\nvar titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n}\n\nfunction tokenizeDefinition(effects, ok, nok) {\n  var self = this\n  var identifier\n  return start\n\n  function start(code) {\n    effects.enter('definition')\n    return factoryLabel.call(\n      self,\n      effects,\n      labelAfter,\n      nok,\n      'definitionLabel',\n      'definitionLabelMarker',\n      'definitionLabelString'\n    )(code)\n  }\n\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(\n      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n    )\n\n    if (code === 58) {\n      effects.enter('definitionMarker')\n      effects.consume(code)\n      effects.exit('definitionMarker') // Note: blank lines can\u2019t exist in content.\n\n      return factoryWhitespace(\n        effects,\n        factoryDestination(\n          effects,\n          effects.attempt(\n            titleConstruct,\n            factorySpace(effects, after, 'whitespace'),\n            factorySpace(effects, after, 'whitespace')\n          ),\n          nok,\n          'definitionDestination',\n          'definitionDestinationLiteral',\n          'definitionDestinationLiteralMarker',\n          'definitionDestinationRaw',\n          'definitionDestinationString'\n        )\n      )\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition')\n\n      if (self.parser.defined.indexOf(identifier) < 0) {\n        self.parser.defined.push(identifier)\n      }\n\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n\nfunction tokenizeTitle(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, before)(code)\n      : nok(code)\n  }\n\n  function before(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factorySpace(effects, after, 'whitespace'),\n        nok,\n        'definitionTitle',\n        'definitionTitleMarker',\n        'definitionTitleString'\n      )(code)\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n\nmodule.exports = definition\n", "'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\n\nvar hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n}\n\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.enter('hardBreakEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    return open\n  }\n\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker')\n      effects.exit('hardBreakEscape')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = hardBreakEscape\n", "'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar markdownSpace = require('../character/markdown-space.js')\nvar chunkedSplice = require('../util/chunked-splice.js')\nvar factorySpace = require('./factory-space.js')\n\nvar headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n}\n\nfunction resolveHeadingAtx(events, context) {\n  var contentEnd = events.length - 2\n  var contentStart = 3\n  var content\n  var text // Prefix whitespace, part of the opening.\n\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2\n  } // Suffix whitespace, part of the closing.\n\n  if (\n    contentEnd - 2 > contentStart &&\n    events[contentEnd][1].type === 'whitespace'\n  ) {\n    contentEnd -= 2\n  }\n\n  if (\n    events[contentEnd][1].type === 'atxHeadingSequence' &&\n    (contentStart === contentEnd - 1 ||\n      (contentEnd - 4 > contentStart &&\n        events[contentEnd - 2][1].type === 'whitespace'))\n  ) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4\n  }\n\n  if (contentEnd > contentStart) {\n    content = {\n      type: 'atxHeadingText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    }\n    text = {\n      type: 'chunkText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      contentType: 'text'\n    }\n    chunkedSplice(events, contentStart, contentEnd - contentStart + 1, [\n      ['enter', content, context],\n      ['enter', text, context],\n      ['exit', text, context],\n      ['exit', content, context]\n    ])\n  }\n\n  return events\n}\n\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  var self = this\n  var size = 0\n  return start\n\n  function start(code) {\n    effects.enter('atxHeading')\n    effects.enter('atxHeadingSequence')\n    return fenceOpenInside(code)\n  }\n\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code)\n      return fenceOpenInside\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence')\n      return self.interrupt ? ok(code) : headingBreak(code)\n    }\n\n    return nok(code)\n  }\n\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence')\n      return sequence(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading')\n      return ok(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code)\n    }\n\n    effects.enter('atxHeadingText')\n    return data(code)\n  }\n\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code)\n      return sequence\n    }\n\n    effects.exit('atxHeadingSequence')\n    return headingBreak(code)\n  }\n\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText')\n      return headingBreak(code)\n    }\n\n    effects.consume(code)\n    return data\n  }\n}\n\nmodule.exports = headingAtx\n", "'use strict'\n\n// This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\nvar basics = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'section',\n  'source',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\nmodule.exports = basics\n", "'use strict'\n\n// This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\nvar raws = ['pre', 'script', 'style', 'textarea']\n\nmodule.exports = raws\n", "'use strict'\n\nvar asciiAlpha = require('../character/ascii-alpha.js')\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js')\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar markdownSpace = require('../character/markdown-space.js')\nvar fromCharCode = require('../constant/from-char-code.js')\nvar htmlBlockNames = require('../constant/html-block-names.js')\nvar htmlRawNames = require('../constant/html-raw-names.js')\nvar partialBlankLine = require('./partial-blank-line.js')\n\nvar htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n}\nvar nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n}\n\nfunction resolveToHtmlFlow(events) {\n  var index = events.length\n\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break\n    }\n  }\n\n  if (index > 1 && events[index - 2][1].type === 'linePrefix') {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start // Add the prefix start to the HTML line token.\n\n    events[index + 1][1].start = events[index - 2][1].start // Remove the line prefix.\n\n    events.splice(index - 2, 2)\n  }\n\n  return events\n}\n\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  var self = this\n  var kind\n  var startTag\n  var buffer\n  var index\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter('htmlFlow')\n    effects.enter('htmlFlowData')\n    effects.consume(code)\n    return open\n  }\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationStart\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      kind = 3 // While we\u2019re in an instruction instead of a declaration, we\u2019re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = fromCharCode(code)\n      startTag = true\n      return tagName\n    }\n\n    return nok(code)\n  }\n\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code)\n      kind = 2\n      return commentOpenInside\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      kind = 5\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpenInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      kind = 4\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n\n  function cdataOpenInside(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length\n        ? self.interrupt\n          ? ok\n          : continuation\n        : cdataOpenInside\n    }\n\n    return nok(code)\n  }\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n\n  function tagName(code) {\n    if (\n      code === null ||\n      code === 47 ||\n      code === 62 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      if (\n        code !== 47 &&\n        startTag &&\n        htmlRawNames.indexOf(buffer.toLowerCase()) > -1\n      ) {\n        kind = 1\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      if (htmlBlockNames.indexOf(buffer.toLowerCase()) > -1) {\n        kind = 6\n\n        if (code === 47) {\n          effects.consume(code)\n          return basicSelfClosing\n        }\n\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      kind = 7 // Do not support complete HTML when interrupting.\n\n      return self.interrupt\n        ? nok(code)\n        : startTag\n        ? completeAttributeNameBefore(code)\n        : completeClosingTagAfter(code)\n    }\n\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      buffer += fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuation\n    }\n\n    return nok(code)\n  }\n\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeClosingTagAfter\n    }\n\n    return completeEnd(code)\n  }\n\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return completeEnd\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameBefore\n    }\n\n    return completeEnd(code)\n  }\n\n  function completeAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    return completeAttributeNameAfter(code)\n  }\n\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameAfter\n    }\n\n    return completeAttributeNameBefore(code)\n  }\n\n  function completeAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return completeAttributeValueQuoted\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    marker = undefined\n    return completeAttributeValueUnquoted(code)\n  }\n\n  function completeAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return completeAttributeValueQuotedAfter\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return completeAttributeValueQuoted\n  }\n\n  function completeAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      return completeAttributeNameAfter(code)\n    }\n\n    effects.consume(code)\n    return completeAttributeValueUnquoted\n  }\n\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code)\n    }\n\n    return nok(code)\n  }\n\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return nok(code)\n  }\n\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return code === null || markdownLineEnding(code)\n      ? continuation(code)\n      : nok(code)\n  }\n\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code)\n      return continuationCommentInside\n    }\n\n    if (code === 60 && kind === 1) {\n      effects.consume(code)\n      return continuationRawTagOpen\n    }\n\n    if (code === 62 && kind === 4) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (code === 63 && kind === 3) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    if (code === 93 && kind === 5) {\n      effects.consume(code)\n      return continuationCharacterDataInside\n    }\n\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(\n        nextBlankConstruct,\n        continuationClose,\n        continuationAtLineEnding\n      )(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code)\n    }\n\n    effects.consume(code)\n    return continuation\n  }\n\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData')\n    return htmlContinueStart(code)\n  }\n\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return htmlContinueStart\n    }\n\n    effects.enter('htmlFlowData')\n    return continuation(code)\n  }\n\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code)\n      buffer = ''\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code)\n      buffer += fromCharCode(code)\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    return continuation(code)\n  }\n\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData')\n      return done(code)\n    }\n\n    effects.consume(code)\n    return continuationClose\n  }\n\n  function done(code) {\n    effects.exit('htmlFlow')\n    return ok(code)\n  }\n}\n\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.exit('htmlFlowData')\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    return effects.attempt(partialBlankLine, ok, nok)\n  }\n}\n\nmodule.exports = htmlFlow\n", "'use strict'\n\nvar asciiAlpha = require('../character/ascii-alpha.js')\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js')\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar markdownSpace = require('../character/markdown-space.js')\nvar factorySpace = require('./factory-space.js')\n\nvar htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n}\n\nfunction tokenizeHtmlText(effects, ok, nok) {\n  var self = this\n  var marker\n  var buffer\n  var index\n  var returnState\n  return start\n\n  function start(code) {\n    effects.enter('htmlText')\n    effects.enter('htmlTextData')\n    effects.consume(code)\n    return open\n  }\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationOpen\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instruction\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    return nok(code)\n  }\n\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentOpen\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpen\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return declaration\n    }\n\n    return nok(code)\n  }\n\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentStart\n    }\n\n    return nok(code)\n  }\n\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentStartDash\n    }\n\n    return comment(code)\n  }\n\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    return comment(code)\n  }\n\n  function comment(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = comment\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return comment\n  }\n\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return end\n    }\n\n    return comment(code)\n  }\n\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length ? cdata : cdataOpen\n    }\n\n    return nok(code)\n  }\n\n  function cdata(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = cdata\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return cdata\n  }\n\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = declaration\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return declaration\n  }\n\n  function instruction(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instructionClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = instruction\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return instruction\n  }\n\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code)\n  }\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return nok(code)\n  }\n\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return tagCloseBetween(code)\n  }\n\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagCloseBetween\n    }\n\n    return end(code)\n  }\n\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return end\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenBetween\n    }\n\n    return end(code)\n  }\n\n  function tagOpenAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    return tagOpenAttributeNameAfter(code)\n  }\n\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeNameAfter\n    }\n\n    return tagOpenBetween(code)\n  }\n\n  function tagOpenAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return tagOpenAttributeValueQuoted\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    effects.consume(code)\n    marker = undefined\n    return tagOpenAttributeValueUnquoted\n  }\n\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return tagOpenAttributeValueQuotedAfter\n    }\n\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueQuoted\n  }\n\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n\n  function tagOpenAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueUnquoted\n  } // We can\u2019t have blank lines in content, so no need to worry about empty\n  // tokens.\n\n  function atLineEnding(code) {\n    effects.exit('htmlTextData')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(\n      effects,\n      afterPrefix,\n      'linePrefix',\n      self.parser.constructs.disable.null.indexOf('codeIndented') > -1\n        ? undefined\n        : 4\n    )\n  }\n\n  function afterPrefix(code) {\n    effects.enter('htmlTextData')\n    return returnState(code)\n  }\n\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code)\n      effects.exit('htmlTextData')\n      effects.exit('htmlText')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = htmlText\n", "'use strict'\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js')\nvar chunkedPush = require('../util/chunked-push.js')\nvar chunkedSplice = require('../util/chunked-splice.js')\nvar normalizeIdentifier = require('../util/normalize-identifier.js')\nvar resolveAll = require('../util/resolve-all.js')\nvar shallow = require('../util/shallow.js')\nvar factoryDestination = require('./factory-destination.js')\nvar factoryLabel = require('./factory-label.js')\nvar factoryTitle = require('./factory-title.js')\nvar factoryWhitespace = require('./factory-whitespace.js')\n\nvar labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n}\nvar resourceConstruct = {\n  tokenize: tokenizeResource\n}\nvar fullReferenceConstruct = {\n  tokenize: tokenizeFullReference\n}\nvar collapsedReferenceConstruct = {\n  tokenize: tokenizeCollapsedReference\n}\n\nfunction resolveAllLabelEnd(events) {\n  var index = -1\n  var token\n\n  while (++index < events.length) {\n    token = events[index][1]\n\n    if (\n      !token._used &&\n      (token.type === 'labelImage' ||\n        token.type === 'labelLink' ||\n        token.type === 'labelEnd')\n    ) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2)\n      token.type = 'data'\n      index++\n    }\n  }\n\n  return events\n}\n\nfunction resolveToLabelEnd(events, context) {\n  var index = events.length\n  var offset = 0\n  var group\n  var label\n  var text\n  var token\n  var open\n  var close\n  var media // Find an opening.\n\n  while (index--) {\n    token = events[index][1]\n\n    if (open) {\n      // If we see another link, or inactive link label, we\u2019ve been here before.\n      if (\n        token.type === 'link' ||\n        (token.type === 'labelLink' && token._inactive)\n      ) {\n        break\n      } // Mark other link openings as inactive, as we can\u2019t have links in\n      // links.\n\n      if (events[index][0] === 'enter' && token.type === 'labelLink') {\n        token._inactive = true\n      }\n    } else if (close) {\n      if (\n        events[index][0] === 'enter' &&\n        (token.type === 'labelImage' || token.type === 'labelLink') &&\n        !token._balanced\n      ) {\n        open = index\n\n        if (token.type !== 'labelLink') {\n          offset = 2\n          break\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index\n    }\n  }\n\n  group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: shallow(events[open][1].start),\n    end: shallow(events[events.length - 1][1].end)\n  }\n  label = {\n    type: 'label',\n    start: shallow(events[open][1].start),\n    end: shallow(events[close][1].end)\n  }\n  text = {\n    type: 'labelText',\n    start: shallow(events[open + offset + 2][1].end),\n    end: shallow(events[close - 2][1].start)\n  }\n  media = [\n    ['enter', group, context],\n    ['enter', label, context]\n  ] // Opening marker.\n\n  media = chunkedPush(media, events.slice(open + 1, open + offset + 3)) // Text open.\n\n  media = chunkedPush(media, [['enter', text, context]]) // Between.\n\n  media = chunkedPush(\n    media,\n    resolveAll(\n      context.parser.constructs.insideSpan.null,\n      events.slice(open + offset + 4, close - 3),\n      context\n    )\n  ) // Text close, marker close, label close.\n\n  media = chunkedPush(media, [\n    ['exit', text, context],\n    events[close - 2],\n    events[close - 1],\n    ['exit', label, context]\n  ]) // Reference, resource, or so.\n\n  media = chunkedPush(media, events.slice(close + 1)) // Media close.\n\n  media = chunkedPush(media, [['exit', group, context]])\n  chunkedSplice(events, open, events.length, media)\n  return events\n}\n\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  var self = this\n  var index = self.events.length\n  var labelStart\n  var defined // Find an opening.\n\n  while (index--) {\n    if (\n      (self.events[index][1].type === 'labelImage' ||\n        self.events[index][1].type === 'labelLink') &&\n      !self.events[index][1]._balanced\n    ) {\n      labelStart = self.events[index][1]\n      break\n    }\n  }\n\n  return start\n\n  function start(code) {\n    if (!labelStart) {\n      return nok(code)\n    } // It\u2019s a balanced bracket, but contains a link.\n\n    if (labelStart._inactive) return balanced(code)\n    defined =\n      self.parser.defined.indexOf(\n        normalizeIdentifier(\n          self.sliceSerialize({\n            start: labelStart.end,\n            end: self.now()\n          })\n        )\n      ) > -1\n    effects.enter('labelEnd')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelEnd')\n    return afterLabelEnd\n  }\n\n  function afterLabelEnd(code) {\n    // Resource: `[asd](fgh)`.\n    if (code === 40) {\n      return effects.attempt(\n        resourceConstruct,\n        ok,\n        defined ? ok : balanced\n      )(code)\n    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?\n\n    if (code === 91) {\n      return effects.attempt(\n        fullReferenceConstruct,\n        ok,\n        defined\n          ? effects.attempt(collapsedReferenceConstruct, ok, balanced)\n          : balanced\n      )(code)\n    } // Shortcut reference: `[asd]`?\n\n    return defined ? ok(code) : balanced(code)\n  }\n\n  function balanced(code) {\n    labelStart._balanced = true\n    return nok(code)\n  }\n}\n\nfunction tokenizeResource(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.enter('resource')\n    effects.enter('resourceMarker')\n    effects.consume(code)\n    effects.exit('resourceMarker')\n    return factoryWhitespace(effects, open)\n  }\n\n  function open(code) {\n    if (code === 41) {\n      return end(code)\n    }\n\n    return factoryDestination(\n      effects,\n      destinationAfter,\n      nok,\n      'resourceDestination',\n      'resourceDestinationLiteral',\n      'resourceDestinationLiteralMarker',\n      'resourceDestinationRaw',\n      'resourceDestinationString',\n      3\n    )(code)\n  }\n\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, between)(code)\n      : end(code)\n  }\n\n  function between(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factoryWhitespace(effects, end),\n        nok,\n        'resourceTitle',\n        'resourceTitleMarker',\n        'resourceTitleString'\n      )(code)\n    }\n\n    return end(code)\n  }\n\n  function end(code) {\n    if (code === 41) {\n      effects.enter('resourceMarker')\n      effects.consume(code)\n      effects.exit('resourceMarker')\n      effects.exit('resource')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n\nfunction tokenizeFullReference(effects, ok, nok) {\n  var self = this\n  return start\n\n  function start(code) {\n    return factoryLabel.call(\n      self,\n      effects,\n      afterLabel,\n      nok,\n      'reference',\n      'referenceMarker',\n      'referenceString'\n    )(code)\n  }\n\n  function afterLabel(code) {\n    return self.parser.defined.indexOf(\n      normalizeIdentifier(\n        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n      )\n    ) < 0\n      ? nok(code)\n      : ok(code)\n  }\n}\n\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.enter('reference')\n    effects.enter('referenceMarker')\n    effects.consume(code)\n    effects.exit('referenceMarker')\n    return open\n  }\n\n  function open(code) {\n    if (code === 93) {\n      effects.enter('referenceMarker')\n      effects.consume(code)\n      effects.exit('referenceMarker')\n      effects.exit('reference')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = labelEnd\n", "'use strict'\n\nvar labelEnd = require('./label-end.js')\n\nvar labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n}\n\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  var self = this\n  return start\n\n  function start(code) {\n    effects.enter('labelImage')\n    effects.enter('labelImageMarker')\n    effects.consume(code)\n    effects.exit('labelImageMarker')\n    return open\n  }\n\n  function open(code) {\n    if (code === 91) {\n      effects.enter('labelMarker')\n      effects.consume(code)\n      effects.exit('labelMarker')\n      effects.exit('labelImage')\n      return after\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 &&\n      /* c8 ignore next */\n      '_hiddenFootnoteSupport' in self.parser.constructs\n      ? /* c8 ignore next */\n        nok(code)\n      : ok(code)\n  }\n}\n\nmodule.exports = labelStartImage\n", "'use strict'\n\nvar labelEnd = require('./label-end.js')\n\nvar labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n}\n\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  var self = this\n  return start\n\n  function start(code) {\n    effects.enter('labelLink')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelLink')\n    return after\n  }\n\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 &&\n      /* c8 ignore next */\n      '_hiddenFootnoteSupport' in self.parser.constructs\n      ? /* c8 ignore next */\n        nok(code)\n      : ok(code)\n  }\n}\n\nmodule.exports = labelStartLink\n", "'use strict'\n\nvar factorySpace = require('./factory-space.js')\n\nvar lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n}\n\nfunction tokenizeLineEnding(effects, ok) {\n  return start\n\n  function start(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, ok, 'linePrefix')\n  }\n}\n\nmodule.exports = lineEnding\n", "'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownSpace = require('../character/markdown-space.js')\nvar factorySpace = require('./factory-space.js')\n\nvar thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n}\n\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  var size = 0\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter('thematicBreak')\n    marker = code\n    return atBreak(code)\n  }\n\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence')\n      return sequence(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code)\n    }\n\n    if (size < 3 || (code !== null && !markdownLineEnding(code))) {\n      return nok(code)\n    }\n\n    effects.exit('thematicBreak')\n    return ok(code)\n  }\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      size++\n      return sequence\n    }\n\n    effects.exit('thematicBreakSequence')\n    return atBreak(code)\n  }\n}\n\nmodule.exports = thematicBreak\n", "'use strict'\n\nvar asciiDigit = require('../character/ascii-digit.js')\nvar markdownSpace = require('../character/markdown-space.js')\nvar prefixSize = require('../util/prefix-size.js')\nvar sizeChunks = require('../util/size-chunks.js')\nvar factorySpace = require('./factory-space.js')\nvar partialBlankLine = require('./partial-blank-line.js')\nvar thematicBreak = require('./thematic-break.js')\n\nvar list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n}\nvar listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n}\nvar indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n\nfunction tokenizeListStart(effects, ok, nok) {\n  var self = this\n  var initialSize = prefixSize(self.events, 'linePrefix')\n  var size = 0\n  return start\n\n  function start(code) {\n    var kind =\n      self.containerState.type ||\n      (code === 42 || code === 43 || code === 45\n        ? 'listUnordered'\n        : 'listOrdered')\n\n    if (\n      kind === 'listUnordered'\n        ? !self.containerState.marker || code === self.containerState.marker\n        : asciiDigit(code)\n    ) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind\n        effects.enter(kind, {\n          _container: true\n        })\n      }\n\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix')\n        return code === 42 || code === 45\n          ? effects.check(thematicBreak, nok, atMarker)(code)\n          : atMarker(code)\n      }\n\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix')\n        effects.enter('listItemValue')\n        return inside(code)\n      }\n    }\n\n    return nok(code)\n  }\n\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code)\n      return inside\n    }\n\n    if (\n      (!self.interrupt || size < 2) &&\n      (self.containerState.marker\n        ? code === self.containerState.marker\n        : code === 41 || code === 46)\n    ) {\n      effects.exit('listItemValue')\n      return atMarker(code)\n    }\n\n    return nok(code)\n  }\n\n  function atMarker(code) {\n    effects.enter('listItemMarker')\n    effects.consume(code)\n    effects.exit('listItemMarker')\n    self.containerState.marker = self.containerState.marker || code\n    return effects.check(\n      partialBlankLine, // Can\u2019t be empty when interrupting.\n      self.interrupt ? nok : onBlank,\n      effects.attempt(\n        listItemPrefixWhitespaceConstruct,\n        endOfPrefix,\n        otherPrefix\n      )\n    )\n  }\n\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true\n    initialSize++\n    return endOfPrefix(code)\n  }\n\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter('listItemPrefixWhitespace')\n      effects.consume(code)\n      effects.exit('listItemPrefixWhitespace')\n      return endOfPrefix\n    }\n\n    return nok(code)\n  }\n\n  function endOfPrefix(code) {\n    self.containerState.size =\n      initialSize + sizeChunks(self.sliceStream(effects.exit('listItemPrefix')))\n    return ok(code)\n  }\n}\n\nfunction tokenizeListContinuation(effects, ok, nok) {\n  var self = this\n  self.containerState._closeFlow = undefined\n  return effects.check(partialBlankLine, onBlank, notBlank)\n\n  function onBlank(code) {\n    self.containerState.furtherBlankLines =\n      self.containerState.furtherBlankLines ||\n      self.containerState.initialBlankLine // We have a blank line.\n    // Still, try to consume at most the items size.\n\n    return factorySpace(\n      effects,\n      ok,\n      'listItemIndent',\n      self.containerState.size + 1\n    )(code)\n  }\n\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined\n      return notInCurrentItem(code)\n    }\n\n    self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)\n  }\n\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true // As we\u2019re closing flow, we\u2019re no longer interrupting.\n\n    self.interrupt = undefined\n    return factorySpace(\n      effects,\n      effects.attempt(list, ok, nok),\n      'linePrefix',\n      self.parser.constructs.disable.null.indexOf('codeIndented') > -1\n        ? undefined\n        : 4\n    )(code)\n  }\n}\n\nfunction tokenizeIndent(effects, ok, nok) {\n  var self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemIndent',\n    self.containerState.size + 1\n  )\n\n  function afterPrefix(code) {\n    return prefixSize(self.events, 'listItemIndent') ===\n      self.containerState.size\n      ? ok(code)\n      : nok(code)\n  }\n}\n\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type)\n}\n\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  var self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemPrefixWhitespace',\n    self.parser.constructs.disable.null.indexOf('codeIndented') > -1\n      ? undefined\n      : 4 + 1\n  )\n\n  function afterPrefix(code) {\n    return markdownSpace(code) ||\n      !prefixSize(self.events, 'listItemPrefixWhitespace')\n      ? nok(code)\n      : ok(code)\n  }\n}\n\nmodule.exports = list\n", "'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar shallow = require('../util/shallow.js')\nvar factorySpace = require('./factory-space.js')\n\nvar setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n}\n\nfunction resolveToSetextUnderline(events, context) {\n  var index = events.length\n  var content\n  var text\n  var definition\n  var heading // Find the opening of the content.\n  // It\u2019ll always exist: we don\u2019t tokenize if it isn\u2019t there.\n\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index\n        break\n      }\n\n      if (events[index][1].type === 'paragraph') {\n        text = index\n      }\n    } // Exit\n    else {\n      if (events[index][1].type === 'content') {\n        // Remove the content end (if needed we\u2019ll add it later)\n        events.splice(index, 1)\n      }\n\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index\n      }\n    }\n  }\n\n  heading = {\n    type: 'setextHeading',\n    start: shallow(events[text][1].start),\n    end: shallow(events[events.length - 1][1].end)\n  } // Change the paragraph to setext heading text.\n\n  events[text][1].type = 'setextHeadingText' // If we have definitions in the content, we\u2019ll keep on having content,\n  // but we need move it.\n\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context])\n    events.splice(definition + 1, 0, ['exit', events[content][1], context])\n    events[content][1].end = shallow(events[definition][1].end)\n  } else {\n    events[content][1] = heading\n  } // Add the heading exit at the end.\n\n  events.push(['exit', heading, context])\n  return events\n}\n\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  var self = this\n  var index = self.events.length\n  var marker\n  var paragraph // Find an opening.\n\n  while (index--) {\n    // Skip enter/exit of line ending, line prefix, and content.\n    // We can now either have a definition or a paragraph.\n    if (\n      self.events[index][1].type !== 'lineEnding' &&\n      self.events[index][1].type !== 'linePrefix' &&\n      self.events[index][1].type !== 'content'\n    ) {\n      paragraph = self.events[index][1].type === 'paragraph'\n      break\n    }\n  }\n\n  return start\n\n  function start(code) {\n    if (!self.lazy && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine')\n      effects.enter('setextHeadingLineSequence')\n      marker = code\n      return closingSequence(code)\n    }\n\n    return nok(code)\n  }\n\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return closingSequence\n    }\n\n    effects.exit('setextHeadingLineSequence')\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code)\n  }\n\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = setextUnderline\n", "'use strict'\n\nObject.defineProperty(exports, '__esModule', {value: true})\n\nvar text$1 = require('./initialize/text.js')\nvar attention = require('./tokenize/attention.js')\nvar autolink = require('./tokenize/autolink.js')\nvar blockQuote = require('./tokenize/block-quote.js')\nvar characterEscape = require('./tokenize/character-escape.js')\nvar characterReference = require('./tokenize/character-reference.js')\nvar codeFenced = require('./tokenize/code-fenced.js')\nvar codeIndented = require('./tokenize/code-indented.js')\nvar codeText = require('./tokenize/code-text.js')\nvar definition = require('./tokenize/definition.js')\nvar hardBreakEscape = require('./tokenize/hard-break-escape.js')\nvar headingAtx = require('./tokenize/heading-atx.js')\nvar htmlFlow = require('./tokenize/html-flow.js')\nvar htmlText = require('./tokenize/html-text.js')\nvar labelEnd = require('./tokenize/label-end.js')\nvar labelStartImage = require('./tokenize/label-start-image.js')\nvar labelStartLink = require('./tokenize/label-start-link.js')\nvar lineEnding = require('./tokenize/line-ending.js')\nvar list = require('./tokenize/list.js')\nvar setextUnderline = require('./tokenize/setext-underline.js')\nvar thematicBreak = require('./tokenize/thematic-break.js')\n\nvar document = {\n  42: list,\n  // Asterisk\n  43: list,\n  // Plus sign\n  45: list,\n  // Dash\n  48: list,\n  // 0\n  49: list,\n  // 1\n  50: list,\n  // 2\n  51: list,\n  // 3\n  52: list,\n  // 4\n  53: list,\n  // 5\n  54: list,\n  // 6\n  55: list,\n  // 7\n  56: list,\n  // 8\n  57: list,\n  // 9\n  62: blockQuote // Greater than\n}\nvar contentInitial = {\n  91: definition // Left square bracket\n}\nvar flowInitial = {\n  '-2': codeIndented,\n  // Horizontal tab\n  '-1': codeIndented,\n  // Virtual space\n  32: codeIndented // Space\n}\nvar flow = {\n  35: headingAtx,\n  // Number sign\n  42: thematicBreak,\n  // Asterisk\n  45: [setextUnderline, thematicBreak],\n  // Dash\n  60: htmlFlow,\n  // Less than\n  61: setextUnderline,\n  // Equals to\n  95: thematicBreak,\n  // Underscore\n  96: codeFenced,\n  // Grave accent\n  126: codeFenced // Tilde\n}\nvar string = {\n  38: characterReference,\n  // Ampersand\n  92: characterEscape // Backslash\n}\nvar text = {\n  '-5': lineEnding,\n  // Carriage return\n  '-4': lineEnding,\n  // Line feed\n  '-3': lineEnding,\n  // Carriage return + line feed\n  33: labelStartImage,\n  // Exclamation mark\n  38: characterReference,\n  // Ampersand\n  42: attention,\n  // Asterisk\n  60: [autolink, htmlText],\n  // Less than\n  91: labelStartLink,\n  // Left square bracket\n  92: [hardBreakEscape, characterEscape],\n  // Backslash\n  93: labelEnd,\n  // Right square bracket\n  95: attention,\n  // Underscore\n  96: codeText // Grave accent\n}\nvar insideSpan = {\n  null: [attention, text$1.resolver]\n}\nvar disable = {\n  null: []\n}\n\nexports.contentInitial = contentInitial\nexports.disable = disable\nexports.document = document\nexports.flow = flow\nexports.flowInitial = flowInitial\nexports.insideSpan = insideSpan\nexports.string = string\nexports.text = text\n", "'use strict'\n\nvar content = require('./initialize/content.js')\nvar document = require('./initialize/document.js')\nvar flow = require('./initialize/flow.js')\nvar text = require('./initialize/text.js')\nvar combineExtensions = require('./util/combine-extensions.js')\nvar createTokenizer = require('./util/create-tokenizer.js')\nvar miniflat = require('./util/miniflat.js')\nvar constructs = require('./constructs.js')\n\nfunction parse(options) {\n  var settings = options || {}\n  var parser = {\n    defined: [],\n    constructs: combineExtensions(\n      [constructs].concat(miniflat(settings.extensions))\n    ),\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(text.string),\n    text: create(text.text)\n  }\n  return parser\n\n  function create(initializer) {\n    return creator\n\n    function creator(from) {\n      return createTokenizer(parser, initializer, from)\n    }\n  }\n}\n\nmodule.exports = parse\n", "'use strict'\n\nvar search = /[\\0\\t\\n\\r]/g\n\nfunction preprocess() {\n  var start = true\n  var column = 1\n  var buffer = ''\n  var atCarriageReturn\n  return preprocessor\n\n  function preprocessor(value, encoding, end) {\n    var chunks = []\n    var match\n    var next\n    var startPosition\n    var endPosition\n    var code\n    value = buffer + value.toString(encoding)\n    startPosition = 0\n    buffer = ''\n\n    if (start) {\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++\n      }\n\n      start = undefined\n    }\n\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition\n      match = search.exec(value)\n      endPosition = match ? match.index : value.length\n      code = value.charCodeAt(endPosition)\n\n      if (!match) {\n        buffer = value.slice(startPosition)\n        break\n      }\n\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3)\n        atCarriageReturn = undefined\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5)\n          atCarriageReturn = undefined\n        }\n\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition))\n          column += endPosition - startPosition\n        }\n\n        if (code === 0) {\n          chunks.push(65533)\n          column++\n        } else if (code === 9) {\n          next = Math.ceil(column / 4) * 4\n          chunks.push(-2)\n\n          while (column++ < next) chunks.push(-1)\n        } else if (code === 10) {\n          chunks.push(-4)\n          column = 1\n        } // Must be carriage return.\n        else {\n          atCarriageReturn = true\n          column = 1\n        }\n      }\n\n      startPosition = endPosition + 1\n    }\n\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5)\n      if (buffer) chunks.push(buffer)\n      chunks.push(null)\n    }\n\n    return chunks\n  }\n}\n\nmodule.exports = preprocess\n", "'use strict'\n\nvar subtokenize = require('./util/subtokenize.js')\n\nfunction postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n\n  return events\n}\n\nmodule.exports = postprocess\n", "'use strict'\n\nmodule.exports = fromMarkdown\n\n// These three are compiled away in the `dist/`\n\nvar toString = require('mdast-util-to-string')\nvar assign = require('micromark/dist/constant/assign')\nvar own = require('micromark/dist/constant/has-own-property')\nvar normalizeIdentifier = require('micromark/dist/util/normalize-identifier')\nvar safeFromInt = require('micromark/dist/util/safe-from-int')\nvar parser = require('micromark/dist/parse')\nvar preprocessor = require('micromark/dist/preprocess')\nvar postprocess = require('micromark/dist/postprocess')\nvar decode = require('parse-entities/decode-entity')\nvar stringifyPosition = require('unist-util-stringify-position')\n\nfunction fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding\n    encoding = undefined\n  }\n\n  return compiler(options)(\n    postprocess(\n      parser(options).document().write(preprocessor()(value, encoding, true))\n    )\n  )\n}\n\n// Note this compiler only understand complete buffering, not streaming.\nfunction compiler(options) {\n  var settings = options || {}\n  var config = configure(\n    {\n      transforms: [],\n      canContainEols: [\n        'emphasis',\n        'fragment',\n        'heading',\n        'paragraph',\n        'strong'\n      ],\n\n      enter: {\n        autolink: opener(link),\n        autolinkProtocol: onenterdata,\n        autolinkEmail: onenterdata,\n        atxHeading: opener(heading),\n        blockQuote: opener(blockQuote),\n        characterEscape: onenterdata,\n        characterReference: onenterdata,\n        codeFenced: opener(codeFlow),\n        codeFencedFenceInfo: buffer,\n        codeFencedFenceMeta: buffer,\n        codeIndented: opener(codeFlow, buffer),\n        codeText: opener(codeText, buffer),\n        codeTextData: onenterdata,\n        data: onenterdata,\n        codeFlowValue: onenterdata,\n        definition: opener(definition),\n        definitionDestinationString: buffer,\n        definitionLabelString: buffer,\n        definitionTitleString: buffer,\n        emphasis: opener(emphasis),\n        hardBreakEscape: opener(hardBreak),\n        hardBreakTrailing: opener(hardBreak),\n        htmlFlow: opener(html, buffer),\n        htmlFlowData: onenterdata,\n        htmlText: opener(html, buffer),\n        htmlTextData: onenterdata,\n        image: opener(image),\n        label: buffer,\n        link: opener(link),\n        listItem: opener(listItem),\n        listItemValue: onenterlistitemvalue,\n        listOrdered: opener(list, onenterlistordered),\n        listUnordered: opener(list),\n        paragraph: opener(paragraph),\n        reference: onenterreference,\n        referenceString: buffer,\n        resourceDestinationString: buffer,\n        resourceTitleString: buffer,\n        setextHeading: opener(heading),\n        strong: opener(strong),\n        thematicBreak: opener(thematicBreak)\n      },\n\n      exit: {\n        atxHeading: closer(),\n        atxHeadingSequence: onexitatxheadingsequence,\n        autolink: closer(),\n        autolinkEmail: onexitautolinkemail,\n        autolinkProtocol: onexitautolinkprotocol,\n        blockQuote: closer(),\n        characterEscapeValue: onexitdata,\n        characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n        characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n        characterReferenceValue: onexitcharacterreferencevalue,\n        codeFenced: closer(onexitcodefenced),\n        codeFencedFence: onexitcodefencedfence,\n        codeFencedFenceInfo: onexitcodefencedfenceinfo,\n        codeFencedFenceMeta: onexitcodefencedfencemeta,\n        codeFlowValue: onexitdata,\n        codeIndented: closer(onexitcodeindented),\n        codeText: closer(onexitcodetext),\n        codeTextData: onexitdata,\n        data: onexitdata,\n        definition: closer(),\n        definitionDestinationString: onexitdefinitiondestinationstring,\n        definitionLabelString: onexitdefinitionlabelstring,\n        definitionTitleString: onexitdefinitiontitlestring,\n        emphasis: closer(),\n        hardBreakEscape: closer(onexithardbreak),\n        hardBreakTrailing: closer(onexithardbreak),\n        htmlFlow: closer(onexithtmlflow),\n        htmlFlowData: onexitdata,\n        htmlText: closer(onexithtmltext),\n        htmlTextData: onexitdata,\n        image: closer(onexitimage),\n        label: onexitlabel,\n        labelText: onexitlabeltext,\n        lineEnding: onexitlineending,\n        link: closer(onexitlink),\n        listItem: closer(),\n        listOrdered: closer(),\n        listUnordered: closer(),\n        paragraph: closer(),\n        referenceString: onexitreferencestring,\n        resourceDestinationString: onexitresourcedestinationstring,\n        resourceTitleString: onexitresourcetitlestring,\n        resource: onexitresource,\n        setextHeading: closer(onexitsetextheading),\n        setextHeadingLineSequence: onexitsetextheadinglinesequence,\n        setextHeadingText: onexitsetextheadingtext,\n        strong: closer(),\n        thematicBreak: closer()\n      }\n    },\n\n    settings.mdastExtensions || []\n  )\n\n  var data = {}\n\n  return compile\n\n  function compile(events) {\n    var tree = {type: 'root', children: []}\n    var stack = [tree]\n    var tokenStack = []\n    var listStack = []\n    var index = -1\n    var handler\n    var listStart\n\n    var context = {\n      stack: stack,\n      tokenStack: tokenStack,\n      config: config,\n      enter: enter,\n      exit: exit,\n      buffer: buffer,\n      resume: resume,\n      setData: setData,\n      getData: getData\n    }\n\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (\n        events[index][1].type === 'listOrdered' ||\n        events[index][1].type === 'listUnordered'\n      ) {\n        if (events[index][0] === 'enter') {\n          listStack.push(index)\n        } else {\n          listStart = listStack.pop(index)\n          index = prepareList(events, listStart, index)\n        }\n      }\n    }\n\n    index = -1\n\n    while (++index < events.length) {\n      handler = config[events[index][0]]\n\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(\n          assign({sliceSerialize: events[index][2].sliceSerialize}, context),\n          events[index][1]\n        )\n      }\n    }\n\n    if (tokenStack.length) {\n      throw new Error(\n        'Cannot close document, a token (`' +\n          tokenStack[tokenStack.length - 1].type +\n          '`, ' +\n          stringifyPosition({\n            start: tokenStack[tokenStack.length - 1].start,\n            end: tokenStack[tokenStack.length - 1].end\n          }) +\n          ') is still open'\n      )\n    }\n\n    // Figure out `root` position.\n    tree.position = {\n      start: point(\n        events.length ? events[0][1].start : {line: 1, column: 1, offset: 0}\n      ),\n\n      end: point(\n        events.length\n          ? events[events.length - 2][1].end\n          : {line: 1, column: 1, offset: 0}\n      )\n    }\n\n    index = -1\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree\n    }\n\n    return tree\n  }\n\n  function prepareList(events, start, length) {\n    var index = start - 1\n    var containerBalance = -1\n    var listSpread = false\n    var listItem\n    var tailIndex\n    var lineIndex\n    var tailEvent\n    var event\n    var firstBlankLineIndex\n    var atMarker\n\n    while (++index <= length) {\n      event = events[index]\n\n      if (\n        event[1].type === 'listUnordered' ||\n        event[1].type === 'listOrdered' ||\n        event[1].type === 'blockQuote'\n      ) {\n        if (event[0] === 'enter') {\n          containerBalance++\n        } else {\n          containerBalance--\n        }\n\n        atMarker = undefined\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (\n            listItem &&\n            !atMarker &&\n            !containerBalance &&\n            !firstBlankLineIndex\n          ) {\n            firstBlankLineIndex = index\n          }\n\n          atMarker = undefined\n        }\n      } else if (\n        event[1].type === 'linePrefix' ||\n        event[1].type === 'listItemValue' ||\n        event[1].type === 'listItemMarker' ||\n        event[1].type === 'listItemPrefix' ||\n        event[1].type === 'listItemPrefixWhitespace'\n      ) {\n        // Empty.\n      } else {\n        atMarker = undefined\n      }\n\n      if (\n        (!containerBalance &&\n          event[0] === 'enter' &&\n          event[1].type === 'listItemPrefix') ||\n        (containerBalance === -1 &&\n          event[0] === 'exit' &&\n          (event[1].type === 'listUnordered' ||\n            event[1].type === 'listOrdered'))\n      ) {\n        if (listItem) {\n          tailIndex = index\n          lineIndex = undefined\n\n          while (tailIndex--) {\n            tailEvent = events[tailIndex]\n\n            if (\n              tailEvent[1].type === 'lineEnding' ||\n              tailEvent[1].type === 'lineEndingBlank'\n            ) {\n              if (tailEvent[0] === 'exit') continue\n\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank'\n                listSpread = true\n              }\n\n              tailEvent[1].type = 'lineEnding'\n              lineIndex = tailIndex\n            } else if (\n              tailEvent[1].type === 'linePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefixWhitespace' ||\n              tailEvent[1].type === 'blockQuoteMarker' ||\n              tailEvent[1].type === 'listItemIndent'\n            ) {\n              // Empty\n            } else {\n              break\n            }\n          }\n\n          if (\n            firstBlankLineIndex &&\n            (!lineIndex || firstBlankLineIndex < lineIndex)\n          ) {\n            listItem._spread = true\n          }\n\n          // Fix position.\n          listItem.end = point(\n            lineIndex ? events[lineIndex][1].start : event[1].end\n          )\n\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]])\n          index++\n          length++\n        }\n\n        // Create a new list item.\n        if (event[1].type === 'listItemPrefix') {\n          listItem = {\n            type: 'listItem',\n            _spread: false,\n            start: point(event[1].start)\n          }\n\n          events.splice(index, 0, ['enter', listItem, event[2]])\n          index++\n          length++\n          firstBlankLineIndex = undefined\n          atMarker = true\n        }\n      }\n    }\n\n    events[start][1]._spread = listSpread\n    return length\n  }\n\n  function setData(key, value) {\n    data[key] = value\n  }\n\n  function getData(key) {\n    return data[key]\n  }\n\n  function point(d) {\n    return {line: d.line, column: d.column, offset: d.offset}\n  }\n\n  function opener(create, and) {\n    return open\n\n    function open(token) {\n      enter.call(this, create(token), token)\n      if (and) and.call(this, token)\n    }\n  }\n\n  function buffer() {\n    this.stack.push({type: 'fragment', children: []})\n  }\n\n  function enter(node, token) {\n    this.stack[this.stack.length - 1].children.push(node)\n    this.stack.push(node)\n    this.tokenStack.push(token)\n    node.position = {start: point(token.start)}\n    return node\n  }\n\n  function closer(and) {\n    return close\n\n    function close(token) {\n      if (and) and.call(this, token)\n      exit.call(this, token)\n    }\n  }\n\n  function exit(token) {\n    var node = this.stack.pop()\n    var open = this.tokenStack.pop()\n\n    if (!open) {\n      throw new Error(\n        'Cannot close `' +\n          token.type +\n          '` (' +\n          stringifyPosition({start: token.start, end: token.end}) +\n          '): it\u2019s not open'\n      )\n    } else if (open.type !== token.type) {\n      throw new Error(\n        'Cannot close `' +\n          token.type +\n          '` (' +\n          stringifyPosition({start: token.start, end: token.end}) +\n          '): a different token (`' +\n          open.type +\n          '`, ' +\n          stringifyPosition({start: open.start, end: open.end}) +\n          ') is open'\n      )\n    }\n\n    node.position.end = point(token.end)\n    return node\n  }\n\n  function resume() {\n    return toString(this.stack.pop())\n  }\n\n  //\n  // Handlers.\n  //\n\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true)\n  }\n\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      this.stack[this.stack.length - 2].start = parseInt(\n        this.sliceSerialize(token),\n        10\n      )\n\n      setData('expectingFirstListItemValue')\n    }\n  }\n\n  function onexitcodefencedfenceinfo() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].lang = data\n  }\n\n  function onexitcodefencedfencemeta() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].meta = data\n  }\n\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (getData('flowCodeInside')) return\n    this.buffer()\n    setData('flowCodeInside', true)\n  }\n\n  function onexitcodefenced() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data.replace(\n      /^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g,\n      ''\n    )\n\n    setData('flowCodeInside')\n  }\n\n  function onexitcodeindented() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data\n  }\n\n  function onexitdefinitionlabelstring(token) {\n    // Discard label, use the source content instead.\n    var label = this.resume()\n    this.stack[this.stack.length - 1].label = label\n    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n  }\n\n  function onexitdefinitiontitlestring() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].title = data\n  }\n\n  function onexitdefinitiondestinationstring() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].url = data\n  }\n\n  function onexitatxheadingsequence(token) {\n    if (!this.stack[this.stack.length - 1].depth) {\n      this.stack[this.stack.length - 1].depth = this.sliceSerialize(\n        token\n      ).length\n    }\n  }\n\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true)\n  }\n\n  function onexitsetextheadinglinesequence(token) {\n    this.stack[this.stack.length - 1].depth =\n      this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2\n  }\n\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding')\n  }\n\n  function onenterdata(token) {\n    var siblings = this.stack[this.stack.length - 1].children\n    var tail = siblings[siblings.length - 1]\n\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text()\n      tail.position = {start: point(token.start)}\n      this.stack[this.stack.length - 1].children.push(tail)\n    }\n\n    this.stack.push(tail)\n  }\n\n  function onexitdata(token) {\n    var tail = this.stack.pop()\n    tail.value += this.sliceSerialize(token)\n    tail.position.end = point(token.end)\n  }\n\n  function onexitlineending(token) {\n    var context = this.stack[this.stack.length - 1]\n\n    // If we\u2019re at a hard break, include the line ending in there.\n    if (getData('atHardBreak')) {\n      context.children[context.children.length - 1].position.end = point(\n        token.end\n      )\n\n      setData('atHardBreak')\n      return\n    }\n\n    if (\n      !getData('setextHeadingSlurpLineEnding') &&\n      config.canContainEols.indexOf(context.type) > -1\n    ) {\n      onenterdata.call(this, token)\n      onexitdata.call(this, token)\n    }\n  }\n\n  function onexithardbreak() {\n    setData('atHardBreak', true)\n  }\n\n  function onexithtmlflow() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data\n  }\n\n  function onexithtmltext() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data\n  }\n\n  function onexitcodetext() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data\n  }\n\n  function onexitlink() {\n    var context = this.stack[this.stack.length - 1]\n\n    // To do: clean.\n    if (getData('inReference')) {\n      context.type += 'Reference'\n      context.referenceType = getData('referenceType') || 'shortcut'\n      delete context.url\n      delete context.title\n    } else {\n      delete context.identifier\n      delete context.label\n      delete context.referenceType\n    }\n\n    setData('referenceType')\n  }\n\n  function onexitimage() {\n    var context = this.stack[this.stack.length - 1]\n\n    // To do: clean.\n    if (getData('inReference')) {\n      context.type += 'Reference'\n      context.referenceType = getData('referenceType') || 'shortcut'\n      delete context.url\n      delete context.title\n    } else {\n      delete context.identifier\n      delete context.label\n      delete context.referenceType\n    }\n\n    setData('referenceType')\n  }\n\n  function onexitlabeltext(token) {\n    this.stack[this.stack.length - 2].identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n  }\n\n  function onexitlabel() {\n    var fragment = this.stack[this.stack.length - 1]\n    var value = this.resume()\n\n    this.stack[this.stack.length - 1].label = value\n\n    // Assume a reference.\n    setData('inReference', true)\n\n    if (this.stack[this.stack.length - 1].type === 'link') {\n      this.stack[this.stack.length - 1].children = fragment.children\n    } else {\n      this.stack[this.stack.length - 1].alt = value\n    }\n  }\n\n  function onexitresourcedestinationstring() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].url = data\n  }\n\n  function onexitresourcetitlestring() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].title = data\n  }\n\n  function onexitresource() {\n    setData('inReference')\n  }\n\n  function onenterreference() {\n    setData('referenceType', 'collapsed')\n  }\n\n  function onexitreferencestring(token) {\n    var label = this.resume()\n    this.stack[this.stack.length - 1].label = label\n    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n    setData('referenceType', 'full')\n  }\n\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type)\n  }\n\n  function onexitcharacterreferencevalue(token) {\n    var data = this.sliceSerialize(token)\n    var type = getData('characterReferenceType')\n    var value\n    var tail\n\n    if (type) {\n      value = safeFromInt(\n        data,\n        type === 'characterReferenceMarkerNumeric' ? 10 : 16\n      )\n\n      setData('characterReferenceType')\n    } else {\n      value = decode(data)\n    }\n\n    tail = this.stack.pop()\n    tail.value += value\n    tail.position.end = point(token.end)\n  }\n\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token)\n    this.stack[this.stack.length - 1].url = this.sliceSerialize(token)\n  }\n\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token)\n    this.stack[this.stack.length - 1].url =\n      'mailto:' + this.sliceSerialize(token)\n  }\n\n  //\n  // Creaters.\n  //\n\n  function blockQuote() {\n    return {type: 'blockquote', children: []}\n  }\n\n  function codeFlow() {\n    return {type: 'code', lang: null, meta: null, value: ''}\n  }\n\n  function codeText() {\n    return {type: 'inlineCode', value: ''}\n  }\n\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    }\n  }\n\n  function emphasis() {\n    return {type: 'emphasis', children: []}\n  }\n\n  function heading() {\n    return {type: 'heading', depth: undefined, children: []}\n  }\n\n  function hardBreak() {\n    return {type: 'break'}\n  }\n\n  function html() {\n    return {type: 'html', value: ''}\n  }\n\n  function image() {\n    return {type: 'image', title: null, url: '', alt: null}\n  }\n\n  function link() {\n    return {type: 'link', title: null, url: '', children: []}\n  }\n\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      spread: token._spread,\n      children: []\n    }\n  }\n\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    }\n  }\n\n  function paragraph() {\n    return {type: 'paragraph', children: []}\n  }\n\n  function strong() {\n    return {type: 'strong', children: []}\n  }\n\n  function text() {\n    return {type: 'text', value: ''}\n  }\n\n  function thematicBreak() {\n    return {type: 'thematicBreak'}\n  }\n}\n\nfunction configure(config, extensions) {\n  var index = -1\n\n  while (++index < extensions.length) {\n    extension(config, extensions[index])\n  }\n\n  return config\n}\n\nfunction extension(config, extension) {\n  var key\n  var left\n\n  for (key in extension) {\n    left = own.call(config, key) ? config[key] : (config[key] = {})\n\n    if (key === 'canContainEols' || key === 'transforms') {\n      config[key] = [].concat(left, extension[key])\n    } else {\n      Object.assign(left, extension[key])\n    }\n  }\n}\n", "'use strict'\n\nmodule.exports = require('./dist')\n", "'use strict'\n\nmodule.exports = parse\n\nvar fromMarkdown = require('mdast-util-from-markdown')\n\nfunction parse(options) {\n  var self = this\n\n  this.Parser = parse\n\n  function parse(doc) {\n    return fromMarkdown(\n      doc,\n      Object.assign({}, self.data('settings'), options, {\n        // Note: these options are not in the readme.\n        // The goal is for them to be set by plugins on `data` instead of being\n        // passed by users.\n        extensions: self.data('micromarkExtensions') || [],\n        mdastExtensions: self.data('fromMarkdownExtensions') || []\n      })\n    )\n  }\n}\n", null, null, null, null, "var asciiAlpha = require('micromark/dist/character/ascii-alpha')\nvar asciiAlphanumeric = require('micromark/dist/character/ascii-alphanumeric')\nvar asciiControl = require('micromark/dist/character/ascii-control')\nvar markdownLineEnding = require('micromark/dist/character/markdown-line-ending')\nvar unicodePunctuation = require('micromark/dist/character/unicode-punctuation')\nvar unicodeWhitespace = require('micromark/dist/character/unicode-whitespace')\n\nvar www = {tokenize: tokenizeWww, partial: true}\nvar domain = {tokenize: tokenizeDomain, partial: true}\nvar path = {tokenize: tokenizePath, partial: true}\nvar punctuation = {tokenize: tokenizePunctuation, partial: true}\nvar namedCharacterReference = {\n  tokenize: tokenizeNamedCharacterReference,\n  partial: true\n}\n\nvar wwwAutolink = {tokenize: tokenizeWwwAutolink, previous: previousWww}\nvar httpAutolink = {tokenize: tokenizeHttpAutolink, previous: previousHttp}\nvar emailAutolink = {tokenize: tokenizeEmailAutolink, previous: previousEmail}\n\nvar text = {}\n\n// Export hooked constructs.\nexports.text = text\n\n// `0`\nvar code = 48\n\n// While the code is smaller than `{`.\nwhile (code < 123) {\n  text[code] = emailAutolink\n  code++\n  // Jump from `:` -> `A`\n  if (code === 58) code = 65\n  // Jump from `[` -> `a`\n  else if (code === 91) code = 97\n}\n\n// `+`\ntext[43] = emailAutolink\n// `-`\ntext[45] = emailAutolink\n// `.`\ntext[46] = emailAutolink\n// `_`\ntext[95] = emailAutolink\n// `h`.\ntext[72] = [emailAutolink, httpAutolink]\ntext[104] = [emailAutolink, httpAutolink]\n// `w`.\ntext[87] = [emailAutolink, wwwAutolink]\ntext[119] = [emailAutolink, wwwAutolink]\n\nfunction tokenizeEmailAutolink(effects, ok, nok) {\n  var self = this\n  var hasDot\n\n  return start\n\n  function start(code) {\n    /* istanbul ignore next - hooks. */\n    if (\n      !gfmAtext(code) ||\n      !previousEmail(self.previous) ||\n      previous(self.events)\n    ) {\n      return nok(code)\n    }\n\n    effects.enter('literalAutolink')\n    effects.enter('literalAutolinkEmail')\n    return atext(code)\n  }\n\n  function atext(code) {\n    if (gfmAtext(code)) {\n      effects.consume(code)\n      return atext\n    }\n\n    // `@`\n    if (code === 64) {\n      effects.consume(code)\n      return label\n    }\n\n    return nok(code)\n  }\n\n  function label(code) {\n    // `.`\n    if (code === 46) {\n      return effects.check(punctuation, done, dotContinuation)(code)\n    }\n\n    if (\n      // `-`\n      code === 45 ||\n      // `_`\n      code === 95\n    ) {\n      return effects.check(punctuation, nok, dashOrUnderscoreContinuation)(code)\n    }\n\n    if (asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return label\n    }\n\n    return done(code)\n  }\n\n  function dotContinuation(code) {\n    effects.consume(code)\n    hasDot = true\n    return label\n  }\n\n  function dashOrUnderscoreContinuation(code) {\n    effects.consume(code)\n    return afterDashOrUnderscore\n  }\n\n  function afterDashOrUnderscore(code) {\n    // `.`\n    if (code === 46) {\n      return effects.check(punctuation, nok, dotContinuation)(code)\n    }\n\n    return label(code)\n  }\n\n  function done(code) {\n    if (hasDot) {\n      effects.exit('literalAutolinkEmail')\n      effects.exit('literalAutolink')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n\nfunction tokenizeWwwAutolink(effects, ok, nok) {\n  var self = this\n\n  return start\n\n  function start(code) {\n    /* istanbul ignore next - hooks. */\n    if (\n      (code !== 87 && code - 32 !== 87) ||\n      !previousWww(self.previous) ||\n      previous(self.events)\n    ) {\n      return nok(code)\n    }\n\n    effects.enter('literalAutolink')\n    effects.enter('literalAutolinkWww')\n    // For `www.` we check instead of attempt, because when it matches, GH\n    // treats it as part of a domain (yes, it says a valid domain must come\n    // after `www.`, but that\u2019s not how it\u2019s implemented by them).\n    return effects.check(\n      www,\n      effects.attempt(domain, effects.attempt(path, done), nok),\n      nok\n    )(code)\n  }\n\n  function done(code) {\n    effects.exit('literalAutolinkWww')\n    effects.exit('literalAutolink')\n    return ok(code)\n  }\n}\n\nfunction tokenizeHttpAutolink(effects, ok, nok) {\n  var self = this\n\n  return start\n\n  function start(code) {\n    /* istanbul ignore next - hooks. */\n    if (\n      (code !== 72 && code - 32 !== 72) ||\n      !previousHttp(self.previous) ||\n      previous(self.events)\n    ) {\n      return nok(code)\n    }\n\n    effects.enter('literalAutolink')\n    effects.enter('literalAutolinkHttp')\n    effects.consume(code)\n    return t1\n  }\n\n  function t1(code) {\n    // `t`\n    if (code === 84 || code - 32 === 84) {\n      effects.consume(code)\n      return t2\n    }\n\n    return nok(code)\n  }\n\n  function t2(code) {\n    // `t`\n    if (code === 84 || code - 32 === 84) {\n      effects.consume(code)\n      return p\n    }\n\n    return nok(code)\n  }\n\n  function p(code) {\n    // `p`\n    if (code === 80 || code - 32 === 80) {\n      effects.consume(code)\n      return s\n    }\n\n    return nok(code)\n  }\n\n  function s(code) {\n    // `s`\n    if (code === 83 || code - 32 === 83) {\n      effects.consume(code)\n      return colon\n    }\n\n    return colon(code)\n  }\n\n  function colon(code) {\n    // `:`\n    if (code === 58) {\n      effects.consume(code)\n      return slash1\n    }\n\n    return nok(code)\n  }\n\n  function slash1(code) {\n    // `/`\n    if (code === 47) {\n      effects.consume(code)\n      return slash2\n    }\n\n    return nok(code)\n  }\n\n  function slash2(code) {\n    // `/`\n    if (code === 47) {\n      effects.consume(code)\n      return after\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    return asciiControl(code) ||\n      unicodeWhitespace(code) ||\n      unicodePunctuation(code)\n      ? nok(code)\n      : effects.attempt(domain, effects.attempt(path, done), nok)(code)\n  }\n\n  function done(code) {\n    effects.exit('literalAutolinkHttp')\n    effects.exit('literalAutolink')\n    return ok(code)\n  }\n}\n\nfunction tokenizeWww(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    // Assume a `w`.\n    effects.consume(code)\n    return w2\n  }\n\n  function w2(code) {\n    // `w`\n    if (code === 87 || code - 32 === 87) {\n      effects.consume(code)\n      return w3\n    }\n\n    return nok(code)\n  }\n\n  function w3(code) {\n    // `w`\n    if (code === 87 || code - 32 === 87) {\n      effects.consume(code)\n      return dot\n    }\n\n    return nok(code)\n  }\n\n  function dot(code) {\n    // `.`\n    if (code === 46) {\n      effects.consume(code)\n      return after\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? nok(code) : ok(code)\n  }\n}\n\nfunction tokenizeDomain(effects, ok, nok) {\n  var hasUnderscoreInLastSegment\n  var hasUnderscoreInLastLastSegment\n\n  return domain\n\n  function domain(code) {\n    // `&`\n    if (code === 38) {\n      return effects.check(\n        namedCharacterReference,\n        done,\n        punctuationContinuation\n      )(code)\n    }\n\n    if (code === 46 /* `.` */ || code === 95 /* `_` */) {\n      return effects.check(punctuation, done, punctuationContinuation)(code)\n    }\n\n    // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can\n    // occur, which sounds like ASCII only, but they also support `www.\u9EDE\u770B.com`,\n    // so that\u2019s Unicode.\n    // Instead of some new production for Unicode alphanumerics, markdown\n    // already has that for Unicode punctuation and whitespace, so use those.\n    if (\n      asciiControl(code) ||\n      unicodeWhitespace(code) ||\n      (code !== 45 /* `-` */ && unicodePunctuation(code))\n    ) {\n      return done(code)\n    }\n\n    effects.consume(code)\n    return domain\n  }\n\n  function punctuationContinuation(code) {\n    // `.`\n    if (code === 46) {\n      hasUnderscoreInLastLastSegment = hasUnderscoreInLastSegment\n      hasUnderscoreInLastSegment = undefined\n      effects.consume(code)\n      return domain\n    }\n\n    // `_`\n    if (code === 95) hasUnderscoreInLastSegment = true\n\n    effects.consume(code)\n    return domain\n  }\n\n  function done(code) {\n    if (!hasUnderscoreInLastLastSegment && !hasUnderscoreInLastSegment) {\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n\nfunction tokenizePath(effects, ok) {\n  var balance = 0\n\n  return inPath\n\n  function inPath(code) {\n    // `&`\n    if (code === 38) {\n      return effects.check(\n        namedCharacterReference,\n        ok,\n        continuedPunctuation\n      )(code)\n    }\n\n    // `(`\n    if (code === 40) {\n      balance++\n    }\n\n    // `)`\n    if (code === 41) {\n      return effects.check(\n        punctuation,\n        parenAtPathEnd,\n        continuedPunctuation\n      )(code)\n    }\n\n    if (pathEnd(code)) {\n      return ok(code)\n    }\n\n    if (trailingPunctuation(code)) {\n      return effects.check(punctuation, ok, continuedPunctuation)(code)\n    }\n\n    effects.consume(code)\n    return inPath\n  }\n\n  function continuedPunctuation(code) {\n    effects.consume(code)\n    return inPath\n  }\n\n  function parenAtPathEnd(code) {\n    balance--\n    return balance < 0 ? ok(code) : continuedPunctuation(code)\n  }\n}\n\nfunction tokenizeNamedCharacterReference(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    // Assume an ampersand.\n    effects.consume(code)\n    return inside\n  }\n\n  function inside(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return inside\n    }\n\n    // `;`\n    if (code === 59) {\n      effects.consume(code)\n      return after\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    // If the named character reference is followed by the end of the path, it\u2019s\n    // not continued punctuation.\n    return pathEnd(code) ? ok(code) : nok(code)\n  }\n}\n\nfunction tokenizePunctuation(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    // Always a valid trailing punctuation marker.\n    effects.consume(code)\n    return after\n  }\n\n  function after(code) {\n    // Check the next.\n    if (trailingPunctuation(code)) {\n      effects.consume(code)\n      return after\n    }\n\n    // If the punctuation marker is followed by the end of the path, it\u2019s not\n    // continued punctuation.\n    return pathEnd(code) ? ok(code) : nok(code)\n  }\n}\n\nfunction trailingPunctuation(code) {\n  return (\n    // `!`\n    code === 33 ||\n    // `\"`\n    code === 34 ||\n    // `'`\n    code === 39 ||\n    // `)`\n    code === 41 ||\n    // `*`\n    code === 42 ||\n    // `,`\n    code === 44 ||\n    // `.`\n    code === 46 ||\n    // `:`\n    code === 58 ||\n    // `;`\n    code === 59 ||\n    // `<`\n    code === 60 ||\n    // `?`\n    code === 63 ||\n    // `_`.\n    code === 95 ||\n    // `~`\n    code === 126\n  )\n}\n\nfunction pathEnd(code) {\n  return (\n    // EOF.\n    code === null ||\n    // CR, LF, CRLF, HT, VS.\n    code < 0 ||\n    // Space.\n    code === 32 ||\n    // `<`\n    code === 60\n  )\n}\n\nfunction gfmAtext(code) {\n  return (\n    code === 43 /* `+` */ ||\n    code === 45 /* `-` */ ||\n    code === 46 /* `.` */ ||\n    code === 95 /* `_` */ ||\n    asciiAlphanumeric(code)\n  )\n}\n\nfunction previousWww(code) {\n  return (\n    code === null ||\n    code < 0 ||\n    code === 32 /* ` ` */ ||\n    code === 40 /* `(` */ ||\n    code === 42 /* `*` */ ||\n    code === 95 /* `_` */ ||\n    code === 126 /* `~` */\n  )\n}\n\nfunction previousHttp(code) {\n  return code === null || !asciiAlpha(code)\n}\n\nfunction previousEmail(code) {\n  return code !== 47 /* `/` */ && previousHttp(code)\n}\n\nfunction previous(events) {\n  var index = events.length\n\n  while (index--) {\n    if (\n      (events[index][1].type === 'labelLink' ||\n        events[index][1].type === 'labelImage') &&\n      !events[index][1]._balanced\n    ) {\n      return true\n    }\n  }\n}\n", "module.exports = require('./syntax')\n", "module.exports = create\n\nvar classifyCharacter = require('micromark/dist/util/classify-character')\nvar chunkedSplice = require('micromark/dist/util/chunked-splice')\nvar resolveAll = require('micromark/dist/util/resolve-all')\nvar shallow = require('micromark/dist/util/shallow')\n\nfunction create(options) {\n  var settings = options || {}\n  var single = settings.singleTilde\n  var tokenizer = {\n    tokenize: tokenizeStrikethrough,\n    resolveAll: resolveAllStrikethrough\n  }\n\n  if (single === null || single === undefined) {\n    single = true\n  }\n\n  return {text: {126: tokenizer}, insideSpan: {null: tokenizer}}\n\n  // Take events and resolve strikethrough.\n  function resolveAllStrikethrough(events, context) {\n    var index = -1\n    var strikethrough\n    var text\n    var open\n    var nextEvents\n\n    // Walk through all events.\n    while (++index < events.length) {\n      // Find a token that can close.\n      if (\n        events[index][0] === 'enter' &&\n        events[index][1].type === 'strikethroughSequenceTemporary' &&\n        events[index][1]._close\n      ) {\n        open = index\n\n        // Now walk back to find an opener.\n        while (open--) {\n          // Find a token that can open the closer.\n          if (\n            events[open][0] === 'exit' &&\n            events[open][1].type === 'strikethroughSequenceTemporary' &&\n            events[open][1]._open &&\n            // If the sizes are the same:\n            events[index][1].end.offset - events[index][1].start.offset ===\n              events[open][1].end.offset - events[open][1].start.offset\n          ) {\n            events[index][1].type = 'strikethroughSequence'\n            events[open][1].type = 'strikethroughSequence'\n\n            strikethrough = {\n              type: 'strikethrough',\n              start: shallow(events[open][1].start),\n              end: shallow(events[index][1].end)\n            }\n\n            text = {\n              type: 'strikethroughText',\n              start: shallow(events[open][1].end),\n              end: shallow(events[index][1].start)\n            }\n\n            // Opening.\n            nextEvents = [\n              ['enter', strikethrough, context],\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context],\n              ['enter', text, context]\n            ]\n\n            // Between.\n            chunkedSplice(\n              nextEvents,\n              nextEvents.length,\n              0,\n              resolveAll(\n                context.parser.constructs.insideSpan.null,\n                events.slice(open + 1, index),\n                context\n              )\n            )\n\n            // Closing.\n            chunkedSplice(nextEvents, nextEvents.length, 0, [\n              ['exit', text, context],\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context],\n              ['exit', strikethrough, context]\n            ])\n\n            chunkedSplice(events, open - 1, index - open + 3, nextEvents)\n\n            index = open + nextEvents.length - 2\n            break\n          }\n        }\n      }\n    }\n\n    return removeRemainingSequences(events)\n  }\n\n  function removeRemainingSequences(events) {\n    var index = -1\n    var length = events.length\n\n    while (++index < length) {\n      if (events[index][1].type === 'strikethroughSequenceTemporary') {\n        events[index][1].type = 'data'\n      }\n    }\n\n    return events\n  }\n\n  function tokenizeStrikethrough(effects, ok, nok) {\n    var previous = this.previous\n    var events = this.events\n    var size = 0\n\n    return start\n\n    function start(code) {\n      if (\n        code !== 126 ||\n        (previous === 126 &&\n          events[events.length - 1][1].type !== 'characterEscape')\n      ) {\n        return nok(code)\n      }\n\n      effects.enter('strikethroughSequenceTemporary')\n      return more(code)\n    }\n\n    function more(code) {\n      var before = classifyCharacter(previous)\n      var token\n      var after\n\n      if (code === 126) {\n        // If this is the third marker, exit.\n        if (size > 1) return nok(code)\n        effects.consume(code)\n        size++\n        return more\n      }\n\n      if (size < 2 && !single) return nok(code)\n      token = effects.exit('strikethroughSequenceTemporary')\n      after = classifyCharacter(code)\n      token._open = !after || (after === 2 && before)\n      token._close = !before || (before === 2 && after)\n      return ok(code)\n    }\n  }\n}\n", "exports.flow = {\n  null: {tokenize: tokenizeTable, resolve: resolveTable, interruptible: true}\n}\n\nvar createSpace = require('micromark/dist/tokenize/factory-space')\n\nvar setextUnderlineMini = {tokenize: tokenizeSetextUnderlineMini, partial: true}\nvar nextPrefixedOrBlank = {tokenize: tokenizeNextPrefixedOrBlank, partial: true}\n\nfunction resolveTable(events, context) {\n  var length = events.length\n  var index = -1\n  var token\n  var inHead\n  var inDelimiterRow\n  var inRow\n  var cell\n  var content\n  var text\n  var contentStart\n  var contentEnd\n  var cellStart\n\n  while (++index < length) {\n    token = events[index][1]\n\n    if (inRow) {\n      if (token.type === 'temporaryTableCellContent') {\n        contentStart = contentStart || index\n        contentEnd = index\n      }\n\n      if (\n        // Combine separate content parts into one.\n        (token.type === 'tableCellDivider' || token.type === 'tableRow') &&\n        contentEnd\n      ) {\n        content = {\n          type: 'tableContent',\n          start: events[contentStart][1].start,\n          end: events[contentEnd][1].end\n        }\n        text = {\n          type: 'chunkText',\n          start: content.start,\n          end: content.end,\n          contentType: 'text'\n        }\n\n        events.splice(\n          contentStart,\n          contentEnd - contentStart + 1,\n          ['enter', content, context],\n          ['enter', text, context],\n          ['exit', text, context],\n          ['exit', content, context]\n        )\n        index -= contentEnd - contentStart - 3\n        length = events.length\n        contentStart = undefined\n        contentEnd = undefined\n      }\n    }\n\n    if (\n      events[index][0] === 'exit' &&\n      cellStart &&\n      cellStart + 1 < index &&\n      (token.type === 'tableCellDivider' ||\n        (token.type === 'tableRow' &&\n          (cellStart + 3 < index ||\n            events[cellStart][1].type !== 'whitespace')))\n    ) {\n      cell = {\n        type: inDelimiterRow\n          ? 'tableDelimiter'\n          : inHead\n          ? 'tableHeader'\n          : 'tableData',\n        start: events[cellStart][1].start,\n        end: events[index][1].end\n      }\n      events.splice(index + (token.type === 'tableCellDivider' ? 1 : 0), 0, [\n        'exit',\n        cell,\n        context\n      ])\n      events.splice(cellStart, 0, ['enter', cell, context])\n      index += 2\n      length = events.length\n      cellStart = index + 1\n    }\n\n    if (token.type === 'tableRow') {\n      inRow = events[index][0] === 'enter'\n\n      if (inRow) {\n        cellStart = index + 1\n      }\n    }\n\n    if (token.type === 'tableDelimiterRow') {\n      inDelimiterRow = events[index][0] === 'enter'\n\n      if (inDelimiterRow) {\n        cellStart = index + 1\n      }\n    }\n\n    if (token.type === 'tableHead') {\n      inHead = events[index][0] === 'enter'\n    }\n  }\n\n  return events\n}\n\nfunction tokenizeTable(effects, ok, nok) {\n  var align = []\n  var tableHeaderCount = 0\n  var seenDelimiter\n  var hasDash\n\n  return start\n\n  function start(code) {\n    /* istanbul ignore if - used to be passed in beta micromark versions. */\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return nok(code)\n    }\n\n    effects.enter('table')._align = align\n    effects.enter('tableHead')\n    effects.enter('tableRow')\n\n    // If we start with a pipe, we open a cell marker.\n    if (code === 124) {\n      return cellDividerHead(code)\n    }\n\n    tableHeaderCount++\n    effects.enter('temporaryTableCellContent')\n    // Can\u2019t be space or eols at the start of a construct, so we\u2019re in a cell.\n    return inCellContentHead(code)\n  }\n\n  function cellDividerHead(code) {\n    // Always a pipe.\n    effects.enter('tableCellDivider')\n    effects.consume(code)\n    effects.exit('tableCellDivider')\n    seenDelimiter = true\n    return cellBreakHead\n  }\n\n  function cellBreakHead(code) {\n    // EOF, CR, LF, CRLF.\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return atRowEndHead(code)\n    }\n\n    // HT, VS, SP.\n    if (code === -2 || code === -1 || code === 32) {\n      effects.enter('whitespace')\n      effects.consume(code)\n      return inWhitespaceHead\n    }\n\n    if (seenDelimiter) {\n      seenDelimiter = undefined\n      tableHeaderCount++\n    }\n\n    // `|`\n    if (code === 124) {\n      return cellDividerHead(code)\n    }\n\n    // Anything else is cell content.\n    effects.enter('temporaryTableCellContent')\n    return inCellContentHead(code)\n  }\n\n  function inWhitespaceHead(code) {\n    // HT, VS, SP.\n    if (code === -2 || code === -1 || code === 32) {\n      effects.consume(code)\n      return inWhitespaceHead\n    }\n\n    effects.exit('whitespace')\n    return cellBreakHead(code)\n  }\n\n  function inCellContentHead(code) {\n    // EOF, whitespace, pipe\n    if (code === null || code < 0 || code === 32 || code === 124) {\n      effects.exit('temporaryTableCellContent')\n      return cellBreakHead(code)\n    }\n\n    effects.consume(code)\n    // `\\`\n    return code === 92 ? inCellContentEscapeHead : inCellContentHead\n  }\n\n  function inCellContentEscapeHead(code) {\n    // `\\` or `|`\n    if (code === 92 || code === 124) {\n      effects.consume(code)\n      return inCellContentHead\n    }\n\n    // Anything else.\n    return inCellContentHead(code)\n  }\n\n  function atRowEndHead(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    effects.exit('tableRow')\n    effects.exit('tableHead')\n\n    // Always a line ending.\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n\n    // If a setext heading, exit.\n    return effects.check(\n      setextUnderlineMini,\n      nok,\n      // Support an indent before the delimiter row.\n      createSpace(effects, rowStartDelimiter, 'linePrefix', 4)\n    )\n  }\n\n  function rowStartDelimiter(code) {\n    // If there\u2019s another space, or we\u2019re at the EOL/EOF, exit.\n    if (code === null || code < 0 || code === 32) {\n      return nok(code)\n    }\n\n    effects.enter('tableDelimiterRow')\n    return atDelimiterRowBreak(code)\n  }\n\n  function atDelimiterRowBreak(code) {\n    // EOF, CR, LF, CRLF.\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return rowEndDelimiter(code)\n    }\n\n    // HT, VS, SP.\n    if (code === -2 || code === -1 || code === 32) {\n      effects.enter('whitespace')\n      effects.consume(code)\n      return inWhitespaceDelimiter\n    }\n\n    // `-`\n    if (code === 45) {\n      effects.enter('tableDelimiterFiller')\n      effects.consume(code)\n      hasDash = true\n      align.push(null)\n      return inFillerDelimiter\n    }\n\n    // `:`\n    if (code === 58) {\n      effects.enter('tableDelimiterAlignment')\n      effects.consume(code)\n      effects.exit('tableDelimiterAlignment')\n      align.push('left')\n      return afterLeftAlignment\n    }\n\n    // If we start with a pipe, we open a cell marker.\n    if (code === 124) {\n      effects.enter('tableCellDivider')\n      effects.consume(code)\n      effects.exit('tableCellDivider')\n      return atDelimiterRowBreak\n    }\n\n    return nok(code)\n  }\n\n  function inWhitespaceDelimiter(code) {\n    // HT, VS, SP.\n    if (code === -2 || code === -1 || code === 32) {\n      effects.consume(code)\n      return inWhitespaceDelimiter\n    }\n\n    effects.exit('whitespace')\n    return atDelimiterRowBreak(code)\n  }\n\n  function inFillerDelimiter(code) {\n    // `-`\n    if (code === 45) {\n      effects.consume(code)\n      return inFillerDelimiter\n    }\n\n    effects.exit('tableDelimiterFiller')\n\n    // `:`\n    if (code === 58) {\n      effects.enter('tableDelimiterAlignment')\n      effects.consume(code)\n      effects.exit('tableDelimiterAlignment')\n\n      align[align.length - 1] =\n        align[align.length - 1] === 'left' ? 'center' : 'right'\n\n      return afterRightAlignment\n    }\n\n    return atDelimiterRowBreak(code)\n  }\n\n  function afterLeftAlignment(code) {\n    // `-`\n    if (code === 45) {\n      effects.enter('tableDelimiterFiller')\n      effects.consume(code)\n      hasDash = true\n      return inFillerDelimiter\n    }\n\n    // Anything else is not ok.\n    return nok(code)\n  }\n\n  function afterRightAlignment(code) {\n    // EOF, CR, LF, CRLF.\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return rowEndDelimiter(code)\n    }\n\n    // HT, VS, SP.\n    if (code === -2 || code === -1 || code === 32) {\n      effects.enter('whitespace')\n      effects.consume(code)\n      return inWhitespaceDelimiter\n    }\n\n    // `|`\n    if (code === 124) {\n      effects.enter('tableCellDivider')\n      effects.consume(code)\n      effects.exit('tableCellDivider')\n      return atDelimiterRowBreak\n    }\n\n    return nok(code)\n  }\n\n  function rowEndDelimiter(code) {\n    effects.exit('tableDelimiterRow')\n\n    // Exit if there was no dash at all, or if the header cell count is not the\n    // delimiter cell count.\n    if (!hasDash || tableHeaderCount !== align.length) {\n      return nok(code)\n    }\n\n    if (code === null) {\n      return tableClose(code)\n    }\n\n    return effects.check(nextPrefixedOrBlank, tableClose, tableContinue)(code)\n  }\n\n  function tableClose(code) {\n    effects.exit('table')\n    return ok(code)\n  }\n\n  function tableContinue(code) {\n    // Always a line ending.\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    // We checked that it\u2019s not a prefixed or blank line, so we\u2019re certain a\n    // body is coming, though it may be indented.\n    return createSpace(effects, bodyStart, 'linePrefix', 4)\n  }\n\n  function bodyStart(code) {\n    effects.enter('tableBody')\n    return rowStartBody(code)\n  }\n\n  function rowStartBody(code) {\n    effects.enter('tableRow')\n\n    // If we start with a pipe, we open a cell marker.\n    if (code === 124) {\n      return cellDividerBody(code)\n    }\n\n    effects.enter('temporaryTableCellContent')\n    // Can\u2019t be space or eols at the start of a construct, so we\u2019re in a cell.\n    return inCellContentBody(code)\n  }\n\n  function cellDividerBody(code) {\n    // Always a pipe.\n    effects.enter('tableCellDivider')\n    effects.consume(code)\n    effects.exit('tableCellDivider')\n    return cellBreakBody\n  }\n\n  function cellBreakBody(code) {\n    // EOF, CR, LF, CRLF.\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return atRowEndBody(code)\n    }\n\n    // HT, VS, SP.\n    if (code === -2 || code === -1 || code === 32) {\n      effects.enter('whitespace')\n      effects.consume(code)\n      return inWhitespaceBody\n    }\n\n    // `|`\n    if (code === 124) {\n      return cellDividerBody(code)\n    }\n\n    // Anything else is cell content.\n    effects.enter('temporaryTableCellContent')\n    return inCellContentBody(code)\n  }\n\n  function inWhitespaceBody(code) {\n    // HT, VS, SP.\n    if (code === -2 || code === -1 || code === 32) {\n      effects.consume(code)\n      return inWhitespaceBody\n    }\n\n    effects.exit('whitespace')\n    return cellBreakBody(code)\n  }\n\n  function inCellContentBody(code) {\n    // EOF, whitespace, pipe\n    if (code === null || code < 0 || code === 32 || code === 124) {\n      effects.exit('temporaryTableCellContent')\n      return cellBreakBody(code)\n    }\n\n    effects.consume(code)\n    // `\\`\n    return code === 92 ? inCellContentEscapeBody : inCellContentBody\n  }\n\n  function inCellContentEscapeBody(code) {\n    // `\\` or `|`\n    if (code === 92 || code === 124) {\n      effects.consume(code)\n      return inCellContentBody\n    }\n\n    // Anything else.\n    return inCellContentBody(code)\n  }\n\n  function atRowEndBody(code) {\n    effects.exit('tableRow')\n\n    if (code === null) {\n      return tableBodyClose(code)\n    }\n\n    return effects.check(\n      nextPrefixedOrBlank,\n      tableBodyClose,\n      tableBodyContinue\n    )(code)\n  }\n\n  function tableBodyClose(code) {\n    effects.exit('tableBody')\n    return tableClose(code)\n  }\n\n  function tableBodyContinue(code) {\n    // Always a line ending.\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    // Support an optional prefix, then start a body row.\n    return createSpace(effects, rowStartBody, 'linePrefix', 4)\n  }\n}\n\n// Based on micromark, but that won\u2019t work as we\u2019re in a table, and that expects\n// content.\n// <https://github.com/micromark/micromark/blob/main/lib/tokenize/setext-underline.js>\nfunction tokenizeSetextUnderlineMini(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    // `-`\n    if (code !== 45) {\n      return nok(code)\n    }\n\n    effects.enter('setextUnderline')\n    return sequence(code)\n  }\n\n  function sequence(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return sequence\n    }\n\n    return whitespace(code)\n  }\n\n  function whitespace(code) {\n    if (code === -2 || code === -1 || code === 32) {\n      effects.consume(code)\n      return whitespace\n    }\n\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n\nfunction tokenizeNextPrefixedOrBlank(effects, ok, nok) {\n  var size = 0\n\n  return start\n\n  function start(code) {\n    // This is a check, so we don\u2019t care about tokens, but we open a bogus one\n    // so we\u2019re valid.\n    effects.enter('check')\n    // EOL.\n    effects.consume(code)\n    return whitespace\n  }\n\n  function whitespace(code) {\n    // VS or SP.\n    if (code === -1 || code === 32) {\n      effects.consume(code)\n      size++\n      return size === 4 ? ok : whitespace\n    }\n\n    // EOF or whitespace\n    if (code === null || code < 0) {\n      return ok(code)\n    }\n\n    // Anything else.\n    return nok(code)\n  }\n}\n", "module.exports = require('./syntax')\n", "var markdownLineEndingOrSpace = require('micromark/dist/character/markdown-line-ending-or-space')\nvar spaceFactory = require('micromark/dist/tokenize/factory-space')\nvar prefixSize = require('micromark/dist/util/prefix-size')\n\nvar tasklistCheck = {tokenize: tokenizeTasklistCheck}\n\nexports.text = {91: tasklistCheck}\n\nfunction tokenizeTasklistCheck(effects, ok, nok) {\n  var self = this\n\n  return open\n\n  function open(code) {\n    if (\n      // Exit if not `[`.\n      code !== 91 ||\n      // Exit if there\u2019s stuff before.\n      self.previous !== null ||\n      // Exit if not in the first content that is the first child of a list\n      // item.\n      !self._gfmTasklistFirstContentOfListItem\n    ) {\n      return nok(code)\n    }\n\n    effects.enter('taskListCheck')\n    effects.enter('taskListCheckMarker')\n    effects.consume(code)\n    effects.exit('taskListCheckMarker')\n    return inside\n  }\n\n  function inside(code) {\n    // Tab or space.\n    if (code === -2 || code === 32) {\n      effects.enter('taskListCheckValueUnchecked')\n      effects.consume(code)\n      effects.exit('taskListCheckValueUnchecked')\n      return close\n    }\n\n    // Upper- and lower `x`.\n    if (code === 88 || code === 120) {\n      effects.enter('taskListCheckValueChecked')\n      effects.consume(code)\n      effects.exit('taskListCheckValueChecked')\n      return close\n    }\n\n    return nok(code)\n  }\n\n  function close(code) {\n    // `]`\n    if (code === 93) {\n      effects.enter('taskListCheckMarker')\n      effects.consume(code)\n      effects.exit('taskListCheckMarker')\n      effects.exit('taskListCheck')\n      return effects.check({tokenize: spaceThenNonSpace}, ok, nok)\n    }\n\n    return nok(code)\n  }\n}\n\nfunction spaceThenNonSpace(effects, ok, nok) {\n  var self = this\n\n  return spaceFactory(effects, after, 'whitespace')\n\n  function after(code) {\n    return prefixSize(self.events, 'whitespace') &&\n      code !== null &&\n      !markdownLineEndingOrSpace(code)\n      ? ok(code)\n      : nok(code)\n  }\n}\n", "module.exports = require('./syntax')\n", "var combine = require('micromark/dist/util/combine-extensions')\nvar autolink = require('micromark-extension-gfm-autolink-literal')\nvar strikethrough = require('micromark-extension-gfm-strikethrough')\nvar table = require('micromark-extension-gfm-table')\nvar tasklist = require('micromark-extension-gfm-task-list-item')\n\nmodule.exports = create\n\nfunction create(options) {\n  return combine([autolink, strikethrough(options), table, tasklist])\n}\n", "module.exports = require('./syntax')\n", "'use strict'\n\nmodule.exports = ccount\n\nfunction ccount(source, character) {\n  var value = String(source)\n  var count = 0\n  var index\n\n  if (typeof character !== 'string') {\n    throw new Error('Expected character')\n  }\n\n  index = value.indexOf(character)\n\n  while (index !== -1) {\n    count++\n    index = value.indexOf(character, index + character.length)\n  }\n\n  return count\n}\n", "'use strict'\n\nmodule.exports = convert\n\nfunction convert(test) {\n  if (test == null) {\n    return ok\n  }\n\n  if (typeof test === 'string') {\n    return typeFactory(test)\n  }\n\n  if (typeof test === 'object') {\n    return 'length' in test ? anyFactory(test) : allFactory(test)\n  }\n\n  if (typeof test === 'function') {\n    return test\n  }\n\n  throw new Error('Expected function, string, or object as test')\n}\n\n// Utility assert each property in `test` is represented in `node`, and each\n// values are strictly equal.\nfunction allFactory(test) {\n  return all\n\n  function all(node) {\n    var key\n\n    for (key in test) {\n      if (node[key] !== test[key]) return false\n    }\n\n    return true\n  }\n}\n\nfunction anyFactory(tests) {\n  var checks = []\n  var index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index])\n  }\n\n  return any\n\n  function any() {\n    var index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, arguments)) {\n        return true\n      }\n    }\n\n    return false\n  }\n}\n\n// Utility to convert a string into a function which checks a given node\u2019s type\n// for said string.\nfunction typeFactory(test) {\n  return type\n\n  function type(node) {\n    return Boolean(node && node.type === test)\n  }\n}\n\n// Utility to return true.\nfunction ok() {\n  return true\n}\n", "module.exports = identity\nfunction identity(d) {\n  return d\n}\n", "'use strict'\n\nmodule.exports = visitParents\n\nvar convert = require('unist-util-is/convert')\nvar color = require('./color')\n\nvar CONTINUE = true\nvar SKIP = 'skip'\nvar EXIT = false\n\nvisitParents.CONTINUE = CONTINUE\nvisitParents.SKIP = SKIP\nvisitParents.EXIT = EXIT\n\nfunction visitParents(tree, test, visitor, reverse) {\n  var step\n  var is\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    visitor = test\n    test = null\n  }\n\n  is = convert(test)\n  step = reverse ? -1 : 1\n\n  factory(tree, null, [])()\n\n  function factory(node, index, parents) {\n    var value = typeof node === 'object' && node !== null ? node : {}\n    var name\n\n    if (typeof value.type === 'string') {\n      name =\n        typeof value.tagName === 'string'\n          ? value.tagName\n          : typeof value.name === 'string'\n          ? value.name\n          : undefined\n\n      visit.displayName =\n        'node (' + color(value.type + (name ? '<' + name + '>' : '')) + ')'\n    }\n\n    return visit\n\n    function visit() {\n      var grandparents = parents.concat(node)\n      var result = []\n      var subresult\n      var offset\n\n      if (!test || is(node, index, parents[parents.length - 1] || null)) {\n        result = toResult(visitor(node, parents))\n\n        if (result[0] === EXIT) {\n          return result\n        }\n      }\n\n      if (node.children && result[0] !== SKIP) {\n        offset = (reverse ? node.children.length : -1) + step\n\n        while (offset > -1 && offset < node.children.length) {\n          subresult = factory(node.children[offset], offset, grandparents)()\n\n          if (subresult[0] === EXIT) {\n            return subresult\n          }\n\n          offset =\n            typeof subresult[1] === 'number' ? subresult[1] : offset + step\n        }\n      }\n\n      return result\n    }\n  }\n}\n\nfunction toResult(value) {\n  if (value !== null && typeof value === 'object' && 'length' in value) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return [value]\n}\n", "'use strict';\n\nmodule.exports = string => {\n\tif (typeof string !== 'string') {\n\t\tthrow new TypeError('Expected a string');\n\t}\n\n\t// Escape characters with special meaning either inside or outside character sets.\n\t// Use a simple backslash escape when it\u2019s always valid, and a \\unnnn escape when the simpler form would be disallowed by Unicode patterns\u2019 stricter grammar.\n\treturn string\n\t\t.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&')\n\t\t.replace(/-/g, '\\\\x2d');\n};\n", "'use strict'\n\nmodule.exports = findAndReplace\n\nvar visit = require('unist-util-visit-parents')\nvar convert = require('unist-util-is/convert')\nvar escape = require('escape-string-regexp')\n\nvar splice = [].splice\n\nfunction findAndReplace(tree, find, replace, options) {\n  var settings\n  var schema\n\n  if (typeof find === 'string' || (find && typeof find.exec === 'function')) {\n    schema = [[find, replace]]\n  } else {\n    schema = find\n    options = replace\n  }\n\n  settings = options || {}\n\n  search(tree, settings, handlerFactory(toPairs(schema)))\n\n  return tree\n\n  function handlerFactory(pairs) {\n    var pair = pairs[0]\n\n    return handler\n\n    function handler(node, parent) {\n      var find = pair[0]\n      var replace = pair[1]\n      var nodes = []\n      var start = 0\n      var index = parent.children.indexOf(node)\n      var position\n      var match\n      var subhandler\n      var value\n\n      find.lastIndex = 0\n\n      match = find.exec(node.value)\n\n      while (match) {\n        position = match.index\n        value = replace.apply(\n          null,\n          [].concat(match, {index: match.index, input: match.input})\n        )\n\n        if (value !== false) {\n          if (start !== position) {\n            nodes.push({type: 'text', value: node.value.slice(start, position)})\n          }\n\n          if (typeof value === 'string' && value.length > 0) {\n            value = {type: 'text', value: value}\n          }\n\n          if (value) {\n            nodes = [].concat(nodes, value)\n          }\n\n          start = position + match[0].length\n        }\n\n        if (!find.global) {\n          break\n        }\n\n        match = find.exec(node.value)\n      }\n\n      if (position === undefined) {\n        nodes = [node]\n        index--\n      } else {\n        if (start < node.value.length) {\n          nodes.push({type: 'text', value: node.value.slice(start)})\n        }\n\n        nodes.unshift(index, 1)\n        splice.apply(parent.children, nodes)\n      }\n\n      if (pairs.length > 1) {\n        subhandler = handlerFactory(pairs.slice(1))\n        position = -1\n\n        while (++position < nodes.length) {\n          node = nodes[position]\n\n          if (node.type === 'text') {\n            subhandler(node, parent)\n          } else {\n            search(node, settings, subhandler)\n          }\n        }\n      }\n\n      return index + nodes.length + 1\n    }\n  }\n}\n\nfunction search(tree, settings, handler) {\n  var ignored = convert(settings.ignore || [])\n  var result = []\n\n  visit(tree, 'text', visitor)\n\n  return result\n\n  function visitor(node, parents) {\n    var index = -1\n    var parent\n    var grandparent\n\n    while (++index < parents.length) {\n      parent = parents[index]\n\n      if (\n        ignored(\n          parent,\n          grandparent ? grandparent.children.indexOf(parent) : undefined,\n          grandparent\n        )\n      ) {\n        return\n      }\n\n      grandparent = parent\n    }\n\n    return handler(node, grandparent)\n  }\n}\n\nfunction toPairs(schema) {\n  var result = []\n  var key\n  var index\n\n  if (typeof schema !== 'object') {\n    throw new Error('Expected array or object as schema')\n  }\n\n  if ('length' in schema) {\n    index = -1\n\n    while (++index < schema.length) {\n      result.push([\n        toExpression(schema[index][0]),\n        toFunction(schema[index][1])\n      ])\n    }\n  } else {\n    for (key in schema) {\n      result.push([toExpression(key), toFunction(schema[key])])\n    }\n  }\n\n  return result\n}\n\nfunction toExpression(find) {\n  return typeof find === 'string' ? new RegExp(escape(find), 'g') : find\n}\n\nfunction toFunction(replace) {\n  return typeof replace === 'function' ? replace : returner\n\n  function returner() {\n    return replace\n  }\n}\n", "var ccount = require('ccount')\nvar findAndReplace = require('mdast-util-find-and-replace')\nvar unicodePunctuation = require('micromark/dist/character/unicode-punctuation')\nvar unicodeWhitespace = require('micromark/dist/character/unicode-whitespace')\n\nexports.transforms = [transformGfmAutolinkLiterals]\nexports.enter = {\n  literalAutolink: enterLiteralAutolink,\n  literalAutolinkEmail: enterLiteralAutolinkValue,\n  literalAutolinkHttp: enterLiteralAutolinkValue,\n  literalAutolinkWww: enterLiteralAutolinkValue\n}\nexports.exit = {\n  literalAutolink: exitLiteralAutolink,\n  literalAutolinkEmail: exitLiteralAutolinkEmail,\n  literalAutolinkHttp: exitLiteralAutolinkHttp,\n  literalAutolinkWww: exitLiteralAutolinkWww\n}\n\nfunction enterLiteralAutolink(token) {\n  this.enter({type: 'link', title: null, url: '', children: []}, token)\n}\n\nfunction enterLiteralAutolinkValue(token) {\n  this.config.enter.autolinkProtocol.call(this, token)\n}\n\nfunction exitLiteralAutolinkHttp(token) {\n  this.config.exit.autolinkProtocol.call(this, token)\n}\n\nfunction exitLiteralAutolinkWww(token) {\n  this.config.exit.data.call(this, token)\n  this.stack[this.stack.length - 1].url = 'http://' + this.sliceSerialize(token)\n}\n\nfunction exitLiteralAutolinkEmail(token) {\n  this.config.exit.autolinkEmail.call(this, token)\n}\n\nfunction exitLiteralAutolink(token) {\n  this.exit(token)\n}\n\nfunction transformGfmAutolinkLiterals(tree) {\n  findAndReplace(\n    tree,\n    [\n      [/(https?:\\/\\/|www(?=\\.))([-.\\w]+)([^ \\t\\r\\n]*)/i, findUrl],\n      [/([-.\\w+]+)@([-\\w]+(?:\\.[-\\w]+)+)/, findEmail]\n    ],\n    {ignore: ['link', 'linkReference']}\n  )\n}\n\nfunction findUrl($0, protocol, domain, path, match) {\n  var prefix = ''\n  var parts\n  var result\n\n  // Not an expected previous character.\n  if (!previous(match)) {\n    return false\n  }\n\n  // Treat `www` as part of the domain.\n  if (/^w/i.test(protocol)) {\n    domain = protocol + domain\n    protocol = ''\n    prefix = 'http://'\n  }\n\n  if (!isCorrectDomain(domain)) {\n    return false\n  }\n\n  parts = splitUrl(domain + path)\n\n  if (!parts[0]) return false\n\n  result = {\n    type: 'link',\n    title: null,\n    url: prefix + protocol + parts[0],\n    children: [{type: 'text', value: protocol + parts[0]}]\n  }\n\n  if (parts[1]) {\n    result = [result, {type: 'text', value: parts[1]}]\n  }\n\n  return result\n}\n\nfunction findEmail($0, atext, label, match) {\n  // Not an expected previous character.\n  if (!previous(match, true) || /[_-]$/.test(label)) {\n    return false\n  }\n\n  return {\n    type: 'link',\n    title: null,\n    url: 'mailto:' + atext + '@' + label,\n    children: [{type: 'text', value: atext + '@' + label}]\n  }\n}\n\nfunction isCorrectDomain(domain) {\n  var parts = domain.split('.')\n\n  if (\n    parts.length < 2 ||\n    (parts[parts.length - 1] &&\n      (/_/.test(parts[parts.length - 1]) ||\n        !/[a-zA-Z\\d]/.test(parts[parts.length - 1]))) ||\n    (parts[parts.length - 2] &&\n      (/_/.test(parts[parts.length - 2]) ||\n        !/[a-zA-Z\\d]/.test(parts[parts.length - 2])))\n  ) {\n    return false\n  }\n\n  return true\n}\n\nfunction splitUrl(url) {\n  var trail = /[!\"&'),.:;<>?\\]}]+$/.exec(url)\n  var closingParenIndex\n  var openingParens\n  var closingParens\n\n  if (trail) {\n    url = url.slice(0, trail.index)\n    trail = trail[0]\n    closingParenIndex = trail.indexOf(')')\n    openingParens = ccount(url, '(')\n    closingParens = ccount(url, ')')\n\n    while (closingParenIndex !== -1 && openingParens > closingParens) {\n      url += trail.slice(0, closingParenIndex + 1)\n      trail = trail.slice(closingParenIndex + 1)\n      closingParenIndex = trail.indexOf(')')\n      closingParens++\n    }\n  }\n\n  return [url, trail]\n}\n\nfunction previous(match, email) {\n  var code = match.input.charCodeAt(match.index - 1)\n  return (\n    (code !== code || unicodeWhitespace(code) || unicodePunctuation(code)) &&\n    (!email || code !== 47)\n  )\n}\n", "exports.canContainEols = ['delete']\nexports.enter = {strikethrough: enterStrikethrough}\nexports.exit = {strikethrough: exitStrikethrough}\n\nfunction enterStrikethrough(token) {\n  this.enter({type: 'delete', children: []}, token)\n}\n\nfunction exitStrikethrough(token) {\n  this.exit(token)\n}\n", "exports.enter = {\n  table: enterTable,\n  tableData: enterCell,\n  tableHeader: enterCell,\n  tableRow: enterRow\n}\nexports.exit = {\n  codeText: exitCodeText,\n  table: exitTable,\n  tableData: exit,\n  tableHeader: exit,\n  tableRow: exit\n}\n\nfunction enterTable(token) {\n  this.enter({type: 'table', align: token._align, children: []}, token)\n  this.setData('inTable', true)\n}\n\nfunction exitTable(token) {\n  this.exit(token)\n  this.setData('inTable')\n}\n\nfunction enterRow(token) {\n  this.enter({type: 'tableRow', children: []}, token)\n}\n\nfunction exit(token) {\n  this.exit(token)\n}\n\nfunction enterCell(token) {\n  this.enter({type: 'tableCell', children: []}, token)\n}\n\n// Overwrite the default code text data handler to unescape escaped pipes when\n// they are in tables.\nfunction exitCodeText(token) {\n  var value = this.resume()\n\n  if (this.getData('inTable')) {\n    value = value.replace(/\\\\([\\\\|])/g, replace)\n  }\n\n  this.stack[this.stack.length - 1].value = value\n  this.exit(token)\n}\n\nfunction replace($0, $1) {\n  // Pipes work, backslashes don\u2019t (but can\u2019t escape pipes).\n  return $1 === '|' ? $1 : $0\n}\n", "exports.exit = {\n  taskListCheckValueChecked: exitCheck,\n  taskListCheckValueUnchecked: exitCheck,\n  paragraph: exitParagraphWithTaskListItem\n}\n\nfunction exitCheck(token) {\n  // We\u2019re always in a paragraph, in a list item.\n  this.stack[this.stack.length - 2].checked =\n    token.type === 'taskListCheckValueChecked'\n}\n\nfunction exitParagraphWithTaskListItem(token) {\n  var parent = this.stack[this.stack.length - 2]\n  var node = this.stack[this.stack.length - 1]\n  var siblings = parent.children\n  var head = node.children[0]\n  var index = -1\n  var firstParaghraph\n\n  if (\n    parent &&\n    parent.type === 'listItem' &&\n    typeof parent.checked === 'boolean' &&\n    head &&\n    head.type === 'text'\n  ) {\n    while (++index < siblings.length) {\n      if (siblings[index].type === 'paragraph') {\n        firstParaghraph = siblings[index]\n        break\n      }\n    }\n\n    if (firstParaghraph === node) {\n      // Must start with a space or a tab.\n      head.value = head.value.slice(1)\n\n      if (head.value.length === 0) {\n        node.children.shift()\n      } else {\n        head.position.start.column++\n        head.position.start.offset++\n        node.position.start = Object.assign({}, head.position.start)\n      }\n    }\n  }\n\n  this.exit(token)\n}\n", "var autolinkLiteral = require('mdast-util-gfm-autolink-literal/from-markdown')\nvar strikethrough = require('mdast-util-gfm-strikethrough/from-markdown')\nvar table = require('mdast-util-gfm-table/from-markdown')\nvar taskListItem = require('mdast-util-gfm-task-list-item/from-markdown')\n\nvar own = {}.hasOwnProperty\n\nmodule.exports = configure([\n  autolinkLiteral,\n  strikethrough,\n  table,\n  taskListItem\n])\n\nfunction configure(extensions) {\n  var config = {transforms: [], canContainEols: []}\n  var length = extensions.length\n  var index = -1\n\n  while (++index < length) {\n    extension(config, extensions[index])\n  }\n\n  return config\n}\n\nfunction extension(config, extension) {\n  var key\n  var left\n  var right\n\n  for (key in extension) {\n    left = own.call(config, key) ? config[key] : (config[key] = {})\n    right = extension[key]\n\n    if (key === 'canContainEols' || key === 'transforms') {\n      config[key] = [].concat(left, right)\n    } else {\n      Object.assign(left, right)\n    }\n  }\n}\n", "var inConstruct = 'phrasing'\nvar notInConstruct = ['autolink', 'link', 'image', 'label']\n\nexports.unsafe = [\n  {\n    character: '@',\n    before: '[+\\\\-.\\\\w]',\n    after: '[\\\\-.\\\\w]',\n    inConstruct: inConstruct,\n    notInConstruct: notInConstruct\n  },\n  {\n    character: '.',\n    before: '[Ww]',\n    after: '[\\\\-.\\\\w]',\n    inConstruct: inConstruct,\n    notInConstruct: notInConstruct\n  },\n  {\n    character: ':',\n    before: '[ps]',\n    after: '\\\\/',\n    inConstruct: inConstruct,\n    notInConstruct: notInConstruct\n  }\n]\n", "module.exports = phrasing\n\nfunction phrasing(parent, context, safeOptions) {\n  var children = parent.children || []\n  var results = []\n  var index = -1\n  var before = safeOptions.before\n  var after\n  var handle\n  var child\n\n  while (++index < children.length) {\n    child = children[index]\n\n    if (index + 1 < children.length) {\n      handle = context.handle.handlers[children[index + 1].type]\n      if (handle && handle.peek) handle = handle.peek\n      after = handle\n        ? handle(children[index + 1], parent, context, {\n            before: '',\n            after: ''\n          }).charAt(0)\n        : ''\n    } else {\n      after = safeOptions.after\n    }\n\n    // In some cases, html (text) can be found in phrasing right after an eol.\n    // When we\u2019d serialize that, in most cases that would be seen as html\n    // (flow).\n    // As we can\u2019t escape or so to prevent it from happening, we take a somewhat\n    // reasonable approach: replace that eol with a space.\n    // See: <https://github.com/syntax-tree/mdast-util-to-markdown/issues/15>\n    if (\n      results.length > 0 &&\n      (before === '\\r' || before === '\\n') &&\n      child.type === 'html'\n    ) {\n      results[results.length - 1] = results[results.length - 1].replace(\n        /(\\r?\\n|\\r)$/,\n        ' '\n      )\n      before = ' '\n    }\n\n    results.push(\n      context.handle(child, parent, context, {\n        before: before,\n        after: after\n      })\n    )\n\n    before = results[results.length - 1].slice(-1)\n  }\n\n  return results.join('')\n}\n", "var phrasing = require('mdast-util-to-markdown/lib/util/container-phrasing')\n\nexports.unsafe = [{character: '~', inConstruct: 'phrasing'}]\nexports.handlers = {delete: handleDelete}\n\nhandleDelete.peek = peekDelete\n\nfunction handleDelete(node, _, context) {\n  var exit = context.enter('emphasis')\n  var value = phrasing(node, context, {before: '~', after: '~'})\n  exit()\n  return '~~' + value + '~~'\n}\n\nfunction peekDelete() {\n  return '~'\n}\n", "module.exports = patternCompile\n\nfunction patternCompile(pattern) {\n  var before\n  var after\n\n  if (!pattern._compiled) {\n    before = pattern.before ? '(?:' + pattern.before + ')' : ''\n    after = pattern.after ? '(?:' + pattern.after + ')' : ''\n\n    if (pattern.atBreak) {\n      before = '[\\\\r\\\\n][\\\\t ]*' + before\n    }\n\n    pattern._compiled = new RegExp(\n      (before ? '(' + before + ')' : '') +\n        (/[|\\\\{}()[\\]^$+*?.-]/.test(pattern.character) ? '\\\\' : '') +\n        pattern.character +\n        (after || ''),\n      'g'\n    )\n  }\n\n  return pattern._compiled\n}\n", "module.exports = inlineCode\ninlineCode.peek = inlineCodePeek\n\nvar patternCompile = require('../util/pattern-compile')\n\nfunction inlineCode(node, parent, context) {\n  var value = node.value || ''\n  var sequence = '`'\n  var index = -1\n  var pattern\n  var expression\n  var match\n  var position\n\n  // If there is a single grave accent on its own in the code, use a fence of\n  // two.\n  // If there are two in a row, use one.\n  while (new RegExp('(^|[^`])' + sequence + '([^`]|$)').test(value)) {\n    sequence += '`'\n  }\n\n  // If this is not just spaces or eols (tabs don\u2019t count), and either the\n  // first or last character are a space, eol, or tick, then pad with spaces.\n  if (\n    /[^ \\r\\n]/.test(value) &&\n    (/[ \\r\\n`]/.test(value.charAt(0)) ||\n      /[ \\r\\n`]/.test(value.charAt(value.length - 1)))\n  ) {\n    value = ' ' + value + ' '\n  }\n\n  // We have a potential problem: certain characters after eols could result in\n  // blocks being seen.\n  // For example, if someone injected the string `'\\n# b'`, then that would\n  // result in an ATX heading.\n  // We can\u2019t escape characters in `inlineCode`, but because eols are\n  // transformed to spaces when going from markdown to HTML anyway, we can swap\n  // them out.\n  while (++index < context.unsafe.length) {\n    pattern = context.unsafe[index]\n\n    // Only look for `atBreak`s.\n    // Btw: note that `atBreak` patterns will always start the regex at LF or\n    // CR.\n    if (!pattern.atBreak) continue\n\n    expression = patternCompile(pattern)\n\n    while ((match = expression.exec(value))) {\n      position = match.index\n\n      // Support CRLF (patterns only look for one of the characters).\n      if (\n        value.charCodeAt(position) === 10 /* `\\n` */ &&\n        value.charCodeAt(position - 1) === 13 /* `\\r` */\n      ) {\n        position--\n      }\n\n      value = value.slice(0, position) + ' ' + value.slice(match.index + 1)\n    }\n  }\n\n  return sequence + value + sequence\n}\n\nfunction inlineCodePeek() {\n  return '`'\n}\n", "/*!\n * repeat-string <https://github.com/jonschlinkert/repeat-string>\n *\n * Copyright (c) 2014-2015, Jon Schlinkert.\n * Licensed under the MIT License.\n */\n\n'use strict';\n\n/**\n * Results cache\n */\n\nvar res = '';\nvar cache;\n\n/**\n * Expose `repeat`\n */\n\nmodule.exports = repeat;\n\n/**\n * Repeat the given `string` the specified `number`\n * of times.\n *\n * **Example:**\n *\n * ```js\n * var repeat = require('repeat-string');\n * repeat('A', 5);\n * //=> AAAAA\n * ```\n *\n * @param {String} `string` The string to repeat\n * @param {Number} `number` The number of times to repeat the string\n * @return {String} Repeated string\n * @api public\n */\n\nfunction repeat(str, num) {\n  if (typeof str !== 'string') {\n    throw new TypeError('expected a string');\n  }\n\n  // cover common, quick use cases\n  if (num === 1) return str;\n  if (num === 2) return str + str;\n\n  var max = str.length * num;\n  if (cache !== str || typeof cache === 'undefined') {\n    cache = str;\n    res = '';\n  } else if (res.length >= max) {\n    return res.substr(0, max);\n  }\n\n  while (max > res.length && num > 1) {\n    if (num & 1) {\n      res += str;\n    }\n\n    num >>= 1;\n    str += str;\n  }\n\n  res += str;\n  res = res.substr(0, max);\n  return res;\n}\n", "'use strict'\n\nvar repeat = require('repeat-string')\n\nmodule.exports = markdownTable\n\nvar trailingWhitespace = / +$/\n\n// Characters.\nvar space = ' '\nvar lineFeed = '\\n'\nvar dash = '-'\nvar colon = ':'\nvar verticalBar = '|'\n\nvar x = 0\nvar C = 67\nvar L = 76\nvar R = 82\nvar c = 99\nvar l = 108\nvar r = 114\n\n// Create a table from a matrix of strings.\nfunction markdownTable(table, options) {\n  var settings = options || {}\n  var padding = settings.padding !== false\n  var start = settings.delimiterStart !== false\n  var end = settings.delimiterEnd !== false\n  var align = (settings.align || []).concat()\n  var alignDelimiters = settings.alignDelimiters !== false\n  var alignments = []\n  var stringLength = settings.stringLength || defaultStringLength\n  var rowIndex = -1\n  var rowLength = table.length\n  var cellMatrix = []\n  var sizeMatrix = []\n  var row = []\n  var sizes = []\n  var longestCellByColumn = []\n  var mostCellsPerRow = 0\n  var cells\n  var columnIndex\n  var columnLength\n  var largest\n  var size\n  var cell\n  var lines\n  var line\n  var before\n  var after\n  var code\n\n  // This is a superfluous loop if we don\u2019t align delimiters, but otherwise we\u2019d\n  // do superfluous work when aligning, so optimize for aligning.\n  while (++rowIndex < rowLength) {\n    cells = table[rowIndex]\n    columnIndex = -1\n    columnLength = cells.length\n    row = []\n    sizes = []\n\n    if (columnLength > mostCellsPerRow) {\n      mostCellsPerRow = columnLength\n    }\n\n    while (++columnIndex < columnLength) {\n      cell = serialize(cells[columnIndex])\n\n      if (alignDelimiters === true) {\n        size = stringLength(cell)\n        sizes[columnIndex] = size\n\n        largest = longestCellByColumn[columnIndex]\n\n        if (largest === undefined || size > largest) {\n          longestCellByColumn[columnIndex] = size\n        }\n      }\n\n      row.push(cell)\n    }\n\n    cellMatrix[rowIndex] = row\n    sizeMatrix[rowIndex] = sizes\n  }\n\n  // Figure out which alignments to use.\n  columnIndex = -1\n  columnLength = mostCellsPerRow\n\n  if (typeof align === 'object' && 'length' in align) {\n    while (++columnIndex < columnLength) {\n      alignments[columnIndex] = toAlignment(align[columnIndex])\n    }\n  } else {\n    code = toAlignment(align)\n\n    while (++columnIndex < columnLength) {\n      alignments[columnIndex] = code\n    }\n  }\n\n  // Inject the alignment row.\n  columnIndex = -1\n  columnLength = mostCellsPerRow\n  row = []\n  sizes = []\n\n  while (++columnIndex < columnLength) {\n    code = alignments[columnIndex]\n    before = ''\n    after = ''\n\n    if (code === l) {\n      before = colon\n    } else if (code === r) {\n      after = colon\n    } else if (code === c) {\n      before = colon\n      after = colon\n    }\n\n    // There *must* be at least one hyphen-minus in each alignment cell.\n    size = alignDelimiters\n      ? Math.max(\n          1,\n          longestCellByColumn[columnIndex] - before.length - after.length\n        )\n      : 1\n\n    cell = before + repeat(dash, size) + after\n\n    if (alignDelimiters === true) {\n      size = before.length + size + after.length\n\n      if (size > longestCellByColumn[columnIndex]) {\n        longestCellByColumn[columnIndex] = size\n      }\n\n      sizes[columnIndex] = size\n    }\n\n    row[columnIndex] = cell\n  }\n\n  // Inject the alignment row.\n  cellMatrix.splice(1, 0, row)\n  sizeMatrix.splice(1, 0, sizes)\n\n  rowIndex = -1\n  rowLength = cellMatrix.length\n  lines = []\n\n  while (++rowIndex < rowLength) {\n    row = cellMatrix[rowIndex]\n    sizes = sizeMatrix[rowIndex]\n    columnIndex = -1\n    columnLength = mostCellsPerRow\n    line = []\n\n    while (++columnIndex < columnLength) {\n      cell = row[columnIndex] || ''\n      before = ''\n      after = ''\n\n      if (alignDelimiters === true) {\n        size = longestCellByColumn[columnIndex] - (sizes[columnIndex] || 0)\n        code = alignments[columnIndex]\n\n        if (code === r) {\n          before = repeat(space, size)\n        } else if (code === c) {\n          if (size % 2 === 0) {\n            before = repeat(space, size / 2)\n            after = before\n          } else {\n            before = repeat(space, size / 2 + 0.5)\n            after = repeat(space, size / 2 - 0.5)\n          }\n        } else {\n          after = repeat(space, size)\n        }\n      }\n\n      if (start === true && columnIndex === 0) {\n        line.push(verticalBar)\n      }\n\n      if (\n        padding === true &&\n        // Don\u2019t add the opening space if we\u2019re not aligning and the cell is\n        // empty: there will be a closing space.\n        !(alignDelimiters === false && cell === '') &&\n        (start === true || columnIndex !== 0)\n      ) {\n        line.push(space)\n      }\n\n      if (alignDelimiters === true) {\n        line.push(before)\n      }\n\n      line.push(cell)\n\n      if (alignDelimiters === true) {\n        line.push(after)\n      }\n\n      if (padding === true) {\n        line.push(space)\n      }\n\n      if (end === true || columnIndex !== columnLength - 1) {\n        line.push(verticalBar)\n      }\n    }\n\n    line = line.join('')\n\n    if (end === false) {\n      line = line.replace(trailingWhitespace, '')\n    }\n\n    lines.push(line)\n  }\n\n  return lines.join(lineFeed)\n}\n\nfunction serialize(value) {\n  return value === null || value === undefined ? '' : String(value)\n}\n\nfunction defaultStringLength(value) {\n  return value.length\n}\n\nfunction toAlignment(value) {\n  var code = typeof value === 'string' ? value.charCodeAt(0) : x\n\n  return code === L || code === l\n    ? l\n    : code === R || code === r\n    ? r\n    : code === C || code === c\n    ? c\n    : x\n}\n", "var phrasing = require('mdast-util-to-markdown/lib/util/container-phrasing')\nvar defaultInlineCode = require('mdast-util-to-markdown/lib/handle/inline-code')\nvar markdownTable = require('markdown-table')\n\nmodule.exports = toMarkdown\n\nfunction toMarkdown(options) {\n  var settings = options || {}\n  var padding = settings.tableCellPadding\n  var alignDelimiters = settings.tablePipeAlign\n  var stringLength = settings.stringLength\n  var around = padding ? ' ' : '|'\n\n  return {\n    unsafe: [\n      {character: '\\r', inConstruct: 'tableCell'},\n      {character: '\\n', inConstruct: 'tableCell'},\n      // A pipe, when followed by a tab or space (padding), or a dash or colon\n      // (unpadded delimiter row), could result in a table.\n      {atBreak: true, character: '|', after: '[\\t :-]'},\n      // A pipe in a cell must be encoded.\n      {character: '|', inConstruct: 'tableCell'},\n      // A colon must be followed by a dash, in which case it could start a\n      // delimiter row.\n      {atBreak: true, character: ':', after: '-'},\n      // A delimiter row can also start with a dash, when followed by more\n      // dashes, a colon, or a pipe.\n      // This is a stricter version than the built in check for lists, thematic\n      // breaks, and setex heading underlines though:\n      // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>\n      {atBreak: true, character: '-', after: '[:|-]'}\n    ],\n    handlers: {\n      table: handleTable,\n      tableRow: handleTableRow,\n      tableCell: handleTableCell,\n      inlineCode: inlineCodeWithTable\n    }\n  }\n\n  function handleTable(node, _, context) {\n    return serializeData(handleTableAsData(node, context), node.align)\n  }\n\n  // This function isn\u2019t really used normally, because we handle rows at the\n  // table level.\n  // But, if someone passes in a table row, this ensures we make somewhat sense.\n  function handleTableRow(node, _, context) {\n    var row = handleTableRowAsData(node, context)\n    // `markdown-table` will always add an align row\n    var value = serializeData([row])\n    return value.slice(0, value.indexOf('\\n'))\n  }\n\n  function handleTableCell(node, _, context) {\n    var exit = context.enter('tableCell')\n    var value = phrasing(node, context, {before: around, after: around})\n    exit()\n    return value\n  }\n\n  function serializeData(matrix, align) {\n    return markdownTable(matrix, {\n      align: align,\n      alignDelimiters: alignDelimiters,\n      padding: padding,\n      stringLength: stringLength\n    })\n  }\n\n  function handleTableAsData(node, context) {\n    var children = node.children\n    var index = -1\n    var length = children.length\n    var result = []\n    var subexit = context.enter('table')\n\n    while (++index < length) {\n      result[index] = handleTableRowAsData(children[index], context)\n    }\n\n    subexit()\n\n    return result\n  }\n\n  function handleTableRowAsData(node, context) {\n    var children = node.children\n    var index = -1\n    var length = children.length\n    var result = []\n    var subexit = context.enter('tableRow')\n\n    while (++index < length) {\n      result[index] = handleTableCell(children[index], node, context)\n    }\n\n    subexit()\n\n    return result\n  }\n\n  function inlineCodeWithTable(node, parent, context) {\n    var value = defaultInlineCode(node, parent, context)\n\n    if (context.stack.indexOf('tableCell') !== -1) {\n      value = value.replace(/\\|/g, '\\\\$&')\n    }\n\n    return value\n  }\n}\n", "module.exports = checkBullet\n\nfunction checkBullet(context) {\n  var marker = context.options.bullet || '*'\n\n  if (marker !== '*' && marker !== '+' && marker !== '-') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        marker +\n        '` for `options.bullet`, expected `*`, `+`, or `-`'\n    )\n  }\n\n  return marker\n}\n", "module.exports = checkListItemIndent\n\nfunction checkListItemIndent(context) {\n  var style = context.options.listItemIndent || 'tab'\n\n  if (style === 1 || style === '1') {\n    return 'one'\n  }\n\n  if (style !== 'tab' && style !== 'one' && style !== 'mixed') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        style +\n        '` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`'\n    )\n  }\n\n  return style\n}\n", "module.exports = flow\n\nvar repeat = require('repeat-string')\n\nfunction flow(parent, context) {\n  var children = parent.children || []\n  var results = []\n  var index = -1\n  var child\n\n  while (++index < children.length) {\n    child = children[index]\n\n    results.push(\n      context.handle(child, parent, context, {before: '\\n', after: '\\n'})\n    )\n\n    if (index + 1 < children.length) {\n      results.push(between(child, children[index + 1]))\n    }\n  }\n\n  return results.join('')\n\n  function between(left, right) {\n    var index = -1\n    var result\n\n    while (++index < context.join.length) {\n      result = context.join[index](left, right, parent, context)\n\n      if (result === true || result === 1) {\n        break\n      }\n\n      if (typeof result === 'number') {\n        return repeat('\\n', 1 + Number(result))\n      }\n\n      if (result === false) {\n        return '\\n\\n<!---->\\n\\n'\n      }\n    }\n\n    return '\\n\\n'\n  }\n}\n", "module.exports = indentLines\n\nvar eol = /\\r?\\n|\\r/g\n\nfunction indentLines(value, map) {\n  var result = []\n  var start = 0\n  var line = 0\n  var match\n\n  while ((match = eol.exec(value))) {\n    one(value.slice(start, match.index))\n    result.push(match[0])\n    start = match.index + match[0].length\n    line++\n  }\n\n  one(value.slice(start))\n\n  return result.join('')\n\n  function one(value) {\n    result.push(map(value, line, !value))\n  }\n}\n", "module.exports = listItem\n\nvar repeat = require('repeat-string')\nvar checkBullet = require('../util/check-bullet')\nvar checkListItemIndent = require('../util/check-list-item-indent')\nvar flow = require('../util/container-flow')\nvar indentLines = require('../util/indent-lines')\n\nfunction listItem(node, parent, context) {\n  var bullet = checkBullet(context)\n  var listItemIndent = checkListItemIndent(context)\n  var size\n  var value\n  var exit\n\n  if (parent && parent.ordered) {\n    bullet =\n      (parent.start > -1 ? parent.start : 1) +\n      (context.options.incrementListMarker === false\n        ? 0\n        : parent.children.indexOf(node)) +\n      '.'\n  }\n\n  size = bullet.length + 1\n\n  if (\n    listItemIndent === 'tab' ||\n    (listItemIndent === 'mixed' && ((parent && parent.spread) || node.spread))\n  ) {\n    size = Math.ceil(size / 4) * 4\n  }\n\n  exit = context.enter('listItem')\n  value = indentLines(flow(node, context), map)\n  exit()\n\n  return value\n\n  function map(line, index, blank) {\n    if (index) {\n      return (blank ? '' : repeat(' ', size)) + line\n    }\n\n    return (blank ? bullet : bullet + repeat(' ', size - bullet.length)) + line\n  }\n}\n", "var defaultListItem = require('mdast-util-to-markdown/lib/handle/list-item')\n\nexports.unsafe = [{atBreak: true, character: '-', after: '[:|-]'}]\n\nexports.handlers = {\n  listItem: listItemWithTaskListItem\n}\n\nfunction listItemWithTaskListItem(node, parent, context) {\n  var value = defaultListItem(node, parent, context)\n  var head = node.children[0]\n\n  if (typeof node.checked === 'boolean' && head && head.type === 'paragraph') {\n    value = value.replace(/^(?:[*+-]|\\d+\\.)([\\r\\n]| {1,3})/, check)\n  }\n\n  return value\n\n  function check($0) {\n    return $0 + '[' + (node.checked ? 'x' : ' ') + '] '\n  }\n}\n", "module.exports = configure\n\nfunction configure(base, extension) {\n  var index = -1\n  var key\n\n  // First do subextensions.\n  if (extension.extensions) {\n    while (++index < extension.extensions.length) {\n      configure(base, extension.extensions[index])\n    }\n  }\n\n  for (key in extension) {\n    if (key === 'extensions') {\n      // Empty.\n    } else if (key === 'unsafe' || key === 'join') {\n      base[key] = base[key].concat(extension[key] || [])\n    } else if (key === 'handlers') {\n      base[key] = Object.assign(base[key], extension[key] || {})\n    } else {\n      base.options[key] = extension[key]\n    }\n  }\n\n  return base\n}\n", "var autolinkLiteral = require('mdast-util-gfm-autolink-literal/to-markdown')\nvar strikethrough = require('mdast-util-gfm-strikethrough/to-markdown')\nvar table = require('mdast-util-gfm-table/to-markdown')\nvar taskListItem = require('mdast-util-gfm-task-list-item/to-markdown')\nvar configure = require('mdast-util-to-markdown/lib/configure')\n\nmodule.exports = toMarkdown\n\nfunction toMarkdown(options) {\n  var config = configure(\n    {handlers: {}, join: [], unsafe: [], options: {}},\n    {\n      extensions: [autolinkLiteral, strikethrough, table(options), taskListItem]\n    }\n  )\n\n  return Object.assign(config.options, {\n    handlers: config.handlers,\n    join: config.join,\n    unsafe: config.unsafe\n  })\n}\n", "'use strict'\n\nvar syntax = require('micromark-extension-gfm')\nvar fromMarkdown = require('mdast-util-gfm/from-markdown')\nvar toMarkdown = require('mdast-util-gfm/to-markdown')\n\nvar warningIssued\n\nmodule.exports = gfm\n\nfunction gfm(options) {\n  var data = this.data()\n\n  /* istanbul ignore next - old remark. */\n  if (\n    !warningIssued &&\n    ((this.Parser &&\n      this.Parser.prototype &&\n      this.Parser.prototype.blockTokenizers) ||\n      (this.Compiler &&\n        this.Compiler.prototype &&\n        this.Compiler.prototype.visitors))\n  ) {\n    warningIssued = true\n    console.warn(\n      '[remark-gfm] Warning: please upgrade to remark 13 to use this plugin'\n    )\n  }\n\n  add('micromarkExtensions', syntax(options))\n  add('fromMarkdownExtensions', fromMarkdown)\n  add('toMarkdownExtensions', toMarkdown(options))\n\n  function add(field, value) {\n    /* istanbul ignore if - other extensions. */\n    if (data[field]) data[field].push(value)\n    else data[field] = [value]\n  }\n}\n", null, "'use strict';\n\n\nfunction isNothing(subject) {\n  return (typeof subject === 'undefined') || (subject === null);\n}\n\n\nfunction isObject(subject) {\n  return (typeof subject === 'object') && (subject !== null);\n}\n\n\nfunction toArray(sequence) {\n  if (Array.isArray(sequence)) return sequence;\n  else if (isNothing(sequence)) return [];\n\n  return [ sequence ];\n}\n\n\nfunction extend(target, source) {\n  var index, length, key, sourceKeys;\n\n  if (source) {\n    sourceKeys = Object.keys(source);\n\n    for (index = 0, length = sourceKeys.length; index < length; index += 1) {\n      key = sourceKeys[index];\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n\n\nfunction repeat(string, count) {\n  var result = '', cycle;\n\n  for (cycle = 0; cycle < count; cycle += 1) {\n    result += string;\n  }\n\n  return result;\n}\n\n\nfunction isNegativeZero(number) {\n  return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);\n}\n\n\nmodule.exports.isNothing      = isNothing;\nmodule.exports.isObject       = isObject;\nmodule.exports.toArray        = toArray;\nmodule.exports.repeat         = repeat;\nmodule.exports.isNegativeZero = isNegativeZero;\nmodule.exports.extend         = extend;\n", "// YAML error class. http://stackoverflow.com/questions/8458984\n//\n'use strict';\n\nfunction YAMLException(reason, mark) {\n  // Super constructor\n  Error.call(this);\n\n  this.name = 'YAMLException';\n  this.reason = reason;\n  this.mark = mark;\n  this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : '');\n\n  // Include stack trace in error object\n  if (Error.captureStackTrace) {\n    // Chrome and NodeJS\n    Error.captureStackTrace(this, this.constructor);\n  } else {\n    // FF, IE 10+ and Safari 6+. Fallback for others\n    this.stack = (new Error()).stack || '';\n  }\n}\n\n\n// Inherit from Error\nYAMLException.prototype = Object.create(Error.prototype);\nYAMLException.prototype.constructor = YAMLException;\n\n\nYAMLException.prototype.toString = function toString(compact) {\n  var result = this.name + ': ';\n\n  result += this.reason || '(unknown reason)';\n\n  if (!compact && this.mark) {\n    result += ' ' + this.mark.toString();\n  }\n\n  return result;\n};\n\n\nmodule.exports = YAMLException;\n", "'use strict';\n\n\nvar common = require('./common');\n\n\nfunction Mark(name, buffer, position, line, column) {\n  this.name     = name;\n  this.buffer   = buffer;\n  this.position = position;\n  this.line     = line;\n  this.column   = column;\n}\n\n\nMark.prototype.getSnippet = function getSnippet(indent, maxLength) {\n  var head, start, tail, end, snippet;\n\n  if (!this.buffer) return null;\n\n  indent = indent || 4;\n  maxLength = maxLength || 75;\n\n  head = '';\n  start = this.position;\n\n  while (start > 0 && '\\x00\\r\\n\\x85\\u2028\\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) {\n    start -= 1;\n    if (this.position - start > (maxLength / 2 - 1)) {\n      head = ' ... ';\n      start += 5;\n      break;\n    }\n  }\n\n  tail = '';\n  end = this.position;\n\n  while (end < this.buffer.length && '\\x00\\r\\n\\x85\\u2028\\u2029'.indexOf(this.buffer.charAt(end)) === -1) {\n    end += 1;\n    if (end - this.position > (maxLength / 2 - 1)) {\n      tail = ' ... ';\n      end -= 5;\n      break;\n    }\n  }\n\n  snippet = this.buffer.slice(start, end);\n\n  return common.repeat(' ', indent) + head + snippet + tail + '\\n' +\n         common.repeat(' ', indent + this.position - start + head.length) + '^';\n};\n\n\nMark.prototype.toString = function toString(compact) {\n  var snippet, where = '';\n\n  if (this.name) {\n    where += 'in \"' + this.name + '\" ';\n  }\n\n  where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1);\n\n  if (!compact) {\n    snippet = this.getSnippet();\n\n    if (snippet) {\n      where += ':\\n' + snippet;\n    }\n  }\n\n  return where;\n};\n\n\nmodule.exports = Mark;\n", "'use strict';\n\nvar YAMLException = require('./exception');\n\nvar TYPE_CONSTRUCTOR_OPTIONS = [\n  'kind',\n  'resolve',\n  'construct',\n  'instanceOf',\n  'predicate',\n  'represent',\n  'defaultStyle',\n  'styleAliases'\n];\n\nvar YAML_NODE_KINDS = [\n  'scalar',\n  'sequence',\n  'mapping'\n];\n\nfunction compileStyleAliases(map) {\n  var result = {};\n\n  if (map !== null) {\n    Object.keys(map).forEach(function (style) {\n      map[style].forEach(function (alias) {\n        result[String(alias)] = style;\n      });\n    });\n  }\n\n  return result;\n}\n\nfunction Type(tag, options) {\n  options = options || {};\n\n  Object.keys(options).forEach(function (name) {\n    if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {\n      throw new YAMLException('Unknown option \"' + name + '\" is met in definition of \"' + tag + '\" YAML type.');\n    }\n  });\n\n  // TODO: Add tag format check.\n  this.tag          = tag;\n  this.kind         = options['kind']         || null;\n  this.resolve      = options['resolve']      || function () { return true; };\n  this.construct    = options['construct']    || function (data) { return data; };\n  this.instanceOf   = options['instanceOf']   || null;\n  this.predicate    = options['predicate']    || null;\n  this.represent    = options['represent']    || null;\n  this.defaultStyle = options['defaultStyle'] || null;\n  this.styleAliases = compileStyleAliases(options['styleAliases'] || null);\n\n  if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {\n    throw new YAMLException('Unknown kind \"' + this.kind + '\" is specified for \"' + tag + '\" YAML type.');\n  }\n}\n\nmodule.exports = Type;\n", "'use strict';\n\n/*eslint-disable max-len*/\n\nvar common        = require('./common');\nvar YAMLException = require('./exception');\nvar Type          = require('./type');\n\n\nfunction compileList(schema, name, result) {\n  var exclude = [];\n\n  schema.include.forEach(function (includedSchema) {\n    result = compileList(includedSchema, name, result);\n  });\n\n  schema[name].forEach(function (currentType) {\n    result.forEach(function (previousType, previousIndex) {\n      if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {\n        exclude.push(previousIndex);\n      }\n    });\n\n    result.push(currentType);\n  });\n\n  return result.filter(function (type, index) {\n    return exclude.indexOf(index) === -1;\n  });\n}\n\n\nfunction compileMap(/* lists... */) {\n  var result = {\n        scalar: {},\n        sequence: {},\n        mapping: {},\n        fallback: {}\n      }, index, length;\n\n  function collectType(type) {\n    result[type.kind][type.tag] = result['fallback'][type.tag] = type;\n  }\n\n  for (index = 0, length = arguments.length; index < length; index += 1) {\n    arguments[index].forEach(collectType);\n  }\n  return result;\n}\n\n\nfunction Schema(definition) {\n  this.include  = definition.include  || [];\n  this.implicit = definition.implicit || [];\n  this.explicit = definition.explicit || [];\n\n  this.implicit.forEach(function (type) {\n    if (type.loadKind && type.loadKind !== 'scalar') {\n      throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');\n    }\n  });\n\n  this.compiledImplicit = compileList(this, 'implicit', []);\n  this.compiledExplicit = compileList(this, 'explicit', []);\n  this.compiledTypeMap  = compileMap(this.compiledImplicit, this.compiledExplicit);\n}\n\n\nSchema.DEFAULT = null;\n\n\nSchema.create = function createSchema() {\n  var schemas, types;\n\n  switch (arguments.length) {\n    case 1:\n      schemas = Schema.DEFAULT;\n      types = arguments[0];\n      break;\n\n    case 2:\n      schemas = arguments[0];\n      types = arguments[1];\n      break;\n\n    default:\n      throw new YAMLException('Wrong number of arguments for Schema.create function');\n  }\n\n  schemas = common.toArray(schemas);\n  types = common.toArray(types);\n\n  if (!schemas.every(function (schema) { return schema instanceof Schema; })) {\n    throw new YAMLException('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');\n  }\n\n  if (!types.every(function (type) { return type instanceof Type; })) {\n    throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');\n  }\n\n  return new Schema({\n    include: schemas,\n    explicit: types\n  });\n};\n\n\nmodule.exports = Schema;\n", "'use strict';\n\nvar Type = require('../type');\n\nmodule.exports = new Type('tag:yaml.org,2002:str', {\n  kind: 'scalar',\n  construct: function (data) { return data !== null ? data : ''; }\n});\n", "'use strict';\n\nvar Type = require('../type');\n\nmodule.exports = new Type('tag:yaml.org,2002:seq', {\n  kind: 'sequence',\n  construct: function (data) { return data !== null ? data : []; }\n});\n", "'use strict';\n\nvar Type = require('../type');\n\nmodule.exports = new Type('tag:yaml.org,2002:map', {\n  kind: 'mapping',\n  construct: function (data) { return data !== null ? data : {}; }\n});\n", "// Standard YAML's Failsafe schema.\n// http://www.yaml.org/spec/1.2/spec.html#id2802346\n\n\n'use strict';\n\n\nvar Schema = require('../schema');\n\n\nmodule.exports = new Schema({\n  explicit: [\n    require('../type/str'),\n    require('../type/seq'),\n    require('../type/map')\n  ]\n});\n", "'use strict';\n\nvar Type = require('../type');\n\nfunction resolveYamlNull(data) {\n  if (data === null) return true;\n\n  var max = data.length;\n\n  return (max === 1 && data === '~') ||\n         (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));\n}\n\nfunction constructYamlNull() {\n  return null;\n}\n\nfunction isNull(object) {\n  return object === null;\n}\n\nmodule.exports = new Type('tag:yaml.org,2002:null', {\n  kind: 'scalar',\n  resolve: resolveYamlNull,\n  construct: constructYamlNull,\n  predicate: isNull,\n  represent: {\n    canonical: function () { return '~';    },\n    lowercase: function () { return 'null'; },\n    uppercase: function () { return 'NULL'; },\n    camelcase: function () { return 'Null'; }\n  },\n  defaultStyle: 'lowercase'\n});\n", "'use strict';\n\nvar Type = require('../type');\n\nfunction resolveYamlBoolean(data) {\n  if (data === null) return false;\n\n  var max = data.length;\n\n  return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||\n         (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));\n}\n\nfunction constructYamlBoolean(data) {\n  return data === 'true' ||\n         data === 'True' ||\n         data === 'TRUE';\n}\n\nfunction isBoolean(object) {\n  return Object.prototype.toString.call(object) === '[object Boolean]';\n}\n\nmodule.exports = new Type('tag:yaml.org,2002:bool', {\n  kind: 'scalar',\n  resolve: resolveYamlBoolean,\n  construct: constructYamlBoolean,\n  predicate: isBoolean,\n  represent: {\n    lowercase: function (object) { return object ? 'true' : 'false'; },\n    uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },\n    camelcase: function (object) { return object ? 'True' : 'False'; }\n  },\n  defaultStyle: 'lowercase'\n});\n", "'use strict';\n\nvar common = require('../common');\nvar Type   = require('../type');\n\nfunction isHexCode(c) {\n  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) ||\n         ((0x41/* A */ <= c) && (c <= 0x46/* F */)) ||\n         ((0x61/* a */ <= c) && (c <= 0x66/* f */));\n}\n\nfunction isOctCode(c) {\n  return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */));\n}\n\nfunction isDecCode(c) {\n  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */));\n}\n\nfunction resolveYamlInteger(data) {\n  if (data === null) return false;\n\n  var max = data.length,\n      index = 0,\n      hasDigits = false,\n      ch;\n\n  if (!max) return false;\n\n  ch = data[index];\n\n  // sign\n  if (ch === '-' || ch === '+') {\n    ch = data[++index];\n  }\n\n  if (ch === '0') {\n    // 0\n    if (index + 1 === max) return true;\n    ch = data[++index];\n\n    // base 2, base 8, base 16\n\n    if (ch === 'b') {\n      // base 2\n      index++;\n\n      for (; index < max; index++) {\n        ch = data[index];\n        if (ch === '_') continue;\n        if (ch !== '0' && ch !== '1') return false;\n        hasDigits = true;\n      }\n      return hasDigits && ch !== '_';\n    }\n\n\n    if (ch === 'x') {\n      // base 16\n      index++;\n\n      for (; index < max; index++) {\n        ch = data[index];\n        if (ch === '_') continue;\n        if (!isHexCode(data.charCodeAt(index))) return false;\n        hasDigits = true;\n      }\n      return hasDigits && ch !== '_';\n    }\n\n    // base 8\n    for (; index < max; index++) {\n      ch = data[index];\n      if (ch === '_') continue;\n      if (!isOctCode(data.charCodeAt(index))) return false;\n      hasDigits = true;\n    }\n    return hasDigits && ch !== '_';\n  }\n\n  // base 10 (except 0) or base 60\n\n  // value should not start with `_`;\n  if (ch === '_') return false;\n\n  for (; index < max; index++) {\n    ch = data[index];\n    if (ch === '_') continue;\n    if (ch === ':') break;\n    if (!isDecCode(data.charCodeAt(index))) {\n      return false;\n    }\n    hasDigits = true;\n  }\n\n  // Should have digits and should not end with `_`\n  if (!hasDigits || ch === '_') return false;\n\n  // if !base60 - done;\n  if (ch !== ':') return true;\n\n  // base60 almost not used, no needs to optimize\n  return /^(:[0-5]?[0-9])+$/.test(data.slice(index));\n}\n\nfunction constructYamlInteger(data) {\n  var value = data, sign = 1, ch, base, digits = [];\n\n  if (value.indexOf('_') !== -1) {\n    value = value.replace(/_/g, '');\n  }\n\n  ch = value[0];\n\n  if (ch === '-' || ch === '+') {\n    if (ch === '-') sign = -1;\n    value = value.slice(1);\n    ch = value[0];\n  }\n\n  if (value === '0') return 0;\n\n  if (ch === '0') {\n    if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);\n    if (value[1] === 'x') return sign * parseInt(value, 16);\n    return sign * parseInt(value, 8);\n  }\n\n  if (value.indexOf(':') !== -1) {\n    value.split(':').forEach(function (v) {\n      digits.unshift(parseInt(v, 10));\n    });\n\n    value = 0;\n    base = 1;\n\n    digits.forEach(function (d) {\n      value += (d * base);\n      base *= 60;\n    });\n\n    return sign * value;\n\n  }\n\n  return sign * parseInt(value, 10);\n}\n\nfunction isInteger(object) {\n  return (Object.prototype.toString.call(object)) === '[object Number]' &&\n         (object % 1 === 0 && !common.isNegativeZero(object));\n}\n\nmodule.exports = new Type('tag:yaml.org,2002:int', {\n  kind: 'scalar',\n  resolve: resolveYamlInteger,\n  construct: constructYamlInteger,\n  predicate: isInteger,\n  represent: {\n    binary:      function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); },\n    octal:       function (obj) { return obj >= 0 ? '0'  + obj.toString(8) : '-0'  + obj.toString(8).slice(1); },\n    decimal:     function (obj) { return obj.toString(10); },\n    /* eslint-disable max-len */\n    hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() :  '-0x' + obj.toString(16).toUpperCase().slice(1); }\n  },\n  defaultStyle: 'decimal',\n  styleAliases: {\n    binary:      [ 2,  'bin' ],\n    octal:       [ 8,  'oct' ],\n    decimal:     [ 10, 'dec' ],\n    hexadecimal: [ 16, 'hex' ]\n  }\n});\n", "'use strict';\n\nvar common = require('../common');\nvar Type   = require('../type');\n\nvar YAML_FLOAT_PATTERN = new RegExp(\n  // 2.5e4, 2.5 and integers\n  '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +\n  // .2e4, .2\n  // special case, seems not from spec\n  '|\\\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +\n  // 20:59\n  '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\\\.[0-9_]*' +\n  // .inf\n  '|[-+]?\\\\.(?:inf|Inf|INF)' +\n  // .nan\n  '|\\\\.(?:nan|NaN|NAN))$');\n\nfunction resolveYamlFloat(data) {\n  if (data === null) return false;\n\n  if (!YAML_FLOAT_PATTERN.test(data) ||\n      // Quick hack to not allow integers end with `_`\n      // Probably should update regexp & check speed\n      data[data.length - 1] === '_') {\n    return false;\n  }\n\n  return true;\n}\n\nfunction constructYamlFloat(data) {\n  var value, sign, base, digits;\n\n  value  = data.replace(/_/g, '').toLowerCase();\n  sign   = value[0] === '-' ? -1 : 1;\n  digits = [];\n\n  if ('+-'.indexOf(value[0]) >= 0) {\n    value = value.slice(1);\n  }\n\n  if (value === '.inf') {\n    return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;\n\n  } else if (value === '.nan') {\n    return NaN;\n\n  } else if (value.indexOf(':') >= 0) {\n    value.split(':').forEach(function (v) {\n      digits.unshift(parseFloat(v, 10));\n    });\n\n    value = 0.0;\n    base = 1;\n\n    digits.forEach(function (d) {\n      value += d * base;\n      base *= 60;\n    });\n\n    return sign * value;\n\n  }\n  return sign * parseFloat(value, 10);\n}\n\n\nvar SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;\n\nfunction representYamlFloat(object, style) {\n  var res;\n\n  if (isNaN(object)) {\n    switch (style) {\n      case 'lowercase': return '.nan';\n      case 'uppercase': return '.NAN';\n      case 'camelcase': return '.NaN';\n    }\n  } else if (Number.POSITIVE_INFINITY === object) {\n    switch (style) {\n      case 'lowercase': return '.inf';\n      case 'uppercase': return '.INF';\n      case 'camelcase': return '.Inf';\n    }\n  } else if (Number.NEGATIVE_INFINITY === object) {\n    switch (style) {\n      case 'lowercase': return '-.inf';\n      case 'uppercase': return '-.INF';\n      case 'camelcase': return '-.Inf';\n    }\n  } else if (common.isNegativeZero(object)) {\n    return '-0.0';\n  }\n\n  res = object.toString(10);\n\n  // JS stringifier can build scientific format without dots: 5e-100,\n  // while YAML requres dot: 5.e-100. Fix it with simple hack\n\n  return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;\n}\n\nfunction isFloat(object) {\n  return (Object.prototype.toString.call(object) === '[object Number]') &&\n         (object % 1 !== 0 || common.isNegativeZero(object));\n}\n\nmodule.exports = new Type('tag:yaml.org,2002:float', {\n  kind: 'scalar',\n  resolve: resolveYamlFloat,\n  construct: constructYamlFloat,\n  predicate: isFloat,\n  represent: representYamlFloat,\n  defaultStyle: 'lowercase'\n});\n", "// Standard YAML's JSON schema.\n// http://www.yaml.org/spec/1.2/spec.html#id2803231\n//\n// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.\n// So, this schema is not such strict as defined in the YAML specification.\n// It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc.\n\n\n'use strict';\n\n\nvar Schema = require('../schema');\n\n\nmodule.exports = new Schema({\n  include: [\n    require('./failsafe')\n  ],\n  implicit: [\n    require('../type/null'),\n    require('../type/bool'),\n    require('../type/int'),\n    require('../type/float')\n  ]\n});\n", "// Standard YAML's Core schema.\n// http://www.yaml.org/spec/1.2/spec.html#id2804923\n//\n// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.\n// So, Core schema has no distinctions from JSON schema is JS-YAML.\n\n\n'use strict';\n\n\nvar Schema = require('../schema');\n\n\nmodule.exports = new Schema({\n  include: [\n    require('./json')\n  ]\n});\n", "'use strict';\n\nvar Type = require('../type');\n\nvar YAML_DATE_REGEXP = new RegExp(\n  '^([0-9][0-9][0-9][0-9])'          + // [1] year\n  '-([0-9][0-9])'                    + // [2] month\n  '-([0-9][0-9])$');                   // [3] day\n\nvar YAML_TIMESTAMP_REGEXP = new RegExp(\n  '^([0-9][0-9][0-9][0-9])'          + // [1] year\n  '-([0-9][0-9]?)'                   + // [2] month\n  '-([0-9][0-9]?)'                   + // [3] day\n  '(?:[Tt]|[ \\\\t]+)'                 + // ...\n  '([0-9][0-9]?)'                    + // [4] hour\n  ':([0-9][0-9])'                    + // [5] minute\n  ':([0-9][0-9])'                    + // [6] second\n  '(?:\\\\.([0-9]*))?'                 + // [7] fraction\n  '(?:[ \\\\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour\n  '(?::([0-9][0-9]))?))?$');           // [11] tz_minute\n\nfunction resolveYamlTimestamp(data) {\n  if (data === null) return false;\n  if (YAML_DATE_REGEXP.exec(data) !== null) return true;\n  if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;\n  return false;\n}\n\nfunction constructYamlTimestamp(data) {\n  var match, year, month, day, hour, minute, second, fraction = 0,\n      delta = null, tz_hour, tz_minute, date;\n\n  match = YAML_DATE_REGEXP.exec(data);\n  if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);\n\n  if (match === null) throw new Error('Date resolve error');\n\n  // match: [1] year [2] month [3] day\n\n  year = +(match[1]);\n  month = +(match[2]) - 1; // JS month starts with 0\n  day = +(match[3]);\n\n  if (!match[4]) { // no hour\n    return new Date(Date.UTC(year, month, day));\n  }\n\n  // match: [4] hour [5] minute [6] second [7] fraction\n\n  hour = +(match[4]);\n  minute = +(match[5]);\n  second = +(match[6]);\n\n  if (match[7]) {\n    fraction = match[7].slice(0, 3);\n    while (fraction.length < 3) { // milli-seconds\n      fraction += '0';\n    }\n    fraction = +fraction;\n  }\n\n  // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute\n\n  if (match[9]) {\n    tz_hour = +(match[10]);\n    tz_minute = +(match[11] || 0);\n    delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds\n    if (match[9] === '-') delta = -delta;\n  }\n\n  date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));\n\n  if (delta) date.setTime(date.getTime() - delta);\n\n  return date;\n}\n\nfunction representYamlTimestamp(object /*, style*/) {\n  return object.toISOString();\n}\n\nmodule.exports = new Type('tag:yaml.org,2002:timestamp', {\n  kind: 'scalar',\n  resolve: resolveYamlTimestamp,\n  construct: constructYamlTimestamp,\n  instanceOf: Date,\n  represent: representYamlTimestamp\n});\n", "'use strict';\n\nvar Type = require('../type');\n\nfunction resolveYamlMerge(data) {\n  return data === '<<' || data === null;\n}\n\nmodule.exports = new Type('tag:yaml.org,2002:merge', {\n  kind: 'scalar',\n  resolve: resolveYamlMerge\n});\n", "'use strict';\n\n/*eslint-disable no-bitwise*/\n\nvar NodeBuffer;\n\ntry {\n  // A trick for browserified version, to not include `Buffer` shim\n  var _require = require;\n  NodeBuffer = _require('buffer').Buffer;\n} catch (__) {}\n\nvar Type       = require('../type');\n\n\n// [ 64, 65, 66 ] -> [ padding, CR, LF ]\nvar BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\\n\\r';\n\n\nfunction resolveYamlBinary(data) {\n  if (data === null) return false;\n\n  var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;\n\n  // Convert one by one.\n  for (idx = 0; idx < max; idx++) {\n    code = map.indexOf(data.charAt(idx));\n\n    // Skip CR/LF\n    if (code > 64) continue;\n\n    // Fail on illegal characters\n    if (code < 0) return false;\n\n    bitlen += 6;\n  }\n\n  // If there are any bits left, source was corrupted\n  return (bitlen % 8) === 0;\n}\n\nfunction constructYamlBinary(data) {\n  var idx, tailbits,\n      input = data.replace(/[\\r\\n=]/g, ''), // remove CR/LF & padding to simplify scan\n      max = input.length,\n      map = BASE64_MAP,\n      bits = 0,\n      result = [];\n\n  // Collect by 6*4 bits (3 bytes)\n\n  for (idx = 0; idx < max; idx++) {\n    if ((idx % 4 === 0) && idx) {\n      result.push((bits >> 16) & 0xFF);\n      result.push((bits >> 8) & 0xFF);\n      result.push(bits & 0xFF);\n    }\n\n    bits = (bits << 6) | map.indexOf(input.charAt(idx));\n  }\n\n  // Dump tail\n\n  tailbits = (max % 4) * 6;\n\n  if (tailbits === 0) {\n    result.push((bits >> 16) & 0xFF);\n    result.push((bits >> 8) & 0xFF);\n    result.push(bits & 0xFF);\n  } else if (tailbits === 18) {\n    result.push((bits >> 10) & 0xFF);\n    result.push((bits >> 2) & 0xFF);\n  } else if (tailbits === 12) {\n    result.push((bits >> 4) & 0xFF);\n  }\n\n  // Wrap into Buffer for NodeJS and leave Array for browser\n  if (NodeBuffer) {\n    // Support node 6.+ Buffer API when available\n    return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result);\n  }\n\n  return result;\n}\n\nfunction representYamlBinary(object /*, style*/) {\n  var result = '', bits = 0, idx, tail,\n      max = object.length,\n      map = BASE64_MAP;\n\n  // Convert every three bytes to 4 ASCII characters.\n\n  for (idx = 0; idx < max; idx++) {\n    if ((idx % 3 === 0) && idx) {\n      result += map[(bits >> 18) & 0x3F];\n      result += map[(bits >> 12) & 0x3F];\n      result += map[(bits >> 6) & 0x3F];\n      result += map[bits & 0x3F];\n    }\n\n    bits = (bits << 8) + object[idx];\n  }\n\n  // Dump tail\n\n  tail = max % 3;\n\n  if (tail === 0) {\n    result += map[(bits >> 18) & 0x3F];\n    result += map[(bits >> 12) & 0x3F];\n    result += map[(bits >> 6) & 0x3F];\n    result += map[bits & 0x3F];\n  } else if (tail === 2) {\n    result += map[(bits >> 10) & 0x3F];\n    result += map[(bits >> 4) & 0x3F];\n    result += map[(bits << 2) & 0x3F];\n    result += map[64];\n  } else if (tail === 1) {\n    result += map[(bits >> 2) & 0x3F];\n    result += map[(bits << 4) & 0x3F];\n    result += map[64];\n    result += map[64];\n  }\n\n  return result;\n}\n\nfunction isBinary(object) {\n  return NodeBuffer && NodeBuffer.isBuffer(object);\n}\n\nmodule.exports = new Type('tag:yaml.org,2002:binary', {\n  kind: 'scalar',\n  resolve: resolveYamlBinary,\n  construct: constructYamlBinary,\n  predicate: isBinary,\n  represent: representYamlBinary\n});\n", "'use strict';\n\nvar Type = require('../type');\n\nvar _hasOwnProperty = Object.prototype.hasOwnProperty;\nvar _toString       = Object.prototype.toString;\n\nfunction resolveYamlOmap(data) {\n  if (data === null) return true;\n\n  var objectKeys = [], index, length, pair, pairKey, pairHasKey,\n      object = data;\n\n  for (index = 0, length = object.length; index < length; index += 1) {\n    pair = object[index];\n    pairHasKey = false;\n\n    if (_toString.call(pair) !== '[object Object]') return false;\n\n    for (pairKey in pair) {\n      if (_hasOwnProperty.call(pair, pairKey)) {\n        if (!pairHasKey) pairHasKey = true;\n        else return false;\n      }\n    }\n\n    if (!pairHasKey) return false;\n\n    if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);\n    else return false;\n  }\n\n  return true;\n}\n\nfunction constructYamlOmap(data) {\n  return data !== null ? data : [];\n}\n\nmodule.exports = new Type('tag:yaml.org,2002:omap', {\n  kind: 'sequence',\n  resolve: resolveYamlOmap,\n  construct: constructYamlOmap\n});\n", "'use strict';\n\nvar Type = require('../type');\n\nvar _toString = Object.prototype.toString;\n\nfunction resolveYamlPairs(data) {\n  if (data === null) return true;\n\n  var index, length, pair, keys, result,\n      object = data;\n\n  result = new Array(object.length);\n\n  for (index = 0, length = object.length; index < length; index += 1) {\n    pair = object[index];\n\n    if (_toString.call(pair) !== '[object Object]') return false;\n\n    keys = Object.keys(pair);\n\n    if (keys.length !== 1) return false;\n\n    result[index] = [ keys[0], pair[keys[0]] ];\n  }\n\n  return true;\n}\n\nfunction constructYamlPairs(data) {\n  if (data === null) return [];\n\n  var index, length, pair, keys, result,\n      object = data;\n\n  result = new Array(object.length);\n\n  for (index = 0, length = object.length; index < length; index += 1) {\n    pair = object[index];\n\n    keys = Object.keys(pair);\n\n    result[index] = [ keys[0], pair[keys[0]] ];\n  }\n\n  return result;\n}\n\nmodule.exports = new Type('tag:yaml.org,2002:pairs', {\n  kind: 'sequence',\n  resolve: resolveYamlPairs,\n  construct: constructYamlPairs\n});\n", "'use strict';\n\nvar Type = require('../type');\n\nvar _hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction resolveYamlSet(data) {\n  if (data === null) return true;\n\n  var key, object = data;\n\n  for (key in object) {\n    if (_hasOwnProperty.call(object, key)) {\n      if (object[key] !== null) return false;\n    }\n  }\n\n  return true;\n}\n\nfunction constructYamlSet(data) {\n  return data !== null ? data : {};\n}\n\nmodule.exports = new Type('tag:yaml.org,2002:set', {\n  kind: 'mapping',\n  resolve: resolveYamlSet,\n  construct: constructYamlSet\n});\n", "// JS-YAML's default schema for `safeLoad` function.\n// It is not described in the YAML specification.\n//\n// This schema is based on standard YAML's Core schema and includes most of\n// extra types described at YAML tag repository. (http://yaml.org/type/)\n\n\n'use strict';\n\n\nvar Schema = require('../schema');\n\n\nmodule.exports = new Schema({\n  include: [\n    require('./core')\n  ],\n  implicit: [\n    require('../type/timestamp'),\n    require('../type/merge')\n  ],\n  explicit: [\n    require('../type/binary'),\n    require('../type/omap'),\n    require('../type/pairs'),\n    require('../type/set')\n  ]\n});\n", "'use strict';\n\nvar Type = require('../../type');\n\nfunction resolveJavascriptUndefined() {\n  return true;\n}\n\nfunction constructJavascriptUndefined() {\n  /*eslint-disable no-undefined*/\n  return undefined;\n}\n\nfunction representJavascriptUndefined() {\n  return '';\n}\n\nfunction isUndefined(object) {\n  return typeof object === 'undefined';\n}\n\nmodule.exports = new Type('tag:yaml.org,2002:js/undefined', {\n  kind: 'scalar',\n  resolve: resolveJavascriptUndefined,\n  construct: constructJavascriptUndefined,\n  predicate: isUndefined,\n  represent: representJavascriptUndefined\n});\n", "'use strict';\n\nvar Type = require('../../type');\n\nfunction resolveJavascriptRegExp(data) {\n  if (data === null) return false;\n  if (data.length === 0) return false;\n\n  var regexp = data,\n      tail   = /\\/([gim]*)$/.exec(data),\n      modifiers = '';\n\n  // if regexp starts with '/' it can have modifiers and must be properly closed\n  // `/foo/gim` - modifiers tail can be maximum 3 chars\n  if (regexp[0] === '/') {\n    if (tail) modifiers = tail[1];\n\n    if (modifiers.length > 3) return false;\n    // if expression starts with /, is should be properly terminated\n    if (regexp[regexp.length - modifiers.length - 1] !== '/') return false;\n  }\n\n  return true;\n}\n\nfunction constructJavascriptRegExp(data) {\n  var regexp = data,\n      tail   = /\\/([gim]*)$/.exec(data),\n      modifiers = '';\n\n  // `/foo/gim` - tail can be maximum 4 chars\n  if (regexp[0] === '/') {\n    if (tail) modifiers = tail[1];\n    regexp = regexp.slice(1, regexp.length - modifiers.length - 1);\n  }\n\n  return new RegExp(regexp, modifiers);\n}\n\nfunction representJavascriptRegExp(object /*, style*/) {\n  var result = '/' + object.source + '/';\n\n  if (object.global) result += 'g';\n  if (object.multiline) result += 'm';\n  if (object.ignoreCase) result += 'i';\n\n  return result;\n}\n\nfunction isRegExp(object) {\n  return Object.prototype.toString.call(object) === '[object RegExp]';\n}\n\nmodule.exports = new Type('tag:yaml.org,2002:js/regexp', {\n  kind: 'scalar',\n  resolve: resolveJavascriptRegExp,\n  construct: constructJavascriptRegExp,\n  predicate: isRegExp,\n  represent: representJavascriptRegExp\n});\n", "'use strict';\n\nvar esprima;\n\n// Browserified version does not have esprima\n//\n// 1. For node.js just require module as deps\n// 2. For browser try to require mudule via external AMD system.\n//    If not found - try to fallback to window.esprima. If not\n//    found too - then fail to parse.\n//\ntry {\n  // workaround to exclude package from browserify list.\n  var _require = require;\n  esprima = _require('esprima');\n} catch (_) {\n  /* eslint-disable no-redeclare */\n  /* global window */\n  if (typeof window !== 'undefined') esprima = window.esprima;\n}\n\nvar Type = require('../../type');\n\nfunction resolveJavascriptFunction(data) {\n  if (data === null) return false;\n\n  try {\n    var source = '(' + data + ')',\n        ast    = esprima.parse(source, { range: true });\n\n    if (ast.type                    !== 'Program'             ||\n        ast.body.length             !== 1                     ||\n        ast.body[0].type            !== 'ExpressionStatement' ||\n        (ast.body[0].expression.type !== 'ArrowFunctionExpression' &&\n          ast.body[0].expression.type !== 'FunctionExpression')) {\n      return false;\n    }\n\n    return true;\n  } catch (err) {\n    return false;\n  }\n}\n\nfunction constructJavascriptFunction(data) {\n  /*jslint evil:true*/\n\n  var source = '(' + data + ')',\n      ast    = esprima.parse(source, { range: true }),\n      params = [],\n      body;\n\n  if (ast.type                    !== 'Program'             ||\n      ast.body.length             !== 1                     ||\n      ast.body[0].type            !== 'ExpressionStatement' ||\n      (ast.body[0].expression.type !== 'ArrowFunctionExpression' &&\n        ast.body[0].expression.type !== 'FunctionExpression')) {\n    throw new Error('Failed to resolve function');\n  }\n\n  ast.body[0].expression.params.forEach(function (param) {\n    params.push(param.name);\n  });\n\n  body = ast.body[0].expression.body.range;\n\n  // Esprima's ranges include the first '{' and the last '}' characters on\n  // function expressions. So cut them out.\n  if (ast.body[0].expression.body.type === 'BlockStatement') {\n    /*eslint-disable no-new-func*/\n    return new Function(params, source.slice(body[0] + 1, body[1] - 1));\n  }\n  // ES6 arrow functions can omit the BlockStatement. In that case, just return\n  // the body.\n  /*eslint-disable no-new-func*/\n  return new Function(params, 'return ' + source.slice(body[0], body[1]));\n}\n\nfunction representJavascriptFunction(object /*, style*/) {\n  return object.toString();\n}\n\nfunction isFunction(object) {\n  return Object.prototype.toString.call(object) === '[object Function]';\n}\n\nmodule.exports = new Type('tag:yaml.org,2002:js/function', {\n  kind: 'scalar',\n  resolve: resolveJavascriptFunction,\n  construct: constructJavascriptFunction,\n  predicate: isFunction,\n  represent: representJavascriptFunction\n});\n", "// JS-YAML's default schema for `load` function.\n// It is not described in the YAML specification.\n//\n// This schema is based on JS-YAML's default safe schema and includes\n// JavaScript-specific types: !!js/undefined, !!js/regexp and !!js/function.\n//\n// Also this schema is used as default base schema at `Schema.create` function.\n\n\n'use strict';\n\n\nvar Schema = require('../schema');\n\n\nmodule.exports = Schema.DEFAULT = new Schema({\n  include: [\n    require('./default_safe')\n  ],\n  explicit: [\n    require('../type/js/undefined'),\n    require('../type/js/regexp'),\n    require('../type/js/function')\n  ]\n});\n", "'use strict';\n\n/*eslint-disable max-len,no-use-before-define*/\n\nvar common              = require('./common');\nvar YAMLException       = require('./exception');\nvar Mark                = require('./mark');\nvar DEFAULT_SAFE_SCHEMA = require('./schema/default_safe');\nvar DEFAULT_FULL_SCHEMA = require('./schema/default_full');\n\n\nvar _hasOwnProperty = Object.prototype.hasOwnProperty;\n\n\nvar CONTEXT_FLOW_IN   = 1;\nvar CONTEXT_FLOW_OUT  = 2;\nvar CONTEXT_BLOCK_IN  = 3;\nvar CONTEXT_BLOCK_OUT = 4;\n\n\nvar CHOMPING_CLIP  = 1;\nvar CHOMPING_STRIP = 2;\nvar CHOMPING_KEEP  = 3;\n\n\nvar PATTERN_NON_PRINTABLE         = /[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F\\x7F-\\x84\\x86-\\x9F\\uFFFE\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/;\nvar PATTERN_NON_ASCII_LINE_BREAKS = /[\\x85\\u2028\\u2029]/;\nvar PATTERN_FLOW_INDICATORS       = /[,\\[\\]\\{\\}]/;\nvar PATTERN_TAG_HANDLE            = /^(?:!|!!|![a-z\\-]+!)$/i;\nvar PATTERN_TAG_URI               = /^(?:!|[^,\\[\\]\\{\\}])(?:%[0-9a-f]{2}|[0-9a-z\\-#;\\/\\?:@&=\\+\\$,_\\.!~\\*'\\(\\)\\[\\]])*$/i;\n\n\nfunction _class(obj) { return Object.prototype.toString.call(obj); }\n\nfunction is_EOL(c) {\n  return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);\n}\n\nfunction is_WHITE_SPACE(c) {\n  return (c === 0x09/* Tab */) || (c === 0x20/* Space */);\n}\n\nfunction is_WS_OR_EOL(c) {\n  return (c === 0x09/* Tab */) ||\n         (c === 0x20/* Space */) ||\n         (c === 0x0A/* LF */) ||\n         (c === 0x0D/* CR */);\n}\n\nfunction is_FLOW_INDICATOR(c) {\n  return c === 0x2C/* , */ ||\n         c === 0x5B/* [ */ ||\n         c === 0x5D/* ] */ ||\n         c === 0x7B/* { */ ||\n         c === 0x7D/* } */;\n}\n\nfunction fromHexCode(c) {\n  var lc;\n\n  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {\n    return c - 0x30;\n  }\n\n  /*eslint-disable no-bitwise*/\n  lc = c | 0x20;\n\n  if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) {\n    return lc - 0x61 + 10;\n  }\n\n  return -1;\n}\n\nfunction escapedHexLen(c) {\n  if (c === 0x78/* x */) { return 2; }\n  if (c === 0x75/* u */) { return 4; }\n  if (c === 0x55/* U */) { return 8; }\n  return 0;\n}\n\nfunction fromDecimalCode(c) {\n  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {\n    return c - 0x30;\n  }\n\n  return -1;\n}\n\nfunction simpleEscapeSequence(c) {\n  /* eslint-disable indent */\n  return (c === 0x30/* 0 */) ? '\\x00' :\n        (c === 0x61/* a */) ? '\\x07' :\n        (c === 0x62/* b */) ? '\\x08' :\n        (c === 0x74/* t */) ? '\\x09' :\n        (c === 0x09/* Tab */) ? '\\x09' :\n        (c === 0x6E/* n */) ? '\\x0A' :\n        (c === 0x76/* v */) ? '\\x0B' :\n        (c === 0x66/* f */) ? '\\x0C' :\n        (c === 0x72/* r */) ? '\\x0D' :\n        (c === 0x65/* e */) ? '\\x1B' :\n        (c === 0x20/* Space */) ? ' ' :\n        (c === 0x22/* \" */) ? '\\x22' :\n        (c === 0x2F/* / */) ? '/' :\n        (c === 0x5C/* \\ */) ? '\\x5C' :\n        (c === 0x4E/* N */) ? '\\x85' :\n        (c === 0x5F/* _ */) ? '\\xA0' :\n        (c === 0x4C/* L */) ? '\\u2028' :\n        (c === 0x50/* P */) ? '\\u2029' : '';\n}\n\nfunction charFromCodepoint(c) {\n  if (c <= 0xFFFF) {\n    return String.fromCharCode(c);\n  }\n  // Encode UTF-16 surrogate pair\n  // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF\n  return String.fromCharCode(\n    ((c - 0x010000) >> 10) + 0xD800,\n    ((c - 0x010000) & 0x03FF) + 0xDC00\n  );\n}\n\nvar simpleEscapeCheck = new Array(256); // integer, for fast access\nvar simpleEscapeMap = new Array(256);\nfor (var i = 0; i < 256; i++) {\n  simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;\n  simpleEscapeMap[i] = simpleEscapeSequence(i);\n}\n\n\nfunction State(input, options) {\n  this.input = input;\n\n  this.filename  = options['filename']  || null;\n  this.schema    = options['schema']    || DEFAULT_FULL_SCHEMA;\n  this.onWarning = options['onWarning'] || null;\n  this.legacy    = options['legacy']    || false;\n  this.json      = options['json']      || false;\n  this.listener  = options['listener']  || null;\n\n  this.implicitTypes = this.schema.compiledImplicit;\n  this.typeMap       = this.schema.compiledTypeMap;\n\n  this.length     = input.length;\n  this.position   = 0;\n  this.line       = 0;\n  this.lineStart  = 0;\n  this.lineIndent = 0;\n\n  this.documents = [];\n\n  /*\n  this.version;\n  this.checkLineBreaks;\n  this.tagMap;\n  this.anchorMap;\n  this.tag;\n  this.anchor;\n  this.kind;\n  this.result;*/\n\n}\n\n\nfunction generateError(state, message) {\n  return new YAMLException(\n    message,\n    new Mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart)));\n}\n\nfunction throwError(state, message) {\n  throw generateError(state, message);\n}\n\nfunction throwWarning(state, message) {\n  if (state.onWarning) {\n    state.onWarning.call(null, generateError(state, message));\n  }\n}\n\n\nvar directiveHandlers = {\n\n  YAML: function handleYamlDirective(state, name, args) {\n\n    var match, major, minor;\n\n    if (state.version !== null) {\n      throwError(state, 'duplication of %YAML directive');\n    }\n\n    if (args.length !== 1) {\n      throwError(state, 'YAML directive accepts exactly one argument');\n    }\n\n    match = /^([0-9]+)\\.([0-9]+)$/.exec(args[0]);\n\n    if (match === null) {\n      throwError(state, 'ill-formed argument of the YAML directive');\n    }\n\n    major = parseInt(match[1], 10);\n    minor = parseInt(match[2], 10);\n\n    if (major !== 1) {\n      throwError(state, 'unacceptable YAML version of the document');\n    }\n\n    state.version = args[0];\n    state.checkLineBreaks = (minor < 2);\n\n    if (minor !== 1 && minor !== 2) {\n      throwWarning(state, 'unsupported YAML version of the document');\n    }\n  },\n\n  TAG: function handleTagDirective(state, name, args) {\n\n    var handle, prefix;\n\n    if (args.length !== 2) {\n      throwError(state, 'TAG directive accepts exactly two arguments');\n    }\n\n    handle = args[0];\n    prefix = args[1];\n\n    if (!PATTERN_TAG_HANDLE.test(handle)) {\n      throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');\n    }\n\n    if (_hasOwnProperty.call(state.tagMap, handle)) {\n      throwError(state, 'there is a previously declared suffix for \"' + handle + '\" tag handle');\n    }\n\n    if (!PATTERN_TAG_URI.test(prefix)) {\n      throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');\n    }\n\n    state.tagMap[handle] = prefix;\n  }\n};\n\n\nfunction captureSegment(state, start, end, checkJson) {\n  var _position, _length, _character, _result;\n\n  if (start < end) {\n    _result = state.input.slice(start, end);\n\n    if (checkJson) {\n      for (_position = 0, _length = _result.length; _position < _length; _position += 1) {\n        _character = _result.charCodeAt(_position);\n        if (!(_character === 0x09 ||\n              (0x20 <= _character && _character <= 0x10FFFF))) {\n          throwError(state, 'expected valid JSON character');\n        }\n      }\n    } else if (PATTERN_NON_PRINTABLE.test(_result)) {\n      throwError(state, 'the stream contains non-printable characters');\n    }\n\n    state.result += _result;\n  }\n}\n\nfunction mergeMappings(state, destination, source, overridableKeys) {\n  var sourceKeys, key, index, quantity;\n\n  if (!common.isObject(source)) {\n    throwError(state, 'cannot merge mappings; the provided source object is unacceptable');\n  }\n\n  sourceKeys = Object.keys(source);\n\n  for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {\n    key = sourceKeys[index];\n\n    if (!_hasOwnProperty.call(destination, key)) {\n      destination[key] = source[key];\n      overridableKeys[key] = true;\n    }\n  }\n}\n\nfunction storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {\n  var index, quantity;\n\n  // The output is a plain object here, so keys can only be strings.\n  // We need to convert keyNode to a string, but doing so can hang the process\n  // (deeply nested arrays that explode exponentially using aliases).\n  if (Array.isArray(keyNode)) {\n    keyNode = Array.prototype.slice.call(keyNode);\n\n    for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {\n      if (Array.isArray(keyNode[index])) {\n        throwError(state, 'nested arrays are not supported inside keys');\n      }\n\n      if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {\n        keyNode[index] = '[object Object]';\n      }\n    }\n  }\n\n  // Avoid code execution in load() via toString property\n  // (still use its own toString for arrays, timestamps,\n  // and whatever user schema extensions happen to have @@toStringTag)\n  if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {\n    keyNode = '[object Object]';\n  }\n\n\n  keyNode = String(keyNode);\n\n  if (_result === null) {\n    _result = {};\n  }\n\n  if (keyTag === 'tag:yaml.org,2002:merge') {\n    if (Array.isArray(valueNode)) {\n      for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {\n        mergeMappings(state, _result, valueNode[index], overridableKeys);\n      }\n    } else {\n      mergeMappings(state, _result, valueNode, overridableKeys);\n    }\n  } else {\n    if (!state.json &&\n        !_hasOwnProperty.call(overridableKeys, keyNode) &&\n        _hasOwnProperty.call(_result, keyNode)) {\n      state.line = startLine || state.line;\n      state.position = startPos || state.position;\n      throwError(state, 'duplicated mapping key');\n    }\n    _result[keyNode] = valueNode;\n    delete overridableKeys[keyNode];\n  }\n\n  return _result;\n}\n\nfunction readLineBreak(state) {\n  var ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch === 0x0A/* LF */) {\n    state.position++;\n  } else if (ch === 0x0D/* CR */) {\n    state.position++;\n    if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {\n      state.position++;\n    }\n  } else {\n    throwError(state, 'a line break is expected');\n  }\n\n  state.line += 1;\n  state.lineStart = state.position;\n}\n\nfunction skipSeparationSpace(state, allowComments, checkIndent) {\n  var lineBreaks = 0,\n      ch = state.input.charCodeAt(state.position);\n\n  while (ch !== 0) {\n    while (is_WHITE_SPACE(ch)) {\n      ch = state.input.charCodeAt(++state.position);\n    }\n\n    if (allowComments && ch === 0x23/* # */) {\n      do {\n        ch = state.input.charCodeAt(++state.position);\n      } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);\n    }\n\n    if (is_EOL(ch)) {\n      readLineBreak(state);\n\n      ch = state.input.charCodeAt(state.position);\n      lineBreaks++;\n      state.lineIndent = 0;\n\n      while (ch === 0x20/* Space */) {\n        state.lineIndent++;\n        ch = state.input.charCodeAt(++state.position);\n      }\n    } else {\n      break;\n    }\n  }\n\n  if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {\n    throwWarning(state, 'deficient indentation');\n  }\n\n  return lineBreaks;\n}\n\nfunction testDocumentSeparator(state) {\n  var _position = state.position,\n      ch;\n\n  ch = state.input.charCodeAt(_position);\n\n  // Condition state.position === state.lineStart is tested\n  // in parent on each call, for efficiency. No needs to test here again.\n  if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&\n      ch === state.input.charCodeAt(_position + 1) &&\n      ch === state.input.charCodeAt(_position + 2)) {\n\n    _position += 3;\n\n    ch = state.input.charCodeAt(_position);\n\n    if (ch === 0 || is_WS_OR_EOL(ch)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction writeFoldedLines(state, count) {\n  if (count === 1) {\n    state.result += ' ';\n  } else if (count > 1) {\n    state.result += common.repeat('\\n', count - 1);\n  }\n}\n\n\nfunction readPlainScalar(state, nodeIndent, withinFlowCollection) {\n  var preceding,\n      following,\n      captureStart,\n      captureEnd,\n      hasPendingContent,\n      _line,\n      _lineStart,\n      _lineIndent,\n      _kind = state.kind,\n      _result = state.result,\n      ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (is_WS_OR_EOL(ch)      ||\n      is_FLOW_INDICATOR(ch) ||\n      ch === 0x23/* # */    ||\n      ch === 0x26/* & */    ||\n      ch === 0x2A/* * */    ||\n      ch === 0x21/* ! */    ||\n      ch === 0x7C/* | */    ||\n      ch === 0x3E/* > */    ||\n      ch === 0x27/* ' */    ||\n      ch === 0x22/* \" */    ||\n      ch === 0x25/* % */    ||\n      ch === 0x40/* @ */    ||\n      ch === 0x60/* ` */) {\n    return false;\n  }\n\n  if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {\n    following = state.input.charCodeAt(state.position + 1);\n\n    if (is_WS_OR_EOL(following) ||\n        withinFlowCollection && is_FLOW_INDICATOR(following)) {\n      return false;\n    }\n  }\n\n  state.kind = 'scalar';\n  state.result = '';\n  captureStart = captureEnd = state.position;\n  hasPendingContent = false;\n\n  while (ch !== 0) {\n    if (ch === 0x3A/* : */) {\n      following = state.input.charCodeAt(state.position + 1);\n\n      if (is_WS_OR_EOL(following) ||\n          withinFlowCollection && is_FLOW_INDICATOR(following)) {\n        break;\n      }\n\n    } else if (ch === 0x23/* # */) {\n      preceding = state.input.charCodeAt(state.position - 1);\n\n      if (is_WS_OR_EOL(preceding)) {\n        break;\n      }\n\n    } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||\n               withinFlowCollection && is_FLOW_INDICATOR(ch)) {\n      break;\n\n    } else if (is_EOL(ch)) {\n      _line = state.line;\n      _lineStart = state.lineStart;\n      _lineIndent = state.lineIndent;\n      skipSeparationSpace(state, false, -1);\n\n      if (state.lineIndent >= nodeIndent) {\n        hasPendingContent = true;\n        ch = state.input.charCodeAt(state.position);\n        continue;\n      } else {\n        state.position = captureEnd;\n        state.line = _line;\n        state.lineStart = _lineStart;\n        state.lineIndent = _lineIndent;\n        break;\n      }\n    }\n\n    if (hasPendingContent) {\n      captureSegment(state, captureStart, captureEnd, false);\n      writeFoldedLines(state, state.line - _line);\n      captureStart = captureEnd = state.position;\n      hasPendingContent = false;\n    }\n\n    if (!is_WHITE_SPACE(ch)) {\n      captureEnd = state.position + 1;\n    }\n\n    ch = state.input.charCodeAt(++state.position);\n  }\n\n  captureSegment(state, captureStart, captureEnd, false);\n\n  if (state.result) {\n    return true;\n  }\n\n  state.kind = _kind;\n  state.result = _result;\n  return false;\n}\n\nfunction readSingleQuotedScalar(state, nodeIndent) {\n  var ch,\n      captureStart, captureEnd;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch !== 0x27/* ' */) {\n    return false;\n  }\n\n  state.kind = 'scalar';\n  state.result = '';\n  state.position++;\n  captureStart = captureEnd = state.position;\n\n  while ((ch = state.input.charCodeAt(state.position)) !== 0) {\n    if (ch === 0x27/* ' */) {\n      captureSegment(state, captureStart, state.position, true);\n      ch = state.input.charCodeAt(++state.position);\n\n      if (ch === 0x27/* ' */) {\n        captureStart = state.position;\n        state.position++;\n        captureEnd = state.position;\n      } else {\n        return true;\n      }\n\n    } else if (is_EOL(ch)) {\n      captureSegment(state, captureStart, captureEnd, true);\n      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));\n      captureStart = captureEnd = state.position;\n\n    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {\n      throwError(state, 'unexpected end of the document within a single quoted scalar');\n\n    } else {\n      state.position++;\n      captureEnd = state.position;\n    }\n  }\n\n  throwError(state, 'unexpected end of the stream within a single quoted scalar');\n}\n\nfunction readDoubleQuotedScalar(state, nodeIndent) {\n  var captureStart,\n      captureEnd,\n      hexLength,\n      hexResult,\n      tmp,\n      ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch !== 0x22/* \" */) {\n    return false;\n  }\n\n  state.kind = 'scalar';\n  state.result = '';\n  state.position++;\n  captureStart = captureEnd = state.position;\n\n  while ((ch = state.input.charCodeAt(state.position)) !== 0) {\n    if (ch === 0x22/* \" */) {\n      captureSegment(state, captureStart, state.position, true);\n      state.position++;\n      return true;\n\n    } else if (ch === 0x5C/* \\ */) {\n      captureSegment(state, captureStart, state.position, true);\n      ch = state.input.charCodeAt(++state.position);\n\n      if (is_EOL(ch)) {\n        skipSeparationSpace(state, false, nodeIndent);\n\n        // TODO: rework to inline fn with no type cast?\n      } else if (ch < 256 && simpleEscapeCheck[ch]) {\n        state.result += simpleEscapeMap[ch];\n        state.position++;\n\n      } else if ((tmp = escapedHexLen(ch)) > 0) {\n        hexLength = tmp;\n        hexResult = 0;\n\n        for (; hexLength > 0; hexLength--) {\n          ch = state.input.charCodeAt(++state.position);\n\n          if ((tmp = fromHexCode(ch)) >= 0) {\n            hexResult = (hexResult << 4) + tmp;\n\n          } else {\n            throwError(state, 'expected hexadecimal character');\n          }\n        }\n\n        state.result += charFromCodepoint(hexResult);\n\n        state.position++;\n\n      } else {\n        throwError(state, 'unknown escape sequence');\n      }\n\n      captureStart = captureEnd = state.position;\n\n    } else if (is_EOL(ch)) {\n      captureSegment(state, captureStart, captureEnd, true);\n      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));\n      captureStart = captureEnd = state.position;\n\n    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {\n      throwError(state, 'unexpected end of the document within a double quoted scalar');\n\n    } else {\n      state.position++;\n      captureEnd = state.position;\n    }\n  }\n\n  throwError(state, 'unexpected end of the stream within a double quoted scalar');\n}\n\nfunction readFlowCollection(state, nodeIndent) {\n  var readNext = true,\n      _line,\n      _tag     = state.tag,\n      _result,\n      _anchor  = state.anchor,\n      following,\n      terminator,\n      isPair,\n      isExplicitPair,\n      isMapping,\n      overridableKeys = {},\n      keyNode,\n      keyTag,\n      valueNode,\n      ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch === 0x5B/* [ */) {\n    terminator = 0x5D;/* ] */\n    isMapping = false;\n    _result = [];\n  } else if (ch === 0x7B/* { */) {\n    terminator = 0x7D;/* } */\n    isMapping = true;\n    _result = {};\n  } else {\n    return false;\n  }\n\n  if (state.anchor !== null) {\n    state.anchorMap[state.anchor] = _result;\n  }\n\n  ch = state.input.charCodeAt(++state.position);\n\n  while (ch !== 0) {\n    skipSeparationSpace(state, true, nodeIndent);\n\n    ch = state.input.charCodeAt(state.position);\n\n    if (ch === terminator) {\n      state.position++;\n      state.tag = _tag;\n      state.anchor = _anchor;\n      state.kind = isMapping ? 'mapping' : 'sequence';\n      state.result = _result;\n      return true;\n    } else if (!readNext) {\n      throwError(state, 'missed comma between flow collection entries');\n    }\n\n    keyTag = keyNode = valueNode = null;\n    isPair = isExplicitPair = false;\n\n    if (ch === 0x3F/* ? */) {\n      following = state.input.charCodeAt(state.position + 1);\n\n      if (is_WS_OR_EOL(following)) {\n        isPair = isExplicitPair = true;\n        state.position++;\n        skipSeparationSpace(state, true, nodeIndent);\n      }\n    }\n\n    _line = state.line;\n    composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);\n    keyTag = state.tag;\n    keyNode = state.result;\n    skipSeparationSpace(state, true, nodeIndent);\n\n    ch = state.input.charCodeAt(state.position);\n\n    if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {\n      isPair = true;\n      ch = state.input.charCodeAt(++state.position);\n      skipSeparationSpace(state, true, nodeIndent);\n      composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);\n      valueNode = state.result;\n    }\n\n    if (isMapping) {\n      storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode);\n    } else if (isPair) {\n      _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode));\n    } else {\n      _result.push(keyNode);\n    }\n\n    skipSeparationSpace(state, true, nodeIndent);\n\n    ch = state.input.charCodeAt(state.position);\n\n    if (ch === 0x2C/* , */) {\n      readNext = true;\n      ch = state.input.charCodeAt(++state.position);\n    } else {\n      readNext = false;\n    }\n  }\n\n  throwError(state, 'unexpected end of the stream within a flow collection');\n}\n\nfunction readBlockScalar(state, nodeIndent) {\n  var captureStart,\n      folding,\n      chomping       = CHOMPING_CLIP,\n      didReadContent = false,\n      detectedIndent = false,\n      textIndent     = nodeIndent,\n      emptyLines     = 0,\n      atMoreIndented = false,\n      tmp,\n      ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch === 0x7C/* | */) {\n    folding = false;\n  } else if (ch === 0x3E/* > */) {\n    folding = true;\n  } else {\n    return false;\n  }\n\n  state.kind = 'scalar';\n  state.result = '';\n\n  while (ch !== 0) {\n    ch = state.input.charCodeAt(++state.position);\n\n    if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {\n      if (CHOMPING_CLIP === chomping) {\n        chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;\n      } else {\n        throwError(state, 'repeat of a chomping mode identifier');\n      }\n\n    } else if ((tmp = fromDecimalCode(ch)) >= 0) {\n      if (tmp === 0) {\n        throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');\n      } else if (!detectedIndent) {\n        textIndent = nodeIndent + tmp - 1;\n        detectedIndent = true;\n      } else {\n        throwError(state, 'repeat of an indentation width identifier');\n      }\n\n    } else {\n      break;\n    }\n  }\n\n  if (is_WHITE_SPACE(ch)) {\n    do { ch = state.input.charCodeAt(++state.position); }\n    while (is_WHITE_SPACE(ch));\n\n    if (ch === 0x23/* # */) {\n      do { ch = state.input.charCodeAt(++state.position); }\n      while (!is_EOL(ch) && (ch !== 0));\n    }\n  }\n\n  while (ch !== 0) {\n    readLineBreak(state);\n    state.lineIndent = 0;\n\n    ch = state.input.charCodeAt(state.position);\n\n    while ((!detectedIndent || state.lineIndent < textIndent) &&\n           (ch === 0x20/* Space */)) {\n      state.lineIndent++;\n      ch = state.input.charCodeAt(++state.position);\n    }\n\n    if (!detectedIndent && state.lineIndent > textIndent) {\n      textIndent = state.lineIndent;\n    }\n\n    if (is_EOL(ch)) {\n      emptyLines++;\n      continue;\n    }\n\n    // End of the scalar.\n    if (state.lineIndent < textIndent) {\n\n      // Perform the chomping.\n      if (chomping === CHOMPING_KEEP) {\n        state.result += common.repeat('\\n', didReadContent ? 1 + emptyLines : emptyLines);\n      } else if (chomping === CHOMPING_CLIP) {\n        if (didReadContent) { // i.e. only if the scalar is not empty.\n          state.result += '\\n';\n        }\n      }\n\n      // Break this `while` cycle and go to the funciton's epilogue.\n      break;\n    }\n\n    // Folded style: use fancy rules to handle line breaks.\n    if (folding) {\n\n      // Lines starting with white space characters (more-indented lines) are not folded.\n      if (is_WHITE_SPACE(ch)) {\n        atMoreIndented = true;\n        // except for the first content line (cf. Example 8.1)\n        state.result += common.repeat('\\n', didReadContent ? 1 + emptyLines : emptyLines);\n\n      // End of more-indented block.\n      } else if (atMoreIndented) {\n        atMoreIndented = false;\n        state.result += common.repeat('\\n', emptyLines + 1);\n\n      // Just one line break - perceive as the same line.\n      } else if (emptyLines === 0) {\n        if (didReadContent) { // i.e. only if we have already read some scalar content.\n          state.result += ' ';\n        }\n\n      // Several line breaks - perceive as different lines.\n      } else {\n        state.result += common.repeat('\\n', emptyLines);\n      }\n\n    // Literal style: just add exact number of line breaks between content lines.\n    } else {\n      // Keep all line breaks except the header line break.\n      state.result += common.repeat('\\n', didReadContent ? 1 + emptyLines : emptyLines);\n    }\n\n    didReadContent = true;\n    detectedIndent = true;\n    emptyLines = 0;\n    captureStart = state.position;\n\n    while (!is_EOL(ch) && (ch !== 0)) {\n      ch = state.input.charCodeAt(++state.position);\n    }\n\n    captureSegment(state, captureStart, state.position, false);\n  }\n\n  return true;\n}\n\nfunction readBlockSequence(state, nodeIndent) {\n  var _line,\n      _tag      = state.tag,\n      _anchor   = state.anchor,\n      _result   = [],\n      following,\n      detected  = false,\n      ch;\n\n  if (state.anchor !== null) {\n    state.anchorMap[state.anchor] = _result;\n  }\n\n  ch = state.input.charCodeAt(state.position);\n\n  while (ch !== 0) {\n\n    if (ch !== 0x2D/* - */) {\n      break;\n    }\n\n    following = state.input.charCodeAt(state.position + 1);\n\n    if (!is_WS_OR_EOL(following)) {\n      break;\n    }\n\n    detected = true;\n    state.position++;\n\n    if (skipSeparationSpace(state, true, -1)) {\n      if (state.lineIndent <= nodeIndent) {\n        _result.push(null);\n        ch = state.input.charCodeAt(state.position);\n        continue;\n      }\n    }\n\n    _line = state.line;\n    composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);\n    _result.push(state.result);\n    skipSeparationSpace(state, true, -1);\n\n    ch = state.input.charCodeAt(state.position);\n\n    if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {\n      throwError(state, 'bad indentation of a sequence entry');\n    } else if (state.lineIndent < nodeIndent) {\n      break;\n    }\n  }\n\n  if (detected) {\n    state.tag = _tag;\n    state.anchor = _anchor;\n    state.kind = 'sequence';\n    state.result = _result;\n    return true;\n  }\n  return false;\n}\n\nfunction readBlockMapping(state, nodeIndent, flowIndent) {\n  var following,\n      allowCompact,\n      _line,\n      _pos,\n      _tag          = state.tag,\n      _anchor       = state.anchor,\n      _result       = {},\n      overridableKeys = {},\n      keyTag        = null,\n      keyNode       = null,\n      valueNode     = null,\n      atExplicitKey = false,\n      detected      = false,\n      ch;\n\n  if (state.anchor !== null) {\n    state.anchorMap[state.anchor] = _result;\n  }\n\n  ch = state.input.charCodeAt(state.position);\n\n  while (ch !== 0) {\n    following = state.input.charCodeAt(state.position + 1);\n    _line = state.line; // Save the current line.\n    _pos = state.position;\n\n    //\n    // Explicit notation case. There are two separate blocks:\n    // first for the key (denoted by \"?\") and second for the value (denoted by \":\")\n    //\n    if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {\n\n      if (ch === 0x3F/* ? */) {\n        if (atExplicitKey) {\n          storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);\n          keyTag = keyNode = valueNode = null;\n        }\n\n        detected = true;\n        atExplicitKey = true;\n        allowCompact = true;\n\n      } else if (atExplicitKey) {\n        // i.e. 0x3A/* : */ === character after the explicit key.\n        atExplicitKey = false;\n        allowCompact = true;\n\n      } else {\n        throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');\n      }\n\n      state.position += 1;\n      ch = following;\n\n    //\n    // Implicit notation case. Flow-style node as the key first, then \":\", and the value.\n    //\n    } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {\n\n      if (state.line === _line) {\n        ch = state.input.charCodeAt(state.position);\n\n        while (is_WHITE_SPACE(ch)) {\n          ch = state.input.charCodeAt(++state.position);\n        }\n\n        if (ch === 0x3A/* : */) {\n          ch = state.input.charCodeAt(++state.position);\n\n          if (!is_WS_OR_EOL(ch)) {\n            throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping');\n          }\n\n          if (atExplicitKey) {\n            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);\n            keyTag = keyNode = valueNode = null;\n          }\n\n          detected = true;\n          atExplicitKey = false;\n          allowCompact = false;\n          keyTag = state.tag;\n          keyNode = state.result;\n\n        } else if (detected) {\n          throwError(state, 'can not read an implicit mapping pair; a colon is missed');\n\n        } else {\n          state.tag = _tag;\n          state.anchor = _anchor;\n          return true; // Keep the result of `composeNode`.\n        }\n\n      } else if (detected) {\n        throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');\n\n      } else {\n        state.tag = _tag;\n        state.anchor = _anchor;\n        return true; // Keep the result of `composeNode`.\n      }\n\n    } else {\n      break; // Reading is done. Go to the epilogue.\n    }\n\n    //\n    // Common reading code for both explicit and implicit notations.\n    //\n    if (state.line === _line || state.lineIndent > nodeIndent) {\n      if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {\n        if (atExplicitKey) {\n          keyNode = state.result;\n        } else {\n          valueNode = state.result;\n        }\n      }\n\n      if (!atExplicitKey) {\n        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos);\n        keyTag = keyNode = valueNode = null;\n      }\n\n      skipSeparationSpace(state, true, -1);\n      ch = state.input.charCodeAt(state.position);\n    }\n\n    if (state.lineIndent > nodeIndent && (ch !== 0)) {\n      throwError(state, 'bad indentation of a mapping entry');\n    } else if (state.lineIndent < nodeIndent) {\n      break;\n    }\n  }\n\n  //\n  // Epilogue.\n  //\n\n  // Special case: last mapping's node contains only the key in explicit notation.\n  if (atExplicitKey) {\n    storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);\n  }\n\n  // Expose the resulting mapping.\n  if (detected) {\n    state.tag = _tag;\n    state.anchor = _anchor;\n    state.kind = 'mapping';\n    state.result = _result;\n  }\n\n  return detected;\n}\n\nfunction readTagProperty(state) {\n  var _position,\n      isVerbatim = false,\n      isNamed    = false,\n      tagHandle,\n      tagName,\n      ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch !== 0x21/* ! */) return false;\n\n  if (state.tag !== null) {\n    throwError(state, 'duplication of a tag property');\n  }\n\n  ch = state.input.charCodeAt(++state.position);\n\n  if (ch === 0x3C/* < */) {\n    isVerbatim = true;\n    ch = state.input.charCodeAt(++state.position);\n\n  } else if (ch === 0x21/* ! */) {\n    isNamed = true;\n    tagHandle = '!!';\n    ch = state.input.charCodeAt(++state.position);\n\n  } else {\n    tagHandle = '!';\n  }\n\n  _position = state.position;\n\n  if (isVerbatim) {\n    do { ch = state.input.charCodeAt(++state.position); }\n    while (ch !== 0 && ch !== 0x3E/* > */);\n\n    if (state.position < state.length) {\n      tagName = state.input.slice(_position, state.position);\n      ch = state.input.charCodeAt(++state.position);\n    } else {\n      throwError(state, 'unexpected end of the stream within a verbatim tag');\n    }\n  } else {\n    while (ch !== 0 && !is_WS_OR_EOL(ch)) {\n\n      if (ch === 0x21/* ! */) {\n        if (!isNamed) {\n          tagHandle = state.input.slice(_position - 1, state.position + 1);\n\n          if (!PATTERN_TAG_HANDLE.test(tagHandle)) {\n            throwError(state, 'named tag handle cannot contain such characters');\n          }\n\n          isNamed = true;\n          _position = state.position + 1;\n        } else {\n          throwError(state, 'tag suffix cannot contain exclamation marks');\n        }\n      }\n\n      ch = state.input.charCodeAt(++state.position);\n    }\n\n    tagName = state.input.slice(_position, state.position);\n\n    if (PATTERN_FLOW_INDICATORS.test(tagName)) {\n      throwError(state, 'tag suffix cannot contain flow indicator characters');\n    }\n  }\n\n  if (tagName && !PATTERN_TAG_URI.test(tagName)) {\n    throwError(state, 'tag name cannot contain such characters: ' + tagName);\n  }\n\n  if (isVerbatim) {\n    state.tag = tagName;\n\n  } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {\n    state.tag = state.tagMap[tagHandle] + tagName;\n\n  } else if (tagHandle === '!') {\n    state.tag = '!' + tagName;\n\n  } else if (tagHandle === '!!') {\n    state.tag = 'tag:yaml.org,2002:' + tagName;\n\n  } else {\n    throwError(state, 'undeclared tag handle \"' + tagHandle + '\"');\n  }\n\n  return true;\n}\n\nfunction readAnchorProperty(state) {\n  var _position,\n      ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch !== 0x26/* & */) return false;\n\n  if (state.anchor !== null) {\n    throwError(state, 'duplication of an anchor property');\n  }\n\n  ch = state.input.charCodeAt(++state.position);\n  _position = state.position;\n\n  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {\n    ch = state.input.charCodeAt(++state.position);\n  }\n\n  if (state.position === _position) {\n    throwError(state, 'name of an anchor node must contain at least one character');\n  }\n\n  state.anchor = state.input.slice(_position, state.position);\n  return true;\n}\n\nfunction readAlias(state) {\n  var _position, alias,\n      ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch !== 0x2A/* * */) return false;\n\n  ch = state.input.charCodeAt(++state.position);\n  _position = state.position;\n\n  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {\n    ch = state.input.charCodeAt(++state.position);\n  }\n\n  if (state.position === _position) {\n    throwError(state, 'name of an alias node must contain at least one character');\n  }\n\n  alias = state.input.slice(_position, state.position);\n\n  if (!_hasOwnProperty.call(state.anchorMap, alias)) {\n    throwError(state, 'unidentified alias \"' + alias + '\"');\n  }\n\n  state.result = state.anchorMap[alias];\n  skipSeparationSpace(state, true, -1);\n  return true;\n}\n\nfunction composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {\n  var allowBlockStyles,\n      allowBlockScalars,\n      allowBlockCollections,\n      indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent\n      atNewLine  = false,\n      hasContent = false,\n      typeIndex,\n      typeQuantity,\n      type,\n      flowIndent,\n      blockIndent;\n\n  if (state.listener !== null) {\n    state.listener('open', state);\n  }\n\n  state.tag    = null;\n  state.anchor = null;\n  state.kind   = null;\n  state.result = null;\n\n  allowBlockStyles = allowBlockScalars = allowBlockCollections =\n    CONTEXT_BLOCK_OUT === nodeContext ||\n    CONTEXT_BLOCK_IN  === nodeContext;\n\n  if (allowToSeek) {\n    if (skipSeparationSpace(state, true, -1)) {\n      atNewLine = true;\n\n      if (state.lineIndent > parentIndent) {\n        indentStatus = 1;\n      } else if (state.lineIndent === parentIndent) {\n        indentStatus = 0;\n      } else if (state.lineIndent < parentIndent) {\n        indentStatus = -1;\n      }\n    }\n  }\n\n  if (indentStatus === 1) {\n    while (readTagProperty(state) || readAnchorProperty(state)) {\n      if (skipSeparationSpace(state, true, -1)) {\n        atNewLine = true;\n        allowBlockCollections = allowBlockStyles;\n\n        if (state.lineIndent > parentIndent) {\n          indentStatus = 1;\n        } else if (state.lineIndent === parentIndent) {\n          indentStatus = 0;\n        } else if (state.lineIndent < parentIndent) {\n          indentStatus = -1;\n        }\n      } else {\n        allowBlockCollections = false;\n      }\n    }\n  }\n\n  if (allowBlockCollections) {\n    allowBlockCollections = atNewLine || allowCompact;\n  }\n\n  if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {\n    if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {\n      flowIndent = parentIndent;\n    } else {\n      flowIndent = parentIndent + 1;\n    }\n\n    blockIndent = state.position - state.lineStart;\n\n    if (indentStatus === 1) {\n      if (allowBlockCollections &&\n          (readBlockSequence(state, blockIndent) ||\n           readBlockMapping(state, blockIndent, flowIndent)) ||\n          readFlowCollection(state, flowIndent)) {\n        hasContent = true;\n      } else {\n        if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||\n            readSingleQuotedScalar(state, flowIndent) ||\n            readDoubleQuotedScalar(state, flowIndent)) {\n          hasContent = true;\n\n        } else if (readAlias(state)) {\n          hasContent = true;\n\n          if (state.tag !== null || state.anchor !== null) {\n            throwError(state, 'alias node should not have any properties');\n          }\n\n        } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {\n          hasContent = true;\n\n          if (state.tag === null) {\n            state.tag = '?';\n          }\n        }\n\n        if (state.anchor !== null) {\n          state.anchorMap[state.anchor] = state.result;\n        }\n      }\n    } else if (indentStatus === 0) {\n      // Special case: block sequences are allowed to have same indentation level as the parent.\n      // http://www.yaml.org/spec/1.2/spec.html#id2799784\n      hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);\n    }\n  }\n\n  if (state.tag !== null && state.tag !== '!') {\n    if (state.tag === '?') {\n      // Implicit resolving is not allowed for non-scalar types, and '?'\n      // non-specific tag is only automatically assigned to plain scalars.\n      //\n      // We only need to check kind conformity in case user explicitly assigns '?'\n      // tag, for example like this: \"!<?> [0]\"\n      //\n      if (state.result !== null && state.kind !== 'scalar') {\n        throwError(state, 'unacceptable node kind for !<?> tag; it should be \"scalar\", not \"' + state.kind + '\"');\n      }\n\n      for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {\n        type = state.implicitTypes[typeIndex];\n\n        if (type.resolve(state.result)) { // `state.result` updated in resolver if matched\n          state.result = type.construct(state.result);\n          state.tag = type.tag;\n          if (state.anchor !== null) {\n            state.anchorMap[state.anchor] = state.result;\n          }\n          break;\n        }\n      }\n    } else if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) {\n      type = state.typeMap[state.kind || 'fallback'][state.tag];\n\n      if (state.result !== null && type.kind !== state.kind) {\n        throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be \"' + type.kind + '\", not \"' + state.kind + '\"');\n      }\n\n      if (!type.resolve(state.result)) { // `state.result` updated in resolver if matched\n        throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');\n      } else {\n        state.result = type.construct(state.result);\n        if (state.anchor !== null) {\n          state.anchorMap[state.anchor] = state.result;\n        }\n      }\n    } else {\n      throwError(state, 'unknown tag !<' + state.tag + '>');\n    }\n  }\n\n  if (state.listener !== null) {\n    state.listener('close', state);\n  }\n  return state.tag !== null ||  state.anchor !== null || hasContent;\n}\n\nfunction readDocument(state) {\n  var documentStart = state.position,\n      _position,\n      directiveName,\n      directiveArgs,\n      hasDirectives = false,\n      ch;\n\n  state.version = null;\n  state.checkLineBreaks = state.legacy;\n  state.tagMap = {};\n  state.anchorMap = {};\n\n  while ((ch = state.input.charCodeAt(state.position)) !== 0) {\n    skipSeparationSpace(state, true, -1);\n\n    ch = state.input.charCodeAt(state.position);\n\n    if (state.lineIndent > 0 || ch !== 0x25/* % */) {\n      break;\n    }\n\n    hasDirectives = true;\n    ch = state.input.charCodeAt(++state.position);\n    _position = state.position;\n\n    while (ch !== 0 && !is_WS_OR_EOL(ch)) {\n      ch = state.input.charCodeAt(++state.position);\n    }\n\n    directiveName = state.input.slice(_position, state.position);\n    directiveArgs = [];\n\n    if (directiveName.length < 1) {\n      throwError(state, 'directive name must not be less than one character in length');\n    }\n\n    while (ch !== 0) {\n      while (is_WHITE_SPACE(ch)) {\n        ch = state.input.charCodeAt(++state.position);\n      }\n\n      if (ch === 0x23/* # */) {\n        do { ch = state.input.charCodeAt(++state.position); }\n        while (ch !== 0 && !is_EOL(ch));\n        break;\n      }\n\n      if (is_EOL(ch)) break;\n\n      _position = state.position;\n\n      while (ch !== 0 && !is_WS_OR_EOL(ch)) {\n        ch = state.input.charCodeAt(++state.position);\n      }\n\n      directiveArgs.push(state.input.slice(_position, state.position));\n    }\n\n    if (ch !== 0) readLineBreak(state);\n\n    if (_hasOwnProperty.call(directiveHandlers, directiveName)) {\n      directiveHandlers[directiveName](state, directiveName, directiveArgs);\n    } else {\n      throwWarning(state, 'unknown document directive \"' + directiveName + '\"');\n    }\n  }\n\n  skipSeparationSpace(state, true, -1);\n\n  if (state.lineIndent === 0 &&\n      state.input.charCodeAt(state.position)     === 0x2D/* - */ &&\n      state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&\n      state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {\n    state.position += 3;\n    skipSeparationSpace(state, true, -1);\n\n  } else if (hasDirectives) {\n    throwError(state, 'directives end mark is expected');\n  }\n\n  composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);\n  skipSeparationSpace(state, true, -1);\n\n  if (state.checkLineBreaks &&\n      PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {\n    throwWarning(state, 'non-ASCII line breaks are interpreted as content');\n  }\n\n  state.documents.push(state.result);\n\n  if (state.position === state.lineStart && testDocumentSeparator(state)) {\n\n    if (state.input.charCodeAt(state.position) === 0x2E/* . */) {\n      state.position += 3;\n      skipSeparationSpace(state, true, -1);\n    }\n    return;\n  }\n\n  if (state.position < (state.length - 1)) {\n    throwError(state, 'end of the stream or a document separator is expected');\n  } else {\n    return;\n  }\n}\n\n\nfunction loadDocuments(input, options) {\n  input = String(input);\n  options = options || {};\n\n  if (input.length !== 0) {\n\n    // Add tailing `\\n` if not exists\n    if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&\n        input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {\n      input += '\\n';\n    }\n\n    // Strip BOM\n    if (input.charCodeAt(0) === 0xFEFF) {\n      input = input.slice(1);\n    }\n  }\n\n  var state = new State(input, options);\n\n  var nullpos = input.indexOf('\\0');\n\n  if (nullpos !== -1) {\n    state.position = nullpos;\n    throwError(state, 'null byte is not allowed in input');\n  }\n\n  // Use 0 as string terminator. That significantly simplifies bounds check.\n  state.input += '\\0';\n\n  while (state.input.charCodeAt(state.position) === 0x20/* Space */) {\n    state.lineIndent += 1;\n    state.position += 1;\n  }\n\n  while (state.position < (state.length - 1)) {\n    readDocument(state);\n  }\n\n  return state.documents;\n}\n\n\nfunction loadAll(input, iterator, options) {\n  if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') {\n    options = iterator;\n    iterator = null;\n  }\n\n  var documents = loadDocuments(input, options);\n\n  if (typeof iterator !== 'function') {\n    return documents;\n  }\n\n  for (var index = 0, length = documents.length; index < length; index += 1) {\n    iterator(documents[index]);\n  }\n}\n\n\nfunction load(input, options) {\n  var documents = loadDocuments(input, options);\n\n  if (documents.length === 0) {\n    /*eslint-disable no-undefined*/\n    return undefined;\n  } else if (documents.length === 1) {\n    return documents[0];\n  }\n  throw new YAMLException('expected a single document in the stream, but found more');\n}\n\n\nfunction safeLoadAll(input, iterator, options) {\n  if (typeof iterator === 'object' && iterator !== null && typeof options === 'undefined') {\n    options = iterator;\n    iterator = null;\n  }\n\n  return loadAll(input, iterator, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));\n}\n\n\nfunction safeLoad(input, options) {\n  return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));\n}\n\n\nmodule.exports.loadAll     = loadAll;\nmodule.exports.load        = load;\nmodule.exports.safeLoadAll = safeLoadAll;\nmodule.exports.safeLoad    = safeLoad;\n", "'use strict';\n\n/*eslint-disable no-use-before-define*/\n\nvar common              = require('./common');\nvar YAMLException       = require('./exception');\nvar DEFAULT_FULL_SCHEMA = require('./schema/default_full');\nvar DEFAULT_SAFE_SCHEMA = require('./schema/default_safe');\n\nvar _toString       = Object.prototype.toString;\nvar _hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar CHAR_TAB                  = 0x09; /* Tab */\nvar CHAR_LINE_FEED            = 0x0A; /* LF */\nvar CHAR_CARRIAGE_RETURN      = 0x0D; /* CR */\nvar CHAR_SPACE                = 0x20; /* Space */\nvar CHAR_EXCLAMATION          = 0x21; /* ! */\nvar CHAR_DOUBLE_QUOTE         = 0x22; /* \" */\nvar CHAR_SHARP                = 0x23; /* # */\nvar CHAR_PERCENT              = 0x25; /* % */\nvar CHAR_AMPERSAND            = 0x26; /* & */\nvar CHAR_SINGLE_QUOTE         = 0x27; /* ' */\nvar CHAR_ASTERISK             = 0x2A; /* * */\nvar CHAR_COMMA                = 0x2C; /* , */\nvar CHAR_MINUS                = 0x2D; /* - */\nvar CHAR_COLON                = 0x3A; /* : */\nvar CHAR_EQUALS               = 0x3D; /* = */\nvar CHAR_GREATER_THAN         = 0x3E; /* > */\nvar CHAR_QUESTION             = 0x3F; /* ? */\nvar CHAR_COMMERCIAL_AT        = 0x40; /* @ */\nvar CHAR_LEFT_SQUARE_BRACKET  = 0x5B; /* [ */\nvar CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */\nvar CHAR_GRAVE_ACCENT         = 0x60; /* ` */\nvar CHAR_LEFT_CURLY_BRACKET   = 0x7B; /* { */\nvar CHAR_VERTICAL_LINE        = 0x7C; /* | */\nvar CHAR_RIGHT_CURLY_BRACKET  = 0x7D; /* } */\n\nvar ESCAPE_SEQUENCES = {};\n\nESCAPE_SEQUENCES[0x00]   = '\\\\0';\nESCAPE_SEQUENCES[0x07]   = '\\\\a';\nESCAPE_SEQUENCES[0x08]   = '\\\\b';\nESCAPE_SEQUENCES[0x09]   = '\\\\t';\nESCAPE_SEQUENCES[0x0A]   = '\\\\n';\nESCAPE_SEQUENCES[0x0B]   = '\\\\v';\nESCAPE_SEQUENCES[0x0C]   = '\\\\f';\nESCAPE_SEQUENCES[0x0D]   = '\\\\r';\nESCAPE_SEQUENCES[0x1B]   = '\\\\e';\nESCAPE_SEQUENCES[0x22]   = '\\\\\"';\nESCAPE_SEQUENCES[0x5C]   = '\\\\\\\\';\nESCAPE_SEQUENCES[0x85]   = '\\\\N';\nESCAPE_SEQUENCES[0xA0]   = '\\\\_';\nESCAPE_SEQUENCES[0x2028] = '\\\\L';\nESCAPE_SEQUENCES[0x2029] = '\\\\P';\n\nvar DEPRECATED_BOOLEANS_SYNTAX = [\n  'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',\n  'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'\n];\n\nfunction compileStyleMap(schema, map) {\n  var result, keys, index, length, tag, style, type;\n\n  if (map === null) return {};\n\n  result = {};\n  keys = Object.keys(map);\n\n  for (index = 0, length = keys.length; index < length; index += 1) {\n    tag = keys[index];\n    style = String(map[tag]);\n\n    if (tag.slice(0, 2) === '!!') {\n      tag = 'tag:yaml.org,2002:' + tag.slice(2);\n    }\n    type = schema.compiledTypeMap['fallback'][tag];\n\n    if (type && _hasOwnProperty.call(type.styleAliases, style)) {\n      style = type.styleAliases[style];\n    }\n\n    result[tag] = style;\n  }\n\n  return result;\n}\n\nfunction encodeHex(character) {\n  var string, handle, length;\n\n  string = character.toString(16).toUpperCase();\n\n  if (character <= 0xFF) {\n    handle = 'x';\n    length = 2;\n  } else if (character <= 0xFFFF) {\n    handle = 'u';\n    length = 4;\n  } else if (character <= 0xFFFFFFFF) {\n    handle = 'U';\n    length = 8;\n  } else {\n    throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF');\n  }\n\n  return '\\\\' + handle + common.repeat('0', length - string.length) + string;\n}\n\nfunction State(options) {\n  this.schema        = options['schema'] || DEFAULT_FULL_SCHEMA;\n  this.indent        = Math.max(1, (options['indent'] || 2));\n  this.noArrayIndent = options['noArrayIndent'] || false;\n  this.skipInvalid   = options['skipInvalid'] || false;\n  this.flowLevel     = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);\n  this.styleMap      = compileStyleMap(this.schema, options['styles'] || null);\n  this.sortKeys      = options['sortKeys'] || false;\n  this.lineWidth     = options['lineWidth'] || 80;\n  this.noRefs        = options['noRefs'] || false;\n  this.noCompatMode  = options['noCompatMode'] || false;\n  this.condenseFlow  = options['condenseFlow'] || false;\n\n  this.implicitTypes = this.schema.compiledImplicit;\n  this.explicitTypes = this.schema.compiledExplicit;\n\n  this.tag = null;\n  this.result = '';\n\n  this.duplicates = [];\n  this.usedDuplicates = null;\n}\n\n// Indents every line in a string. Empty lines (\\n only) are not indented.\nfunction indentString(string, spaces) {\n  var ind = common.repeat(' ', spaces),\n      position = 0,\n      next = -1,\n      result = '',\n      line,\n      length = string.length;\n\n  while (position < length) {\n    next = string.indexOf('\\n', position);\n    if (next === -1) {\n      line = string.slice(position);\n      position = length;\n    } else {\n      line = string.slice(position, next + 1);\n      position = next + 1;\n    }\n\n    if (line.length && line !== '\\n') result += ind;\n\n    result += line;\n  }\n\n  return result;\n}\n\nfunction generateNextLine(state, level) {\n  return '\\n' + common.repeat(' ', state.indent * level);\n}\n\nfunction testImplicitResolving(state, str) {\n  var index, length, type;\n\n  for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {\n    type = state.implicitTypes[index];\n\n    if (type.resolve(str)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n// [33] s-white ::= s-space | s-tab\nfunction isWhitespace(c) {\n  return c === CHAR_SPACE || c === CHAR_TAB;\n}\n\n// Returns true if the character can be printed without escaping.\n// From YAML 1.2: \"any allowed characters known to be non-printable\n// should also be escaped. [However,] This isn\u2019t mandatory\"\n// Derived from nb-char - \\t - #x85 - #xA0 - #x2028 - #x2029.\nfunction isPrintable(c) {\n  return  (0x00020 <= c && c <= 0x00007E)\n      || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)\n      || ((0x0E000 <= c && c <= 0x00FFFD) && c !== 0xFEFF /* BOM */)\n      ||  (0x10000 <= c && c <= 0x10FFFF);\n}\n\n// [34] ns-char ::= nb-char - s-white\n// [27] nb-char ::= c-printable - b-char - c-byte-order-mark\n// [26] b-char  ::= b-line-feed | b-carriage-return\n// [24] b-line-feed       ::=     #xA    /* LF */\n// [25] b-carriage-return ::=     #xD    /* CR */\n// [3]  c-byte-order-mark ::=     #xFEFF\nfunction isNsChar(c) {\n  return isPrintable(c) && !isWhitespace(c)\n    // byte-order-mark\n    && c !== 0xFEFF\n    // b-char\n    && c !== CHAR_CARRIAGE_RETURN\n    && c !== CHAR_LINE_FEED;\n}\n\n// Simplified test for values allowed after the first character in plain style.\nfunction isPlainSafe(c, prev) {\n  // Uses a subset of nb-char - c-flow-indicator - \":\" - \"#\"\n  // where nb-char ::= c-printable - b-char - c-byte-order-mark.\n  return isPrintable(c) && c !== 0xFEFF\n    // - c-flow-indicator\n    && c !== CHAR_COMMA\n    && c !== CHAR_LEFT_SQUARE_BRACKET\n    && c !== CHAR_RIGHT_SQUARE_BRACKET\n    && c !== CHAR_LEFT_CURLY_BRACKET\n    && c !== CHAR_RIGHT_CURLY_BRACKET\n    // - \":\" - \"#\"\n    // /* An ns-char preceding */ \"#\"\n    && c !== CHAR_COLON\n    && ((c !== CHAR_SHARP) || (prev && isNsChar(prev)));\n}\n\n// Simplified test for values allowed as the first character in plain style.\nfunction isPlainSafeFirst(c) {\n  // Uses a subset of ns-char - c-indicator\n  // where ns-char = nb-char - s-white.\n  return isPrintable(c) && c !== 0xFEFF\n    && !isWhitespace(c) // - s-white\n    // - (c-indicator ::=\n    // \u201C-\u201D | \u201C?\u201D | \u201C:\u201D | \u201C,\u201D | \u201C[\u201D | \u201C]\u201D | \u201C{\u201D | \u201C}\u201D\n    && c !== CHAR_MINUS\n    && c !== CHAR_QUESTION\n    && c !== CHAR_COLON\n    && c !== CHAR_COMMA\n    && c !== CHAR_LEFT_SQUARE_BRACKET\n    && c !== CHAR_RIGHT_SQUARE_BRACKET\n    && c !== CHAR_LEFT_CURLY_BRACKET\n    && c !== CHAR_RIGHT_CURLY_BRACKET\n    // | \u201C#\u201D | \u201C&\u201D | \u201C*\u201D | \u201C!\u201D | \u201C|\u201D | \u201C=\u201D | \u201C>\u201D | \u201C'\u201D | \u201C\"\u201D\n    && c !== CHAR_SHARP\n    && c !== CHAR_AMPERSAND\n    && c !== CHAR_ASTERISK\n    && c !== CHAR_EXCLAMATION\n    && c !== CHAR_VERTICAL_LINE\n    && c !== CHAR_EQUALS\n    && c !== CHAR_GREATER_THAN\n    && c !== CHAR_SINGLE_QUOTE\n    && c !== CHAR_DOUBLE_QUOTE\n    // | \u201C%\u201D | \u201C@\u201D | \u201C`\u201D)\n    && c !== CHAR_PERCENT\n    && c !== CHAR_COMMERCIAL_AT\n    && c !== CHAR_GRAVE_ACCENT;\n}\n\n// Determines whether block indentation indicator is required.\nfunction needIndentIndicator(string) {\n  var leadingSpaceRe = /^\\n* /;\n  return leadingSpaceRe.test(string);\n}\n\nvar STYLE_PLAIN   = 1,\n    STYLE_SINGLE  = 2,\n    STYLE_LITERAL = 3,\n    STYLE_FOLDED  = 4,\n    STYLE_DOUBLE  = 5;\n\n// Determines which scalar styles are possible and returns the preferred style.\n// lineWidth = -1 => no limit.\n// Pre-conditions: str.length > 0.\n// Post-conditions:\n//    STYLE_PLAIN or STYLE_SINGLE => no \\n are in the string.\n//    STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).\n//    STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).\nfunction chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) {\n  var i;\n  var char, prev_char;\n  var hasLineBreak = false;\n  var hasFoldableLine = false; // only checked if shouldTrackWidth\n  var shouldTrackWidth = lineWidth !== -1;\n  var previousLineBreak = -1; // count the first line correctly\n  var plain = isPlainSafeFirst(string.charCodeAt(0))\n          && !isWhitespace(string.charCodeAt(string.length - 1));\n\n  if (singleLineOnly) {\n    // Case: no block styles.\n    // Check for disallowed characters to rule out plain and single.\n    for (i = 0; i < string.length; i++) {\n      char = string.charCodeAt(i);\n      if (!isPrintable(char)) {\n        return STYLE_DOUBLE;\n      }\n      prev_char = i > 0 ? string.charCodeAt(i - 1) : null;\n      plain = plain && isPlainSafe(char, prev_char);\n    }\n  } else {\n    // Case: block styles permitted.\n    for (i = 0; i < string.length; i++) {\n      char = string.charCodeAt(i);\n      if (char === CHAR_LINE_FEED) {\n        hasLineBreak = true;\n        // Check if any line can be folded.\n        if (shouldTrackWidth) {\n          hasFoldableLine = hasFoldableLine ||\n            // Foldable line = too long, and not more-indented.\n            (i - previousLineBreak - 1 > lineWidth &&\n             string[previousLineBreak + 1] !== ' ');\n          previousLineBreak = i;\n        }\n      } else if (!isPrintable(char)) {\n        return STYLE_DOUBLE;\n      }\n      prev_char = i > 0 ? string.charCodeAt(i - 1) : null;\n      plain = plain && isPlainSafe(char, prev_char);\n    }\n    // in case the end is missing a \\n\n    hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&\n      (i - previousLineBreak - 1 > lineWidth &&\n       string[previousLineBreak + 1] !== ' '));\n  }\n  // Although every style can represent \\n without escaping, prefer block styles\n  // for multiline, since they're more readable and they don't add empty lines.\n  // Also prefer folding a super-long line.\n  if (!hasLineBreak && !hasFoldableLine) {\n    // Strings interpretable as another type have to be quoted;\n    // e.g. the string 'true' vs. the boolean true.\n    return plain && !testAmbiguousType(string)\n      ? STYLE_PLAIN : STYLE_SINGLE;\n  }\n  // Edge case: block indentation indicator can only have one digit.\n  if (indentPerLevel > 9 && needIndentIndicator(string)) {\n    return STYLE_DOUBLE;\n  }\n  // At this point we know block styles are valid.\n  // Prefer literal style unless we want to fold.\n  return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;\n}\n\n// Note: line breaking/folding is implemented for only the folded style.\n// NB. We drop the last trailing newline (if any) of a returned block scalar\n//  since the dumper adds its own newline. This always works:\n//    \u2022 No ending newline => unaffected; already using strip \"-\" chomping.\n//    \u2022 Ending newline    => removed then restored.\n//  Importantly, this keeps the \"+\" chomp indicator from gaining an extra line.\nfunction writeScalar(state, string, level, iskey) {\n  state.dump = (function () {\n    if (string.length === 0) {\n      return \"''\";\n    }\n    if (!state.noCompatMode &&\n        DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) {\n      return \"'\" + string + \"'\";\n    }\n\n    var indent = state.indent * Math.max(1, level); // no 0-indent scalars\n    // As indentation gets deeper, let the width decrease monotonically\n    // to the lower bound min(state.lineWidth, 40).\n    // Note that this implies\n    //  state.lineWidth \u2264 40 + state.indent: width is fixed at the lower bound.\n    //  state.lineWidth > 40 + state.indent: width decreases until the lower bound.\n    // This behaves better than a constant minimum width which disallows narrower options,\n    // or an indent threshold which causes the width to suddenly increase.\n    var lineWidth = state.lineWidth === -1\n      ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);\n\n    // Without knowing if keys are implicit/explicit, assume implicit for safety.\n    var singleLineOnly = iskey\n      // No block styles in flow mode.\n      || (state.flowLevel > -1 && level >= state.flowLevel);\n    function testAmbiguity(string) {\n      return testImplicitResolving(state, string);\n    }\n\n    switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) {\n      case STYLE_PLAIN:\n        return string;\n      case STYLE_SINGLE:\n        return \"'\" + string.replace(/'/g, \"''\") + \"'\";\n      case STYLE_LITERAL:\n        return '|' + blockHeader(string, state.indent)\n          + dropEndingNewline(indentString(string, indent));\n      case STYLE_FOLDED:\n        return '>' + blockHeader(string, state.indent)\n          + dropEndingNewline(indentString(foldString(string, lineWidth), indent));\n      case STYLE_DOUBLE:\n        return '\"' + escapeString(string, lineWidth) + '\"';\n      default:\n        throw new YAMLException('impossible error: invalid scalar style');\n    }\n  }());\n}\n\n// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.\nfunction blockHeader(string, indentPerLevel) {\n  var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';\n\n  // note the special case: the string '\\n' counts as a \"trailing\" empty line.\n  var clip =          string[string.length - 1] === '\\n';\n  var keep = clip && (string[string.length - 2] === '\\n' || string === '\\n');\n  var chomp = keep ? '+' : (clip ? '' : '-');\n\n  return indentIndicator + chomp + '\\n';\n}\n\n// (See the note for writeScalar.)\nfunction dropEndingNewline(string) {\n  return string[string.length - 1] === '\\n' ? string.slice(0, -1) : string;\n}\n\n// Note: a long line without a suitable break point will exceed the width limit.\n// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.\nfunction foldString(string, width) {\n  // In folded style, $k$ consecutive newlines output as $k+1$ newlines\u2014\n  // unless they're before or after a more-indented line, or at the very\n  // beginning or end, in which case $k$ maps to $k$.\n  // Therefore, parse each chunk as newline(s) followed by a content line.\n  var lineRe = /(\\n+)([^\\n]*)/g;\n\n  // first line (possibly an empty line)\n  var result = (function () {\n    var nextLF = string.indexOf('\\n');\n    nextLF = nextLF !== -1 ? nextLF : string.length;\n    lineRe.lastIndex = nextLF;\n    return foldLine(string.slice(0, nextLF), width);\n  }());\n  // If we haven't reached the first content line yet, don't add an extra \\n.\n  var prevMoreIndented = string[0] === '\\n' || string[0] === ' ';\n  var moreIndented;\n\n  // rest of the lines\n  var match;\n  while ((match = lineRe.exec(string))) {\n    var prefix = match[1], line = match[2];\n    moreIndented = (line[0] === ' ');\n    result += prefix\n      + (!prevMoreIndented && !moreIndented && line !== ''\n        ? '\\n' : '')\n      + foldLine(line, width);\n    prevMoreIndented = moreIndented;\n  }\n\n  return result;\n}\n\n// Greedy line breaking.\n// Picks the longest line under the limit each time,\n// otherwise settles for the shortest line over the limit.\n// NB. More-indented lines *cannot* be folded, as that would add an extra \\n.\nfunction foldLine(line, width) {\n  if (line === '' || line[0] === ' ') return line;\n\n  // Since a more-indented line adds a \\n, breaks can't be followed by a space.\n  var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.\n  var match;\n  // start is an inclusive index. end, curr, and next are exclusive.\n  var start = 0, end, curr = 0, next = 0;\n  var result = '';\n\n  // Invariants: 0 <= start <= length-1.\n  //   0 <= curr <= next <= max(0, length-2). curr - start <= width.\n  // Inside the loop:\n  //   A match implies length >= 2, so curr and next are <= length-2.\n  while ((match = breakRe.exec(line))) {\n    next = match.index;\n    // maintain invariant: curr - start <= width\n    if (next - start > width) {\n      end = (curr > start) ? curr : next; // derive end <= length-2\n      result += '\\n' + line.slice(start, end);\n      // skip the space that was output as \\n\n      start = end + 1;                    // derive start <= length-1\n    }\n    curr = next;\n  }\n\n  // By the invariants, start <= length-1, so there is something left over.\n  // It is either the whole string or a part starting from non-whitespace.\n  result += '\\n';\n  // Insert a break if the remainder is too long and there is a break available.\n  if (line.length - start > width && curr > start) {\n    result += line.slice(start, curr) + '\\n' + line.slice(curr + 1);\n  } else {\n    result += line.slice(start);\n  }\n\n  return result.slice(1); // drop extra \\n joiner\n}\n\n// Escapes a double-quoted string.\nfunction escapeString(string) {\n  var result = '';\n  var char, nextChar;\n  var escapeSeq;\n\n  for (var i = 0; i < string.length; i++) {\n    char = string.charCodeAt(i);\n    // Check for surrogate pairs (reference Unicode 3.0 section \"3.7 Surrogates\").\n    if (char >= 0xD800 && char <= 0xDBFF/* high surrogate */) {\n      nextChar = string.charCodeAt(i + 1);\n      if (nextChar >= 0xDC00 && nextChar <= 0xDFFF/* low surrogate */) {\n        // Combine the surrogate pair and store it escaped.\n        result += encodeHex((char - 0xD800) * 0x400 + nextChar - 0xDC00 + 0x10000);\n        // Advance index one extra since we already used that char here.\n        i++; continue;\n      }\n    }\n    escapeSeq = ESCAPE_SEQUENCES[char];\n    result += !escapeSeq && isPrintable(char)\n      ? string[i]\n      : escapeSeq || encodeHex(char);\n  }\n\n  return result;\n}\n\nfunction writeFlowSequence(state, level, object) {\n  var _result = '',\n      _tag    = state.tag,\n      index,\n      length;\n\n  for (index = 0, length = object.length; index < length; index += 1) {\n    // Write only valid elements.\n    if (writeNode(state, level, object[index], false, false)) {\n      if (index !== 0) _result += ',' + (!state.condenseFlow ? ' ' : '');\n      _result += state.dump;\n    }\n  }\n\n  state.tag = _tag;\n  state.dump = '[' + _result + ']';\n}\n\nfunction writeBlockSequence(state, level, object, compact) {\n  var _result = '',\n      _tag    = state.tag,\n      index,\n      length;\n\n  for (index = 0, length = object.length; index < length; index += 1) {\n    // Write only valid elements.\n    if (writeNode(state, level + 1, object[index], true, true)) {\n      if (!compact || index !== 0) {\n        _result += generateNextLine(state, level);\n      }\n\n      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {\n        _result += '-';\n      } else {\n        _result += '- ';\n      }\n\n      _result += state.dump;\n    }\n  }\n\n  state.tag = _tag;\n  state.dump = _result || '[]'; // Empty sequence if no valid values.\n}\n\nfunction writeFlowMapping(state, level, object) {\n  var _result       = '',\n      _tag          = state.tag,\n      objectKeyList = Object.keys(object),\n      index,\n      length,\n      objectKey,\n      objectValue,\n      pairBuffer;\n\n  for (index = 0, length = objectKeyList.length; index < length; index += 1) {\n\n    pairBuffer = '';\n    if (index !== 0) pairBuffer += ', ';\n\n    if (state.condenseFlow) pairBuffer += '\"';\n\n    objectKey = objectKeyList[index];\n    objectValue = object[objectKey];\n\n    if (!writeNode(state, level, objectKey, false, false)) {\n      continue; // Skip this pair because of invalid key;\n    }\n\n    if (state.dump.length > 1024) pairBuffer += '? ';\n\n    pairBuffer += state.dump + (state.condenseFlow ? '\"' : '') + ':' + (state.condenseFlow ? '' : ' ');\n\n    if (!writeNode(state, level, objectValue, false, false)) {\n      continue; // Skip this pair because of invalid value.\n    }\n\n    pairBuffer += state.dump;\n\n    // Both key and value are valid.\n    _result += pairBuffer;\n  }\n\n  state.tag = _tag;\n  state.dump = '{' + _result + '}';\n}\n\nfunction writeBlockMapping(state, level, object, compact) {\n  var _result       = '',\n      _tag          = state.tag,\n      objectKeyList = Object.keys(object),\n      index,\n      length,\n      objectKey,\n      objectValue,\n      explicitPair,\n      pairBuffer;\n\n  // Allow sorting keys so that the output file is deterministic\n  if (state.sortKeys === true) {\n    // Default sorting\n    objectKeyList.sort();\n  } else if (typeof state.sortKeys === 'function') {\n    // Custom sort function\n    objectKeyList.sort(state.sortKeys);\n  } else if (state.sortKeys) {\n    // Something is wrong\n    throw new YAMLException('sortKeys must be a boolean or a function');\n  }\n\n  for (index = 0, length = objectKeyList.length; index < length; index += 1) {\n    pairBuffer = '';\n\n    if (!compact || index !== 0) {\n      pairBuffer += generateNextLine(state, level);\n    }\n\n    objectKey = objectKeyList[index];\n    objectValue = object[objectKey];\n\n    if (!writeNode(state, level + 1, objectKey, true, true, true)) {\n      continue; // Skip this pair because of invalid key.\n    }\n\n    explicitPair = (state.tag !== null && state.tag !== '?') ||\n                   (state.dump && state.dump.length > 1024);\n\n    if (explicitPair) {\n      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {\n        pairBuffer += '?';\n      } else {\n        pairBuffer += '? ';\n      }\n    }\n\n    pairBuffer += state.dump;\n\n    if (explicitPair) {\n      pairBuffer += generateNextLine(state, level);\n    }\n\n    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {\n      continue; // Skip this pair because of invalid value.\n    }\n\n    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {\n      pairBuffer += ':';\n    } else {\n      pairBuffer += ': ';\n    }\n\n    pairBuffer += state.dump;\n\n    // Both key and value are valid.\n    _result += pairBuffer;\n  }\n\n  state.tag = _tag;\n  state.dump = _result || '{}'; // Empty mapping if no valid pairs.\n}\n\nfunction detectType(state, object, explicit) {\n  var _result, typeList, index, length, type, style;\n\n  typeList = explicit ? state.explicitTypes : state.implicitTypes;\n\n  for (index = 0, length = typeList.length; index < length; index += 1) {\n    type = typeList[index];\n\n    if ((type.instanceOf  || type.predicate) &&\n        (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&\n        (!type.predicate  || type.predicate(object))) {\n\n      state.tag = explicit ? type.tag : '?';\n\n      if (type.represent) {\n        style = state.styleMap[type.tag] || type.defaultStyle;\n\n        if (_toString.call(type.represent) === '[object Function]') {\n          _result = type.represent(object, style);\n        } else if (_hasOwnProperty.call(type.represent, style)) {\n          _result = type.represent[style](object, style);\n        } else {\n          throw new YAMLException('!<' + type.tag + '> tag resolver accepts not \"' + style + '\" style');\n        }\n\n        state.dump = _result;\n      }\n\n      return true;\n    }\n  }\n\n  return false;\n}\n\n// Serializes `object` and writes it to global `result`.\n// Returns true on success, or false on invalid object.\n//\nfunction writeNode(state, level, object, block, compact, iskey) {\n  state.tag = null;\n  state.dump = object;\n\n  if (!detectType(state, object, false)) {\n    detectType(state, object, true);\n  }\n\n  var type = _toString.call(state.dump);\n\n  if (block) {\n    block = (state.flowLevel < 0 || state.flowLevel > level);\n  }\n\n  var objectOrArray = type === '[object Object]' || type === '[object Array]',\n      duplicateIndex,\n      duplicate;\n\n  if (objectOrArray) {\n    duplicateIndex = state.duplicates.indexOf(object);\n    duplicate = duplicateIndex !== -1;\n  }\n\n  if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {\n    compact = false;\n  }\n\n  if (duplicate && state.usedDuplicates[duplicateIndex]) {\n    state.dump = '*ref_' + duplicateIndex;\n  } else {\n    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {\n      state.usedDuplicates[duplicateIndex] = true;\n    }\n    if (type === '[object Object]') {\n      if (block && (Object.keys(state.dump).length !== 0)) {\n        writeBlockMapping(state, level, state.dump, compact);\n        if (duplicate) {\n          state.dump = '&ref_' + duplicateIndex + state.dump;\n        }\n      } else {\n        writeFlowMapping(state, level, state.dump);\n        if (duplicate) {\n          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;\n        }\n      }\n    } else if (type === '[object Array]') {\n      var arrayLevel = (state.noArrayIndent && (level > 0)) ? level - 1 : level;\n      if (block && (state.dump.length !== 0)) {\n        writeBlockSequence(state, arrayLevel, state.dump, compact);\n        if (duplicate) {\n          state.dump = '&ref_' + duplicateIndex + state.dump;\n        }\n      } else {\n        writeFlowSequence(state, arrayLevel, state.dump);\n        if (duplicate) {\n          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;\n        }\n      }\n    } else if (type === '[object String]') {\n      if (state.tag !== '?') {\n        writeScalar(state, state.dump, level, iskey);\n      }\n    } else {\n      if (state.skipInvalid) return false;\n      throw new YAMLException('unacceptable kind of an object to dump ' + type);\n    }\n\n    if (state.tag !== null && state.tag !== '?') {\n      state.dump = '!<' + state.tag + '> ' + state.dump;\n    }\n  }\n\n  return true;\n}\n\nfunction getDuplicateReferences(object, state) {\n  var objects = [],\n      duplicatesIndexes = [],\n      index,\n      length;\n\n  inspectNode(object, objects, duplicatesIndexes);\n\n  for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {\n    state.duplicates.push(objects[duplicatesIndexes[index]]);\n  }\n  state.usedDuplicates = new Array(length);\n}\n\nfunction inspectNode(object, objects, duplicatesIndexes) {\n  var objectKeyList,\n      index,\n      length;\n\n  if (object !== null && typeof object === 'object') {\n    index = objects.indexOf(object);\n    if (index !== -1) {\n      if (duplicatesIndexes.indexOf(index) === -1) {\n        duplicatesIndexes.push(index);\n      }\n    } else {\n      objects.push(object);\n\n      if (Array.isArray(object)) {\n        for (index = 0, length = object.length; index < length; index += 1) {\n          inspectNode(object[index], objects, duplicatesIndexes);\n        }\n      } else {\n        objectKeyList = Object.keys(object);\n\n        for (index = 0, length = objectKeyList.length; index < length; index += 1) {\n          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);\n        }\n      }\n    }\n  }\n}\n\nfunction dump(input, options) {\n  options = options || {};\n\n  var state = new State(options);\n\n  if (!state.noRefs) getDuplicateReferences(input, state);\n\n  if (writeNode(state, 0, input, true, true)) return state.dump + '\\n';\n\n  return '';\n}\n\nfunction safeDump(input, options) {\n  return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));\n}\n\nmodule.exports.dump     = dump;\nmodule.exports.safeDump = safeDump;\n", "'use strict';\n\n\nvar loader = require('./js-yaml/loader');\nvar dumper = require('./js-yaml/dumper');\n\n\nfunction deprecated(name) {\n  return function () {\n    throw new Error('Function ' + name + ' is deprecated and cannot be used.');\n  };\n}\n\n\nmodule.exports.Type                = require('./js-yaml/type');\nmodule.exports.Schema              = require('./js-yaml/schema');\nmodule.exports.FAILSAFE_SCHEMA     = require('./js-yaml/schema/failsafe');\nmodule.exports.JSON_SCHEMA         = require('./js-yaml/schema/json');\nmodule.exports.CORE_SCHEMA         = require('./js-yaml/schema/core');\nmodule.exports.DEFAULT_SAFE_SCHEMA = require('./js-yaml/schema/default_safe');\nmodule.exports.DEFAULT_FULL_SCHEMA = require('./js-yaml/schema/default_full');\nmodule.exports.load                = loader.load;\nmodule.exports.loadAll             = loader.loadAll;\nmodule.exports.safeLoad            = loader.safeLoad;\nmodule.exports.safeLoadAll         = loader.safeLoadAll;\nmodule.exports.dump                = dumper.dump;\nmodule.exports.safeDump            = dumper.safeDump;\nmodule.exports.YAMLException       = require('./js-yaml/exception');\n\n// Deprecated schema names from JS-YAML 2.0.x\nmodule.exports.MINIMAL_SCHEMA = require('./js-yaml/schema/failsafe');\nmodule.exports.SAFE_SCHEMA    = require('./js-yaml/schema/default_safe');\nmodule.exports.DEFAULT_SCHEMA = require('./js-yaml/schema/default_full');\n\n// Deprecated functions from JS-YAML 1.x.x\nmodule.exports.scan           = deprecated('scan');\nmodule.exports.parse          = deprecated('parse');\nmodule.exports.compose        = deprecated('compose');\nmodule.exports.addConstructor = deprecated('addConstructor');\n", "'use strict';\n\n\nvar yaml = require('./lib/js-yaml.js');\n\n\nmodule.exports = yaml;\n", "import { timingSafeEqual } from \"crypto\";\nimport {\n\tApp,\n\tEditableFileView,\n\trequestUrl,\n\tEditor,\n\tMarkdownView,\n\tModal,\n\tNotice,\n\tPlugin,\n\tPluginSettingTab,\n\tSetting,\n} from \"obsidian\";\nimport { join } from \"path\";\nimport * as fs from \"fs\";\nimport {addIcons}  from 'icon';\nimport { Upload2Notion } from \"Upload2Notion\";\n\n// Remember to rename these classes and interfaces!\n\ninterface MyPluginSettings {\n\tnotionAPI: string;\n\tdatabaseID: string;\n\tproxy: string;\n}\n\nconst DEFAULT_SETTINGS: MyPluginSettings = {\n\tnotionAPI: \"\",\n\tdatabaseID: \"\",\n\tproxy: \"\",\n};\n\nexport default class MyPlugin extends Plugin {\n\tsettings: MyPluginSettings;\n\t\n\tasync onload() {\n\t\tawait this.loadSettings();\n\t\taddIcons();\n\t\t// This creates an icon in the left ribbon.\n\t\tconst ribbonIconEl = this.addRibbonIcon(\n\t\t\t\"notion-logo\",\n\t\t\t\"Share to notion\",\n\t\t\tasync (evt: MouseEvent) => {\n\t\t\t\t// Called when the user clicks the icon.\n\t\t\t\tthis.upload();\n\t\t\t}\n\t\t);\n\t\t// Perform additional things with the ribbon\n\t\tribbonIconEl.addClass(\"my-plugin-ribbon-class\");\n\n\t\t// This adds a status bar item to the bottom of the app. Does not work on mobile apps.\n\t\tconst statusBarItemEl = this.addStatusBarItem();\n\t\t// statusBarItemEl.setText(\"share to notion\");\n\n\t\tthis.addCommand({\n\t\t\tid: \"share-to-notion\",\n\t\t\tname: \"share to notion\",\n\t\t\teditorCallback: async (editor: Editor, view: MarkdownView) => {\n\t\t\t\tthis.upload()\n\t\t\t},\n\t\t});\n\n\n\t\t// This adds a settings tab so the user can configure various aspects of the plugin\n\t\tthis.addSettingTab(new SampleSettingTab(this.app, this));\n\n\t}\n\n\tonunload() {}\n\n\tasync upload(){\n\t\tconst { notionAPI, databaseID } = this.settings;\n\t\t\t\tif (notionAPI === \"\" || databaseID === \"\") {\n\t\t\t\t\tnew Notice(\n\t\t\t\t\t\t\"Please set up the notion API and database ID in the settings tab.\"\n\t\t\t\t\t);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tconst { nowFile, fileData,fullPath } =\n\t\t\t\t\tawait this.getNowFileMarkdwonContent(this.app);\n\t\t\t\tconst { basename } = nowFile;\n\t\t\t\tif (fileData) {\n\t\t\t\t\tconst upload = new Upload2Notion(this);\n\t\t\t\t\tconst res = await upload.syncMarkdownToNotion(basename,fileData, fullPath)\n\t\t\t\t\tconsole.log(res)\n\t\t\t\t\tif(res.status === 200){\n\t\t\t\t\t\tnew Notice(`${basename} \u540C\u6B65\u6210\u529F`)\n\t\t\t\t\t}else {\n\t\t\t\t\t\tnew Notice(`${basename} \u540C\u6B65\u5931\u8D25`)\n\t\t\t\t\t}\n\t\t\t\t}\n\t}\n\n\tasync getNowFileMarkdwonContent(app: App) {\n\t\tconst nowFile = app.workspace.getActiveFile();\n\t\tif (nowFile) {\n\t\t\tconst filePath: string = nowFile.path;\n\t\t\tconst basePath: string = nowFile.vault.adapter.basePath;\n\t\t\tconst fullPath = join(basePath, filePath);\n\t\t\tconsole.log(\"fullpath\", fullPath);\n\t\t\tconst fileData = fs.readFileSync(fullPath, \"utf8\");\n\t\t\treturn {\n\t\t\t\tfileData,\n\t\t\t\tnowFile,\n\t\t\t\tfullPath,\n\t\t\t};\n\t\t} else {\n\t\t\tnew Notice(\"\u8BF7\u6253\u5F00\u9700\u8981\u540C\u6B65\u7684\u6587\u4EF6\");\n\t\t\treturn;\n\t\t}\n\t}\n\n\tasync loadSettings() {\n\t\tthis.settings = Object.assign(\n\t\t\t{},\n\t\t\tDEFAULT_SETTINGS,\n\t\t\tawait this.loadData()\n\t\t);\n\t}\n\n\tasync saveSettings() {\n\t\tawait this.saveData(this.settings);\n\t}\n}\n\nclass SampleModal extends Modal {\n\tconstructor(app: App) {\n\t\tsuper(app);\n\t}\n\n\tonOpen() {\n\t\tconst { contentEl } = this;\n\t\tcontentEl.setText(\"Woah!\");\n\t}\n\n\tonClose() {\n\t\tconst { contentEl } = this;\n\t\tcontentEl.empty();\n\t}\n}\n\nclass SampleSettingTab extends PluginSettingTab {\n\tplugin: MyPlugin;\n\n\tconstructor(app: App, plugin: MyPlugin) {\n\t\tsuper(app, plugin);\n\t\tthis.plugin = plugin;\n\t}\n\n\tdisplay(): void {\n\t\tconst { containerEl } = this;\n\n\t\tcontainerEl.empty();\n\n\t\tcontainerEl.createEl(\"h2\", {\n\t\t\ttext: \"Settings for obsidian to notion plugin.\",\n\t\t});\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName(\"Notion API Token\")\n\t\t\t.setDesc(\"It's a secret\")\n\t\t\t.addText((text) =>\n\t\t\t\ttext\n\t\t\t\t\t.setPlaceholder(\"Enter your Notion API Token\")\n\t\t\t\t\t.setValue(this.plugin.settings.notionAPI)\n\t\t\t\t\t.onChange(async (value) => {\n\t\t\t\t\t\tconsole.log(\"Secret: \" + value);\n\t\t\t\t\t\tthis.plugin.settings.notionAPI = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName(\"Database ID\")\n\t\t\t.setDesc(\"It's a secret\")\n\t\t\t.addText((text) =>\n\t\t\t\ttext\n\t\t\t\t\t.setPlaceholder(\"Enter your Database ID\")\n\t\t\t\t\t.setValue(this.plugin.settings.databaseID)\n\t\t\t\t\t.onChange(async (value) => {\n\t\t\t\t\t\tconsole.log(\"Secret: \" + value);\n\t\t\t\t\t\tthis.plugin.settings.databaseID = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t}\n}\n", "import { addIcon } from 'obsidian';\n\nconst icons: Record<string, string> = {\n  'notion-logo': `\n  <svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"100px\" height=\"100px\" viewBox=\"0 0 100 100\" version=\"1.1\">\n<g id=\"surface1\">\n<path style=\" stroke:none;fill-rule:evenodd;fill:currentColor;fill-opacity:1;\" d=\"M 18.738281 17.796875 C 21.832031 20.308594 22.996094 20.117188 28.804688 19.730469 L 83.582031 16.441406 C 84.746094 16.441406 83.78125 15.28125 83.390625 15.089844 L 74.292969 8.511719 C 72.550781 7.160156 70.230469 5.609375 65.777344 5.996094 L 12.734375 9.867188 C 10.800781 10.058594 10.414062 11.023438 11.183594 11.800781 Z M 22.027344 30.5625 L 22.027344 88.199219 C 22.027344 91.296875 23.574219 92.457031 27.058594 92.265625 L 87.261719 88.78125 C 90.746094 88.589844 91.136719 86.457031 91.136719 83.941406 L 91.136719 26.691406 C 91.136719 24.179688 90.167969 22.824219 88.035156 23.019531 L 25.125 26.691406 C 22.800781 26.886719 22.027344 28.046875 22.027344 30.5625 Z M 81.460938 33.652344 C 81.84375 35.398438 81.460938 37.136719 79.714844 37.332031 L 76.8125 37.910156 L 76.8125 80.460938 C 74.292969 81.816406 71.972656 82.589844 70.035156 82.589844 C 66.9375 82.589844 66.164062 81.621094 63.839844 78.722656 L 44.867188 48.9375 L 44.867188 77.753906 L 50.871094 79.109375 C 50.871094 79.109375 50.871094 82.589844 46.027344 82.589844 L 32.675781 83.363281 C 32.285156 82.589844 32.675781 80.65625 34.027344 80.269531 L 37.511719 79.304688 L 37.511719 41.199219 L 32.675781 40.8125 C 32.285156 39.070312 33.253906 36.558594 35.964844 36.363281 L 50.292969 35.398438 L 70.035156 65.570312 L 70.035156 38.878906 L 65.003906 38.300781 C 64.617188 36.171875 66.164062 34.625 68.097656 34.433594 Z M 8.28125 4.644531 L 63.453125 0.582031 C 70.230469 0 71.972656 0.390625 76.230469 3.484375 L 93.84375 15.859375 C 96.75 17.988281 97.71875 18.570312 97.71875 20.890625 L 97.71875 88.78125 C 97.71875 93.035156 96.167969 95.550781 90.75 95.9375 L 26.675781 99.804688 C 22.609375 100 20.671875 99.421875 18.542969 96.710938 L 5.574219 79.882812 C 3.25 76.785156 2.28125 74.46875 2.28125 71.757812 L 2.28125 11.410156 C 2.28125 7.933594 3.832031 5.03125 8.28125 4.644531 Z M 8.28125 4.644531 \"/>\n</g>\n</svg>\n  `\n};\n\nexport const addIcons = (): void => {\n  Object.keys(icons).forEach((key) => {\n    addIcon(key, icons[key]);\n  });\n};\n", "import { requestUrl } from \"obsidian\";\nimport { Client } from \"@notionhq/client\";\nimport { markdownToBlocks,  } from \"@tryfabric/martian\";\nimport * as fs from \"fs\";\nimport * as yamlFrontMatter from \"yaml-front-matter\";\nimport * as yaml from \"yaml\"\nimport MyPlugin from \"main\";\n\nexport class Upload2Notion {\n\tapp: MyPlugin;\n\tnotion: Client;\n\tagent: any;\n\tconstructor(app: MyPlugin) {\n\t\tthis.app = app;\n\t}\n\tasync createPage(title:string, childArr: any) {\n\t\tconst bodyString = {\n\t\t\tparent: { \n\t\t\t\tdatabase_id: this.app.settings.databaseID \n\t\t\t},\n\t\t\tproperties: {\n\t\t\t\tName: {\n\t\t\t\t\ttitle: [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\ttext: {\n\t\t\t\t\t\t\t\tcontent: title,\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t],\n\t\t\t\t},\n\t\t\t},\n\t\t\tchildren: childArr,\n\t\t}\n\t\tconst response = await requestUrl({\n\t\t\turl: `https://api.notion.com/v1/pages`,\n\t\t\tmethod: 'POST',\n\t\t\theaders: {\n\t\t\t\t'Content-Type': 'application/json',\n\t\t\t\t// 'User-Agent': 'obsidian.md',\n\t\t\t\t'Authorization': 'Bearer ' + this.app.settings.notionAPI,\n\t\t\t\t'Notion-Version': '2021-08-16',\n\t\t\t},\n\t\t\tbody: JSON.stringify(bodyString),\n\t\t})\n\t\treturn response;\n\t}\n\n\tasync syncMarkdownToNotion(title:string, markdown: string, fullPath:string): Promise<any> {\n\t\tconst yamlObj:any = yamlFrontMatter.loadFront(markdown);\n\t\tconst __content = yamlObj.__content\n\t\tconst file2md = markdownToBlocks(__content);\n\t\tconst res = await this.createPage(title, file2md);\n\t\tif (res.status === 200) {\n\t\t\tthis.updateYamlInfo(markdown, fullPath, res)\n\t\t}\n\t\treturn res\n\t}\n\n\tasync updateYamlInfo(yamlContent: string, fullPath: string, res: any) {\n\t\tconst yamlObj:any = yamlFrontMatter.loadFront(yamlContent);\n\t\tconst {url} = res.json\n\t\tyamlObj.link = url;\n\t\tconst __content = yamlObj.__content;\n\t\tdelete yamlObj.__content\n\t\tconst yamlhead = yaml.stringify(yamlObj)\n\t\t//  if yamlhead hava last \\n  remove it\n\t\tconst yamlhead_remove_n = yamlhead.replace(/\\n$/, '')\n\t\t// if __content have start \\n remove it\n\t\tconst __content_remove_n = __content.replace(/^\\n/, '')\n\t\tconst content = '---\\n' +yamlhead_remove_n +'\\n---\\n' + __content_remove_n;\n\n\t\t//write content fo file\n\t\tfs.writeFileSync(fullPath, content);\n\t\treturn res\n\t}\n}\n", "var jsYaml = require('js-yaml');\n\nfunction parse(text, options, loadSafe) {\n    let contentKeyName = options && typeof options === 'string'\n        ? options\n        : options && options.contentKeyName \n            ? options.contentKeyName \n            : '__content';\n\n    let passThroughOptions = options && typeof options === 'object'\n        ? options\n        : undefined;\n\n    let re = /^(-{3}(?:\\n|\\r)([\\w\\W]+?)(?:\\n|\\r)-{3})?([\\w\\W]*)*/\n        , results = re.exec(text)\n        , conf = {}\n        , yamlOrJson;\n\n    if ((yamlOrJson = results[2])) {\n        if (yamlOrJson.charAt(0) === '{') {\n            conf = JSON.parse(yamlOrJson);\n        } else {\n            if(loadSafe) {\n                conf = jsYaml.safeLoad(yamlOrJson, passThroughOptions);\n            } else {\n                conf = jsYaml.load(yamlOrJson, passThroughOptions); \n            }\n        }\n    }\n\n    conf[contentKeyName] = results[3] || '';\n\n    return conf;\n};\n\nexport function loadFront (content, options) {\n    return parse(content, options, false);\n};\n\nexport function safeLoadFront (content, options) {\n    return parse(content, options, true)\n}\n", "const ALIAS = Symbol.for('yaml.alias');\nconst DOC = Symbol.for('yaml.document');\nconst MAP = Symbol.for('yaml.map');\nconst PAIR = Symbol.for('yaml.pair');\nconst SCALAR = Symbol.for('yaml.scalar');\nconst SEQ = Symbol.for('yaml.seq');\nconst NODE_TYPE = Symbol.for('yaml.node.type');\nconst isAlias = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === ALIAS;\nconst isDocument = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === DOC;\nconst isMap = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === MAP;\nconst isPair = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === PAIR;\nconst isScalar = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SCALAR;\nconst isSeq = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SEQ;\nfunction isCollection(node) {\n    if (node && typeof node === 'object')\n        switch (node[NODE_TYPE]) {\n            case MAP:\n            case SEQ:\n                return true;\n        }\n    return false;\n}\nfunction isNode(node) {\n    if (node && typeof node === 'object')\n        switch (node[NODE_TYPE]) {\n            case ALIAS:\n            case MAP:\n            case SCALAR:\n            case SEQ:\n                return true;\n        }\n    return false;\n}\nconst hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor;\nclass NodeBase {\n    constructor(type) {\n        Object.defineProperty(this, NODE_TYPE, { value: type });\n    }\n    /** Create a copy of this node.  */\n    clone() {\n        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));\n        if (this.range)\n            copy.range = this.range.slice();\n        return copy;\n    }\n}\n\nexport { ALIAS, DOC, MAP, NODE_TYPE, NodeBase, PAIR, SCALAR, SEQ, hasAnchor, isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq };\n", "import { isDocument, isNode, isPair, isCollection, isMap, isSeq, isScalar, isAlias } from './nodes/Node.js';\n\nconst BREAK = Symbol('break visit');\nconst SKIP = Symbol('skip children');\nconst REMOVE = Symbol('remove node');\n/**\n * Apply a visitor to an AST node or document.\n *\n * Walks through the tree (depth-first) starting from `node`, calling a\n * `visitor` function with three arguments:\n *   - `key`: For sequence values and map `Pair`, the node's index in the\n *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.\n *     `null` for the root node.\n *   - `node`: The current node.\n *   - `path`: The ancestry of the current node.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this node, continue with next\n *     sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current node, then continue with the next one\n *   - `Node`: Replace the current node, then continue by visiting it\n *   - `number`: While iterating the items of a sequence or map, set the index\n *     of the next step. This is useful especially if the index of the current\n *     node has changed.\n *\n * If `visitor` is a single function, it will be called with all values\n * encountered in the tree, including e.g. `null` values. Alternatively,\n * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,\n * `Alias` and `Scalar` node. To define the same visitor function for more than\n * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)\n * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most\n * specific defined one will be used for each node.\n */\nfunction visit(node, visitor) {\n    const visitor_ = initVisitor(visitor);\n    if (isDocument(node)) {\n        const cd = visit_(null, node.contents, visitor_, Object.freeze([node]));\n        if (cd === REMOVE)\n            node.contents = null;\n    }\n    else\n        visit_(null, node, visitor_, Object.freeze([]));\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisit.BREAK = BREAK;\n/** Do not visit the children of the current node */\nvisit.SKIP = SKIP;\n/** Remove the current node */\nvisit.REMOVE = REMOVE;\nfunction visit_(key, node, visitor, path) {\n    const ctrl = callVisitor(key, node, visitor, path);\n    if (isNode(ctrl) || isPair(ctrl)) {\n        replaceNode(key, path, ctrl);\n        return visit_(key, ctrl, visitor, path);\n    }\n    if (typeof ctrl !== 'symbol') {\n        if (isCollection(node)) {\n            path = Object.freeze(path.concat(node));\n            for (let i = 0; i < node.items.length; ++i) {\n                const ci = visit_(i, node.items[i], visitor, path);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    node.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n        }\n        else if (isPair(node)) {\n            path = Object.freeze(path.concat(node));\n            const ck = visit_('key', node.key, visitor, path);\n            if (ck === BREAK)\n                return BREAK;\n            else if (ck === REMOVE)\n                node.key = null;\n            const cv = visit_('value', node.value, visitor, path);\n            if (cv === BREAK)\n                return BREAK;\n            else if (cv === REMOVE)\n                node.value = null;\n        }\n    }\n    return ctrl;\n}\n/**\n * Apply an async visitor to an AST node or document.\n *\n * Walks through the tree (depth-first) starting from `node`, calling a\n * `visitor` function with three arguments:\n *   - `key`: For sequence values and map `Pair`, the node's index in the\n *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.\n *     `null` for the root node.\n *   - `node`: The current node.\n *   - `path`: The ancestry of the current node.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `Promise`: Must resolve to one of the following values\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this node, continue with next\n *     sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current node, then continue with the next one\n *   - `Node`: Replace the current node, then continue by visiting it\n *   - `number`: While iterating the items of a sequence or map, set the index\n *     of the next step. This is useful especially if the index of the current\n *     node has changed.\n *\n * If `visitor` is a single function, it will be called with all values\n * encountered in the tree, including e.g. `null` values. Alternatively,\n * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,\n * `Alias` and `Scalar` node. To define the same visitor function for more than\n * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)\n * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most\n * specific defined one will be used for each node.\n */\nasync function visitAsync(node, visitor) {\n    const visitor_ = initVisitor(visitor);\n    if (isDocument(node)) {\n        const cd = await visitAsync_(null, node.contents, visitor_, Object.freeze([node]));\n        if (cd === REMOVE)\n            node.contents = null;\n    }\n    else\n        await visitAsync_(null, node, visitor_, Object.freeze([]));\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisitAsync.BREAK = BREAK;\n/** Do not visit the children of the current node */\nvisitAsync.SKIP = SKIP;\n/** Remove the current node */\nvisitAsync.REMOVE = REMOVE;\nasync function visitAsync_(key, node, visitor, path) {\n    const ctrl = await callVisitor(key, node, visitor, path);\n    if (isNode(ctrl) || isPair(ctrl)) {\n        replaceNode(key, path, ctrl);\n        return visitAsync_(key, ctrl, visitor, path);\n    }\n    if (typeof ctrl !== 'symbol') {\n        if (isCollection(node)) {\n            path = Object.freeze(path.concat(node));\n            for (let i = 0; i < node.items.length; ++i) {\n                const ci = await visitAsync_(i, node.items[i], visitor, path);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    node.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n        }\n        else if (isPair(node)) {\n            path = Object.freeze(path.concat(node));\n            const ck = await visitAsync_('key', node.key, visitor, path);\n            if (ck === BREAK)\n                return BREAK;\n            else if (ck === REMOVE)\n                node.key = null;\n            const cv = await visitAsync_('value', node.value, visitor, path);\n            if (cv === BREAK)\n                return BREAK;\n            else if (cv === REMOVE)\n                node.value = null;\n        }\n    }\n    return ctrl;\n}\nfunction initVisitor(visitor) {\n    if (typeof visitor === 'object' &&\n        (visitor.Collection || visitor.Node || visitor.Value)) {\n        return Object.assign({\n            Alias: visitor.Node,\n            Map: visitor.Node,\n            Scalar: visitor.Node,\n            Seq: visitor.Node\n        }, visitor.Value && {\n            Map: visitor.Value,\n            Scalar: visitor.Value,\n            Seq: visitor.Value\n        }, visitor.Collection && {\n            Map: visitor.Collection,\n            Seq: visitor.Collection\n        }, visitor);\n    }\n    return visitor;\n}\nfunction callVisitor(key, node, visitor, path) {\n    if (typeof visitor === 'function')\n        return visitor(key, node, path);\n    if (isMap(node))\n        return visitor.Map?.(key, node, path);\n    if (isSeq(node))\n        return visitor.Seq?.(key, node, path);\n    if (isPair(node))\n        return visitor.Pair?.(key, node, path);\n    if (isScalar(node))\n        return visitor.Scalar?.(key, node, path);\n    if (isAlias(node))\n        return visitor.Alias?.(key, node, path);\n    return undefined;\n}\nfunction replaceNode(key, path, node) {\n    const parent = path[path.length - 1];\n    if (isCollection(parent)) {\n        parent.items[key] = node;\n    }\n    else if (isPair(parent)) {\n        if (key === 'key')\n            parent.key = node;\n        else\n            parent.value = node;\n    }\n    else if (isDocument(parent)) {\n        parent.contents = node;\n    }\n    else {\n        const pt = isAlias(parent) ? 'alias' : 'scalar';\n        throw new Error(`Cannot replace node with ${pt} parent`);\n    }\n}\n\nexport { visit, visitAsync };\n", "import { isNode } from '../nodes/Node.js';\nimport { visit } from '../visit.js';\n\nconst escapeChars = {\n    '!': '%21',\n    ',': '%2C',\n    '[': '%5B',\n    ']': '%5D',\n    '{': '%7B',\n    '}': '%7D'\n};\nconst escapeTagName = (tn) => tn.replace(/[!,[\\]{}]/g, ch => escapeChars[ch]);\nclass Directives {\n    constructor(yaml, tags) {\n        /**\n         * The directives-end/doc-start marker `---`. If `null`, a marker may still be\n         * included in the document's stringified representation.\n         */\n        this.docStart = null;\n        /** The doc-end marker `...`.  */\n        this.docEnd = false;\n        this.yaml = Object.assign({}, Directives.defaultYaml, yaml);\n        this.tags = Object.assign({}, Directives.defaultTags, tags);\n    }\n    clone() {\n        const copy = new Directives(this.yaml, this.tags);\n        copy.docStart = this.docStart;\n        return copy;\n    }\n    /**\n     * During parsing, get a Directives instance for the current document and\n     * update the stream state according to the current version's spec.\n     */\n    atDocument() {\n        const res = new Directives(this.yaml, this.tags);\n        switch (this.yaml.version) {\n            case '1.1':\n                this.atNextDocument = true;\n                break;\n            case '1.2':\n                this.atNextDocument = false;\n                this.yaml = {\n                    explicit: Directives.defaultYaml.explicit,\n                    version: '1.2'\n                };\n                this.tags = Object.assign({}, Directives.defaultTags);\n                break;\n        }\n        return res;\n    }\n    /**\n     * @param onError - May be called even if the action was successful\n     * @returns `true` on success\n     */\n    add(line, onError) {\n        if (this.atNextDocument) {\n            this.yaml = { explicit: Directives.defaultYaml.explicit, version: '1.1' };\n            this.tags = Object.assign({}, Directives.defaultTags);\n            this.atNextDocument = false;\n        }\n        const parts = line.trim().split(/[ \\t]+/);\n        const name = parts.shift();\n        switch (name) {\n            case '%TAG': {\n                if (parts.length !== 2) {\n                    onError(0, '%TAG directive should contain exactly two parts');\n                    if (parts.length < 2)\n                        return false;\n                }\n                const [handle, prefix] = parts;\n                this.tags[handle] = prefix;\n                return true;\n            }\n            case '%YAML': {\n                this.yaml.explicit = true;\n                if (parts.length !== 1) {\n                    onError(0, '%YAML directive should contain exactly one part');\n                    return false;\n                }\n                const [version] = parts;\n                if (version === '1.1' || version === '1.2') {\n                    this.yaml.version = version;\n                    return true;\n                }\n                else {\n                    const isValid = /^\\d+\\.\\d+$/.test(version);\n                    onError(6, `Unsupported YAML version ${version}`, isValid);\n                    return false;\n                }\n            }\n            default:\n                onError(0, `Unknown directive ${name}`, true);\n                return false;\n        }\n    }\n    /**\n     * Resolves a tag, matching handles to those defined in %TAG directives.\n     *\n     * @returns Resolved tag, which may also be the non-specific tag `'!'` or a\n     *   `'!local'` tag, or `null` if unresolvable.\n     */\n    tagName(source, onError) {\n        if (source === '!')\n            return '!'; // non-specific tag\n        if (source[0] !== '!') {\n            onError(`Not a valid tag: ${source}`);\n            return null;\n        }\n        if (source[1] === '<') {\n            const verbatim = source.slice(2, -1);\n            if (verbatim === '!' || verbatim === '!!') {\n                onError(`Verbatim tags aren't resolved, so ${source} is invalid.`);\n                return null;\n            }\n            if (source[source.length - 1] !== '>')\n                onError('Verbatim tags must end with a >');\n            return verbatim;\n        }\n        const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/);\n        if (!suffix)\n            onError(`The ${source} tag has no suffix`);\n        const prefix = this.tags[handle];\n        if (prefix)\n            return prefix + decodeURIComponent(suffix);\n        if (handle === '!')\n            return source; // local tag\n        onError(`Could not resolve tag: ${source}`);\n        return null;\n    }\n    /**\n     * Given a fully resolved tag, returns its printable string form,\n     * taking into account current tag prefixes and defaults.\n     */\n    tagString(tag) {\n        for (const [handle, prefix] of Object.entries(this.tags)) {\n            if (tag.startsWith(prefix))\n                return handle + escapeTagName(tag.substring(prefix.length));\n        }\n        return tag[0] === '!' ? tag : `!<${tag}>`;\n    }\n    toString(doc) {\n        const lines = this.yaml.explicit\n            ? [`%YAML ${this.yaml.version || '1.2'}`]\n            : [];\n        const tagEntries = Object.entries(this.tags);\n        let tagNames;\n        if (doc && tagEntries.length > 0 && isNode(doc.contents)) {\n            const tags = {};\n            visit(doc.contents, (_key, node) => {\n                if (isNode(node) && node.tag)\n                    tags[node.tag] = true;\n            });\n            tagNames = Object.keys(tags);\n        }\n        else\n            tagNames = [];\n        for (const [handle, prefix] of tagEntries) {\n            if (handle === '!!' && prefix === 'tag:yaml.org,2002:')\n                continue;\n            if (!doc || tagNames.some(tn => tn.startsWith(prefix)))\n                lines.push(`%TAG ${handle} ${prefix}`);\n        }\n        return lines.join('\\n');\n    }\n}\nDirectives.defaultYaml = { explicit: false, version: '1.2' };\nDirectives.defaultTags = { '!!': 'tag:yaml.org,2002:' };\n\nexport { Directives };\n", "import { isScalar, isCollection } from '../nodes/Node.js';\nimport { visit } from '../visit.js';\n\n/**\n * Verify that the input string is a valid anchor.\n *\n * Will throw on errors.\n */\nfunction anchorIsValid(anchor) {\n    if (/[\\x00-\\x19\\s,[\\]{}]/.test(anchor)) {\n        const sa = JSON.stringify(anchor);\n        const msg = `Anchor must not contain whitespace or control characters: ${sa}`;\n        throw new Error(msg);\n    }\n    return true;\n}\nfunction anchorNames(root) {\n    const anchors = new Set();\n    visit(root, {\n        Value(_key, node) {\n            if (node.anchor)\n                anchors.add(node.anchor);\n        }\n    });\n    return anchors;\n}\n/** Find a new anchor name with the given `prefix` and a one-indexed suffix. */\nfunction findNewAnchor(prefix, exclude) {\n    for (let i = 1; true; ++i) {\n        const name = `${prefix}${i}`;\n        if (!exclude.has(name))\n            return name;\n    }\n}\nfunction createNodeAnchors(doc, prefix) {\n    const aliasObjects = [];\n    const sourceObjects = new Map();\n    let prevAnchors = null;\n    return {\n        onAnchor: (source) => {\n            aliasObjects.push(source);\n            if (!prevAnchors)\n                prevAnchors = anchorNames(doc);\n            const anchor = findNewAnchor(prefix, prevAnchors);\n            prevAnchors.add(anchor);\n            return anchor;\n        },\n        /**\n         * With circular references, the source node is only resolved after all\n         * of its child nodes are. This is why anchors are set only after all of\n         * the nodes have been created.\n         */\n        setAnchors: () => {\n            for (const source of aliasObjects) {\n                const ref = sourceObjects.get(source);\n                if (typeof ref === 'object' &&\n                    ref.anchor &&\n                    (isScalar(ref.node) || isCollection(ref.node))) {\n                    ref.node.anchor = ref.anchor;\n                }\n                else {\n                    const error = new Error('Failed to resolve repeated object (this should not happen)');\n                    error.source = source;\n                    throw error;\n                }\n            }\n        },\n        sourceObjects\n    };\n}\n\nexport { anchorIsValid, anchorNames, createNodeAnchors, findNewAnchor };\n", "import { anchorIsValid } from '../doc/anchors.js';\nimport { visit } from '../visit.js';\nimport { NodeBase, ALIAS, isAlias, isCollection, isPair } from './Node.js';\n\nclass Alias extends NodeBase {\n    constructor(source) {\n        super(ALIAS);\n        this.source = source;\n        Object.defineProperty(this, 'tag', {\n            set() {\n                throw new Error('Alias nodes cannot have tags');\n            }\n        });\n    }\n    /**\n     * Resolve the value of this alias within `doc`, finding the last\n     * instance of the `source` anchor before this node.\n     */\n    resolve(doc) {\n        let found = undefined;\n        visit(doc, {\n            Node: (_key, node) => {\n                if (node === this)\n                    return visit.BREAK;\n                if (node.anchor === this.source)\n                    found = node;\n            }\n        });\n        return found;\n    }\n    toJSON(_arg, ctx) {\n        if (!ctx)\n            return { source: this.source };\n        const { anchors, doc, maxAliasCount } = ctx;\n        const source = this.resolve(doc);\n        if (!source) {\n            const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;\n            throw new ReferenceError(msg);\n        }\n        const data = anchors.get(source);\n        /* istanbul ignore if */\n        if (!data || data.res === undefined) {\n            const msg = 'This should not happen: Alias anchor was not resolved?';\n            throw new ReferenceError(msg);\n        }\n        if (maxAliasCount >= 0) {\n            data.count += 1;\n            if (data.aliasCount === 0)\n                data.aliasCount = getAliasCount(doc, source, anchors);\n            if (data.count * data.aliasCount > maxAliasCount) {\n                const msg = 'Excessive alias count indicates a resource exhaustion attack';\n                throw new ReferenceError(msg);\n            }\n        }\n        return data.res;\n    }\n    toString(ctx, _onComment, _onChompKeep) {\n        const src = `*${this.source}`;\n        if (ctx) {\n            anchorIsValid(this.source);\n            if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {\n                const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;\n                throw new Error(msg);\n            }\n            if (ctx.implicitKey)\n                return `${src} `;\n        }\n        return src;\n    }\n}\nfunction getAliasCount(doc, node, anchors) {\n    if (isAlias(node)) {\n        const source = node.resolve(doc);\n        const anchor = anchors && source && anchors.get(source);\n        return anchor ? anchor.count * anchor.aliasCount : 0;\n    }\n    else if (isCollection(node)) {\n        let count = 0;\n        for (const item of node.items) {\n            const c = getAliasCount(doc, item, anchors);\n            if (c > count)\n                count = c;\n        }\n        return count;\n    }\n    else if (isPair(node)) {\n        const kc = getAliasCount(doc, node.key, anchors);\n        const vc = getAliasCount(doc, node.value, anchors);\n        return Math.max(kc, vc);\n    }\n    return 1;\n}\n\nexport { Alias };\n", "import { hasAnchor } from './Node.js';\n\n/**\n * Recursively convert any node or its contents to native JavaScript\n *\n * @param value - The input value\n * @param arg - If `value` defines a `toJSON()` method, use this\n *   as its first argument\n * @param ctx - Conversion context, originally set in Document#toJS(). If\n *   `{ keep: true }` is not set, output should be suitable for JSON\n *   stringification.\n */\nfunction toJS(value, arg, ctx) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    if (Array.isArray(value))\n        return value.map((v, i) => toJS(v, String(i), ctx));\n    if (value && typeof value.toJSON === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n        if (!ctx || !hasAnchor(value))\n            return value.toJSON(arg, ctx);\n        const data = { aliasCount: 0, count: 1, res: undefined };\n        ctx.anchors.set(value, data);\n        ctx.onCreate = res => {\n            data.res = res;\n            delete ctx.onCreate;\n        };\n        const res = value.toJSON(arg, ctx);\n        if (ctx.onCreate)\n            ctx.onCreate(res);\n        return res;\n    }\n    if (typeof value === 'bigint' && !ctx?.keep)\n        return Number(value);\n    return value;\n}\n\nexport { toJS };\n", "import { NodeBase, SCALAR } from './Node.js';\nimport { toJS } from './toJS.js';\n\nconst isScalarValue = (value) => !value || (typeof value !== 'function' && typeof value !== 'object');\nclass Scalar extends NodeBase {\n    constructor(value) {\n        super(SCALAR);\n        this.value = value;\n    }\n    toJSON(arg, ctx) {\n        return ctx?.keep ? this.value : toJS(this.value, arg, ctx);\n    }\n    toString() {\n        return String(this.value);\n    }\n}\nScalar.BLOCK_FOLDED = 'BLOCK_FOLDED';\nScalar.BLOCK_LITERAL = 'BLOCK_LITERAL';\nScalar.PLAIN = 'PLAIN';\nScalar.QUOTE_DOUBLE = 'QUOTE_DOUBLE';\nScalar.QUOTE_SINGLE = 'QUOTE_SINGLE';\n\nexport { Scalar, isScalarValue };\n", "import { Alias } from '../nodes/Alias.js';\nimport { isNode, isPair, MAP, SEQ, isDocument } from '../nodes/Node.js';\nimport { Scalar } from '../nodes/Scalar.js';\n\nconst defaultTagPrefix = 'tag:yaml.org,2002:';\nfunction findTagObject(value, tagName, tags) {\n    if (tagName) {\n        const match = tags.filter(t => t.tag === tagName);\n        const tagObj = match.find(t => !t.format) ?? match[0];\n        if (!tagObj)\n            throw new Error(`Tag ${tagName} not found`);\n        return tagObj;\n    }\n    return tags.find(t => t.identify?.(value) && !t.format);\n}\nfunction createNode(value, tagName, ctx) {\n    if (isDocument(value))\n        value = value.contents;\n    if (isNode(value))\n        return value;\n    if (isPair(value)) {\n        const map = ctx.schema[MAP].createNode?.(ctx.schema, null, ctx);\n        map.items.push(value);\n        return map;\n    }\n    if (value instanceof String ||\n        value instanceof Number ||\n        value instanceof Boolean ||\n        (typeof BigInt === 'function' && value instanceof BigInt) // not supported everywhere\n    ) {\n        // https://tc39.es/ecma262/#sec-serializejsonproperty\n        value = value.valueOf();\n    }\n    const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } = ctx;\n    // Detect duplicate references to the same object & use Alias nodes for all\n    // after first. The `ref` wrapper allows for circular references to resolve.\n    let ref = undefined;\n    if (aliasDuplicateObjects && value && typeof value === 'object') {\n        ref = sourceObjects.get(value);\n        if (ref) {\n            if (!ref.anchor)\n                ref.anchor = onAnchor(value);\n            return new Alias(ref.anchor);\n        }\n        else {\n            ref = { anchor: null, node: null };\n            sourceObjects.set(value, ref);\n        }\n    }\n    if (tagName?.startsWith('!!'))\n        tagName = defaultTagPrefix + tagName.slice(2);\n    let tagObj = findTagObject(value, tagName, schema.tags);\n    if (!tagObj) {\n        if (value && typeof value.toJSON === 'function') {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n            value = value.toJSON();\n        }\n        if (!value || typeof value !== 'object') {\n            const node = new Scalar(value);\n            if (ref)\n                ref.node = node;\n            return node;\n        }\n        tagObj =\n            value instanceof Map\n                ? schema[MAP]\n                : Symbol.iterator in Object(value)\n                    ? schema[SEQ]\n                    : schema[MAP];\n    }\n    if (onTagObj) {\n        onTagObj(tagObj);\n        delete ctx.onTagObj;\n    }\n    const node = tagObj?.createNode\n        ? tagObj.createNode(ctx.schema, value, ctx)\n        : new Scalar(value);\n    if (tagName)\n        node.tag = tagName;\n    if (ref)\n        ref.node = node;\n    return node;\n}\n\nexport { createNode };\n", "import { createNode } from '../doc/createNode.js';\nimport { NodeBase, isNode, isPair, isCollection, isScalar } from './Node.js';\n\nfunction collectionFromPath(schema, path, value) {\n    let v = value;\n    for (let i = path.length - 1; i >= 0; --i) {\n        const k = path[i];\n        if (typeof k === 'number' && Number.isInteger(k) && k >= 0) {\n            const a = [];\n            a[k] = v;\n            v = a;\n        }\n        else {\n            v = new Map([[k, v]]);\n        }\n    }\n    return createNode(v, undefined, {\n        aliasDuplicateObjects: false,\n        keepUndefined: false,\n        onAnchor: () => {\n            throw new Error('This should not happen, please report a bug.');\n        },\n        schema,\n        sourceObjects: new Map()\n    });\n}\n// Type guard is intentionally a little wrong so as to be more useful,\n// as it does not cover untypable empty non-string iterables (e.g. []).\nconst isEmptyPath = (path) => path == null ||\n    (typeof path === 'object' && !!path[Symbol.iterator]().next().done);\nclass Collection extends NodeBase {\n    constructor(type, schema) {\n        super(type);\n        Object.defineProperty(this, 'schema', {\n            value: schema,\n            configurable: true,\n            enumerable: false,\n            writable: true\n        });\n    }\n    /**\n     * Create a copy of this collection.\n     *\n     * @param schema - If defined, overwrites the original's schema\n     */\n    clone(schema) {\n        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));\n        if (schema)\n            copy.schema = schema;\n        copy.items = copy.items.map(it => isNode(it) || isPair(it) ? it.clone(schema) : it);\n        if (this.range)\n            copy.range = this.range.slice();\n        return copy;\n    }\n    /**\n     * Adds a value to the collection. For `!!map` and `!!omap` the value must\n     * be a Pair instance or a `{ key, value }` object, which may not have a key\n     * that already exists in the map.\n     */\n    addIn(path, value) {\n        if (isEmptyPath(path))\n            this.add(value);\n        else {\n            const [key, ...rest] = path;\n            const node = this.get(key, true);\n            if (isCollection(node))\n                node.addIn(rest, value);\n            else if (node === undefined && this.schema)\n                this.set(key, collectionFromPath(this.schema, rest, value));\n            else\n                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n        }\n    }\n    /**\n     * Removes a value from the collection.\n     * @returns `true` if the item was found and removed.\n     */\n    deleteIn(path) {\n        const [key, ...rest] = path;\n        if (rest.length === 0)\n            return this.delete(key);\n        const node = this.get(key, true);\n        if (isCollection(node))\n            return node.deleteIn(rest);\n        else\n            throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n    }\n    /**\n     * Returns item at `key`, or `undefined` if not found. By default unwraps\n     * scalar values from their surrounding node; to disable set `keepScalar` to\n     * `true` (collections are always returned intact).\n     */\n    getIn(path, keepScalar) {\n        const [key, ...rest] = path;\n        const node = this.get(key, true);\n        if (rest.length === 0)\n            return !keepScalar && isScalar(node) ? node.value : node;\n        else\n            return isCollection(node) ? node.getIn(rest, keepScalar) : undefined;\n    }\n    hasAllNullValues(allowScalar) {\n        return this.items.every(node => {\n            if (!isPair(node))\n                return false;\n            const n = node.value;\n            return (n == null ||\n                (allowScalar &&\n                    isScalar(n) &&\n                    n.value == null &&\n                    !n.commentBefore &&\n                    !n.comment &&\n                    !n.tag));\n        });\n    }\n    /**\n     * Checks if the collection includes a value with the key `key`.\n     */\n    hasIn(path) {\n        const [key, ...rest] = path;\n        if (rest.length === 0)\n            return this.has(key);\n        const node = this.get(key, true);\n        return isCollection(node) ? node.hasIn(rest) : false;\n    }\n    /**\n     * Sets a value in this collection. For `!!set`, `value` needs to be a\n     * boolean to add/remove the item from the set.\n     */\n    setIn(path, value) {\n        const [key, ...rest] = path;\n        if (rest.length === 0) {\n            this.set(key, value);\n        }\n        else {\n            const node = this.get(key, true);\n            if (isCollection(node))\n                node.setIn(rest, value);\n            else if (node === undefined && this.schema)\n                this.set(key, collectionFromPath(this.schema, rest, value));\n            else\n                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n        }\n    }\n}\nCollection.maxFlowStringSingleLineLength = 60;\n\nexport { Collection, collectionFromPath, isEmptyPath };\n", "/**\n * Stringifies a comment.\n *\n * Empty comment lines are left empty,\n * lines consisting of a single space are replaced by `#`,\n * and all other lines are prefixed with a `#`.\n */\nconst stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, '#');\nfunction indentComment(comment, indent) {\n    if (/^\\n+$/.test(comment))\n        return comment.substring(1);\n    return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;\n}\nconst lineComment = (str, indent, comment) => str.endsWith('\\n')\n    ? indentComment(comment, indent)\n    : comment.includes('\\n')\n        ? '\\n' + indentComment(comment, indent)\n        : (str.endsWith(' ') ? '' : ' ') + comment;\n\nexport { indentComment, lineComment, stringifyComment };\n", "const FOLD_FLOW = 'flow';\nconst FOLD_BLOCK = 'block';\nconst FOLD_QUOTED = 'quoted';\n/**\n * Tries to keep input at up to `lineWidth` characters, splitting only on spaces\n * not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are\n * terminated with `\\n` and started with `indent`.\n */\nfunction foldFlowLines(text, indent, mode = 'flow', { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {\n    if (!lineWidth || lineWidth < 0)\n        return text;\n    const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);\n    if (text.length <= endStep)\n        return text;\n    const folds = [];\n    const escapedFolds = {};\n    let end = lineWidth - indent.length;\n    if (typeof indentAtStart === 'number') {\n        if (indentAtStart > lineWidth - Math.max(2, minContentWidth))\n            folds.push(0);\n        else\n            end = lineWidth - indentAtStart;\n    }\n    let split = undefined;\n    let prev = undefined;\n    let overflow = false;\n    let i = -1;\n    let escStart = -1;\n    let escEnd = -1;\n    if (mode === FOLD_BLOCK) {\n        i = consumeMoreIndentedLines(text, i);\n        if (i !== -1)\n            end = i + endStep;\n    }\n    for (let ch; (ch = text[(i += 1)]);) {\n        if (mode === FOLD_QUOTED && ch === '\\\\') {\n            escStart = i;\n            switch (text[i + 1]) {\n                case 'x':\n                    i += 3;\n                    break;\n                case 'u':\n                    i += 5;\n                    break;\n                case 'U':\n                    i += 9;\n                    break;\n                default:\n                    i += 1;\n            }\n            escEnd = i;\n        }\n        if (ch === '\\n') {\n            if (mode === FOLD_BLOCK)\n                i = consumeMoreIndentedLines(text, i);\n            end = i + endStep;\n            split = undefined;\n        }\n        else {\n            if (ch === ' ' &&\n                prev &&\n                prev !== ' ' &&\n                prev !== '\\n' &&\n                prev !== '\\t') {\n                // space surrounded by non-space can be replaced with newline + indent\n                const next = text[i + 1];\n                if (next && next !== ' ' && next !== '\\n' && next !== '\\t')\n                    split = i;\n            }\n            if (i >= end) {\n                if (split) {\n                    folds.push(split);\n                    end = split + endStep;\n                    split = undefined;\n                }\n                else if (mode === FOLD_QUOTED) {\n                    // white-space collected at end may stretch past lineWidth\n                    while (prev === ' ' || prev === '\\t') {\n                        prev = ch;\n                        ch = text[(i += 1)];\n                        overflow = true;\n                    }\n                    // Account for newline escape, but don't break preceding escape\n                    const j = i > escEnd + 1 ? i - 2 : escStart - 1;\n                    // Bail out if lineWidth & minContentWidth are shorter than an escape string\n                    if (escapedFolds[j])\n                        return text;\n                    folds.push(j);\n                    escapedFolds[j] = true;\n                    end = j + endStep;\n                    split = undefined;\n                }\n                else {\n                    overflow = true;\n                }\n            }\n        }\n        prev = ch;\n    }\n    if (overflow && onOverflow)\n        onOverflow();\n    if (folds.length === 0)\n        return text;\n    if (onFold)\n        onFold();\n    let res = text.slice(0, folds[0]);\n    for (let i = 0; i < folds.length; ++i) {\n        const fold = folds[i];\n        const end = folds[i + 1] || text.length;\n        if (fold === 0)\n            res = `\\n${indent}${text.slice(0, end)}`;\n        else {\n            if (mode === FOLD_QUOTED && escapedFolds[fold])\n                res += `${text[fold]}\\\\`;\n            res += `\\n${indent}${text.slice(fold + 1, end)}`;\n        }\n    }\n    return res;\n}\n/**\n * Presumes `i + 1` is at the start of a line\n * @returns index of last newline in more-indented block\n */\nfunction consumeMoreIndentedLines(text, i) {\n    let ch = text[i + 1];\n    while (ch === ' ' || ch === '\\t') {\n        do {\n            ch = text[(i += 1)];\n        } while (ch && ch !== '\\n');\n        ch = text[i + 1];\n    }\n    return i;\n}\n\nexport { FOLD_BLOCK, FOLD_FLOW, FOLD_QUOTED, foldFlowLines };\n", "import { Scalar } from '../nodes/Scalar.js';\nimport { foldFlowLines, FOLD_QUOTED, FOLD_FLOW, FOLD_BLOCK } from './foldFlowLines.js';\n\nconst getFoldOptions = (ctx) => ({\n    indentAtStart: ctx.indentAtStart,\n    lineWidth: ctx.options.lineWidth,\n    minContentWidth: ctx.options.minContentWidth\n});\n// Also checks for lines starting with %, as parsing the output as YAML 1.1 will\n// presume that's starting a new document.\nconst containsDocumentMarker = (str) => /^(%|---|\\.\\.\\.)/m.test(str);\nfunction lineLengthOverLimit(str, lineWidth, indentLength) {\n    if (!lineWidth || lineWidth < 0)\n        return false;\n    const limit = lineWidth - indentLength;\n    const strLen = str.length;\n    if (strLen <= limit)\n        return false;\n    for (let i = 0, start = 0; i < strLen; ++i) {\n        if (str[i] === '\\n') {\n            if (i - start > limit)\n                return true;\n            start = i + 1;\n            if (strLen - start <= limit)\n                return false;\n        }\n    }\n    return true;\n}\nfunction doubleQuotedString(value, ctx) {\n    const json = JSON.stringify(value);\n    if (ctx.options.doubleQuotedAsJSON)\n        return json;\n    const { implicitKey } = ctx;\n    const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;\n    const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');\n    let str = '';\n    let start = 0;\n    for (let i = 0, ch = json[i]; ch; ch = json[++i]) {\n        if (ch === ' ' && json[i + 1] === '\\\\' && json[i + 2] === 'n') {\n            // space before newline needs to be escaped to not be folded\n            str += json.slice(start, i) + '\\\\ ';\n            i += 1;\n            start = i;\n            ch = '\\\\';\n        }\n        if (ch === '\\\\')\n            switch (json[i + 1]) {\n                case 'u':\n                    {\n                        str += json.slice(start, i);\n                        const code = json.substr(i + 2, 4);\n                        switch (code) {\n                            case '0000':\n                                str += '\\\\0';\n                                break;\n                            case '0007':\n                                str += '\\\\a';\n                                break;\n                            case '000b':\n                                str += '\\\\v';\n                                break;\n                            case '001b':\n                                str += '\\\\e';\n                                break;\n                            case '0085':\n                                str += '\\\\N';\n                                break;\n                            case '00a0':\n                                str += '\\\\_';\n                                break;\n                            case '2028':\n                                str += '\\\\L';\n                                break;\n                            case '2029':\n                                str += '\\\\P';\n                                break;\n                            default:\n                                if (code.substr(0, 2) === '00')\n                                    str += '\\\\x' + code.substr(2);\n                                else\n                                    str += json.substr(i, 6);\n                        }\n                        i += 5;\n                        start = i + 1;\n                    }\n                    break;\n                case 'n':\n                    if (implicitKey ||\n                        json[i + 2] === '\"' ||\n                        json.length < minMultiLineLength) {\n                        i += 1;\n                    }\n                    else {\n                        // folding will eat first newline\n                        str += json.slice(start, i) + '\\n\\n';\n                        while (json[i + 2] === '\\\\' &&\n                            json[i + 3] === 'n' &&\n                            json[i + 4] !== '\"') {\n                            str += '\\n';\n                            i += 2;\n                        }\n                        str += indent;\n                        // space after newline needs to be escaped to not be folded\n                        if (json[i + 2] === ' ')\n                            str += '\\\\';\n                        i += 1;\n                        start = i + 1;\n                    }\n                    break;\n                default:\n                    i += 1;\n            }\n    }\n    str = start ? str + json.slice(start) : json;\n    return implicitKey\n        ? str\n        : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx));\n}\nfunction singleQuotedString(value, ctx) {\n    if (ctx.options.singleQuote === false ||\n        (ctx.implicitKey && value.includes('\\n')) ||\n        /[ \\t]\\n|\\n[ \\t]/.test(value) // single quoted string can't have leading or trailing whitespace around newline\n    )\n        return doubleQuotedString(value, ctx);\n    const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');\n    const res = \"'\" + value.replace(/'/g, \"''\").replace(/\\n+/g, `$&\\n${indent}`) + \"'\";\n    return ctx.implicitKey\n        ? res\n        : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx));\n}\nfunction quotedString(value, ctx) {\n    const { singleQuote } = ctx.options;\n    let qs;\n    if (singleQuote === false)\n        qs = doubleQuotedString;\n    else {\n        const hasDouble = value.includes('\"');\n        const hasSingle = value.includes(\"'\");\n        if (hasDouble && !hasSingle)\n            qs = singleQuotedString;\n        else if (hasSingle && !hasDouble)\n            qs = doubleQuotedString;\n        else\n            qs = singleQuote ? singleQuotedString : doubleQuotedString;\n    }\n    return qs(value, ctx);\n}\nfunction blockString({ comment, type, value }, ctx, onComment, onChompKeep) {\n    const { blockQuote, commentString, lineWidth } = ctx.options;\n    // 1. Block can't end in whitespace unless the last line is non-empty.\n    // 2. Strings consisting of only whitespace are best rendered explicitly.\n    if (!blockQuote || /\\n[\\t ]+$/.test(value) || /^\\s*$/.test(value)) {\n        return quotedString(value, ctx);\n    }\n    const indent = ctx.indent ||\n        (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');\n    const literal = blockQuote === 'literal'\n        ? true\n        : blockQuote === 'folded' || type === Scalar.BLOCK_FOLDED\n            ? false\n            : type === Scalar.BLOCK_LITERAL\n                ? true\n                : !lineLengthOverLimit(value, lineWidth, indent.length);\n    if (!value)\n        return literal ? '|\\n' : '>\\n';\n    // determine chomping from whitespace at value end\n    let chomp;\n    let endStart;\n    for (endStart = value.length; endStart > 0; --endStart) {\n        const ch = value[endStart - 1];\n        if (ch !== '\\n' && ch !== '\\t' && ch !== ' ')\n            break;\n    }\n    let end = value.substring(endStart);\n    const endNlPos = end.indexOf('\\n');\n    if (endNlPos === -1) {\n        chomp = '-'; // strip\n    }\n    else if (value === end || endNlPos !== end.length - 1) {\n        chomp = '+'; // keep\n        if (onChompKeep)\n            onChompKeep();\n    }\n    else {\n        chomp = ''; // clip\n    }\n    if (end) {\n        value = value.slice(0, -end.length);\n        if (end[end.length - 1] === '\\n')\n            end = end.slice(0, -1);\n        end = end.replace(/\\n+(?!\\n|$)/g, `$&${indent}`);\n    }\n    // determine indent indicator from whitespace at value start\n    let startWithSpace = false;\n    let startEnd;\n    let startNlPos = -1;\n    for (startEnd = 0; startEnd < value.length; ++startEnd) {\n        const ch = value[startEnd];\n        if (ch === ' ')\n            startWithSpace = true;\n        else if (ch === '\\n')\n            startNlPos = startEnd;\n        else\n            break;\n    }\n    let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);\n    if (start) {\n        value = value.substring(start.length);\n        start = start.replace(/\\n+/g, `$&${indent}`);\n    }\n    const indentSize = indent ? '2' : '1'; // root is at -1\n    let header = (literal ? '|' : '>') + (startWithSpace ? indentSize : '') + chomp;\n    if (comment) {\n        header += ' ' + commentString(comment.replace(/ ?[\\r\\n]+/g, ' '));\n        if (onComment)\n            onComment();\n    }\n    if (literal) {\n        value = value.replace(/\\n+/g, `$&${indent}`);\n        return `${header}\\n${indent}${start}${value}${end}`;\n    }\n    value = value\n        .replace(/\\n+/g, '\\n$&')\n        .replace(/(?:^|\\n)([\\t ].*)(?:([\\n\\t ]*)\\n(?![\\n\\t ]))?/g, '$1$2') // more-indented lines aren't folded\n        //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent\n        .replace(/\\n+/g, `$&${indent}`);\n    const body = foldFlowLines(`${start}${value}${end}`, indent, FOLD_BLOCK, getFoldOptions(ctx));\n    return `${header}\\n${indent}${body}`;\n}\nfunction plainString(item, ctx, onComment, onChompKeep) {\n    const { type, value } = item;\n    const { actualString, implicitKey, indent, inFlow } = ctx;\n    if ((implicitKey && /[\\n[\\]{},]/.test(value)) ||\n        (inFlow && /[[\\]{},]/.test(value))) {\n        return quotedString(value, ctx);\n    }\n    if (!value ||\n        /^[\\n\\t ,[\\]{}#&*!|>'\"%@`]|^[?-]$|^[?-][ \\t]|[\\n:][ \\t]|[ \\t]\\n|[\\n\\t ]#|[\\n\\t :]$/.test(value)) {\n        // not allowed:\n        // - empty string, '-' or '?'\n        // - start with an indicator character (except [?:-]) or /[?-] /\n        // - '\\n ', ': ' or ' \\n' anywhere\n        // - '#' not preceded by a non-space char\n        // - end with ' ' or ':'\n        return implicitKey || inFlow || !value.includes('\\n')\n            ? quotedString(value, ctx)\n            : blockString(item, ctx, onComment, onChompKeep);\n    }\n    if (!implicitKey &&\n        !inFlow &&\n        type !== Scalar.PLAIN &&\n        value.includes('\\n')) {\n        // Where allowed & type not set explicitly, prefer block style for multiline strings\n        return blockString(item, ctx, onComment, onChompKeep);\n    }\n    if (indent === '' && containsDocumentMarker(value)) {\n        ctx.forceBlockIndent = true;\n        return blockString(item, ctx, onComment, onChompKeep);\n    }\n    const str = value.replace(/\\n+/g, `$&\\n${indent}`);\n    // Verify that output will be parsed as a string, as e.g. plain numbers and\n    // booleans get parsed with those types in v1.2 (e.g. '42', 'true' & '0.9e-3'),\n    // and others in v1.1.\n    if (actualString) {\n        const test = (tag) => tag.default && tag.tag !== 'tag:yaml.org,2002:str' && tag.test?.test(str);\n        const { compat, tags } = ctx.doc.schema;\n        if (tags.some(test) || compat?.some(test))\n            return quotedString(value, ctx);\n    }\n    return implicitKey\n        ? str\n        : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx));\n}\nfunction stringifyString(item, ctx, onComment, onChompKeep) {\n    const { implicitKey, inFlow } = ctx;\n    const ss = typeof item.value === 'string'\n        ? item\n        : Object.assign({}, item, { value: String(item.value) });\n    let { type } = item;\n    if (type !== Scalar.QUOTE_DOUBLE) {\n        // force double quotes on control characters & unpaired surrogates\n        if (/[\\x00-\\x08\\x0b-\\x1f\\x7f-\\x9f\\u{D800}-\\u{DFFF}]/u.test(ss.value))\n            type = Scalar.QUOTE_DOUBLE;\n    }\n    const _stringify = (_type) => {\n        switch (_type) {\n            case Scalar.BLOCK_FOLDED:\n            case Scalar.BLOCK_LITERAL:\n                return implicitKey || inFlow\n                    ? quotedString(ss.value, ctx) // blocks are not valid inside flow containers\n                    : blockString(ss, ctx, onComment, onChompKeep);\n            case Scalar.QUOTE_DOUBLE:\n                return doubleQuotedString(ss.value, ctx);\n            case Scalar.QUOTE_SINGLE:\n                return singleQuotedString(ss.value, ctx);\n            case Scalar.PLAIN:\n                return plainString(ss, ctx, onComment, onChompKeep);\n            default:\n                return null;\n        }\n    };\n    let res = _stringify(type);\n    if (res === null) {\n        const { defaultKeyType, defaultStringType } = ctx.options;\n        const t = (implicitKey && defaultKeyType) || defaultStringType;\n        res = _stringify(t);\n        if (res === null)\n            throw new Error(`Unsupported default string type ${t}`);\n    }\n    return res;\n}\n\nexport { stringifyString };\n", "import { anchorIsValid } from '../doc/anchors.js';\nimport { isPair, isAlias, isNode, isScalar, isCollection } from '../nodes/Node.js';\nimport { stringifyComment } from './stringifyComment.js';\nimport { stringifyString } from './stringifyString.js';\n\nfunction createStringifyContext(doc, options) {\n    const opt = Object.assign({\n        blockQuote: true,\n        commentString: stringifyComment,\n        defaultKeyType: null,\n        defaultStringType: 'PLAIN',\n        directives: null,\n        doubleQuotedAsJSON: false,\n        doubleQuotedMinMultiLineLength: 40,\n        falseStr: 'false',\n        indentSeq: true,\n        lineWidth: 80,\n        minContentWidth: 20,\n        nullStr: 'null',\n        simpleKeys: false,\n        singleQuote: null,\n        trueStr: 'true',\n        verifyAliasOrder: true\n    }, doc.schema.toStringOptions, options);\n    let inFlow;\n    switch (opt.collectionStyle) {\n        case 'block':\n            inFlow = false;\n            break;\n        case 'flow':\n            inFlow = true;\n            break;\n        default:\n            inFlow = null;\n    }\n    return {\n        anchors: new Set(),\n        doc,\n        indent: '',\n        indentStep: typeof opt.indent === 'number' ? ' '.repeat(opt.indent) : '  ',\n        inFlow,\n        options: opt\n    };\n}\nfunction getTagObject(tags, item) {\n    if (item.tag) {\n        const match = tags.filter(t => t.tag === item.tag);\n        if (match.length > 0)\n            return match.find(t => t.format === item.format) ?? match[0];\n    }\n    let tagObj = undefined;\n    let obj;\n    if (isScalar(item)) {\n        obj = item.value;\n        const match = tags.filter(t => t.identify?.(obj));\n        tagObj =\n            match.find(t => t.format === item.format) ?? match.find(t => !t.format);\n    }\n    else {\n        obj = item;\n        tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass);\n    }\n    if (!tagObj) {\n        const name = obj?.constructor?.name ?? typeof obj;\n        throw new Error(`Tag not resolved for ${name} value`);\n    }\n    return tagObj;\n}\n// needs to be called before value stringifier to allow for circular anchor refs\nfunction stringifyProps(node, tagObj, { anchors, doc }) {\n    if (!doc.directives)\n        return '';\n    const props = [];\n    const anchor = (isScalar(node) || isCollection(node)) && node.anchor;\n    if (anchor && anchorIsValid(anchor)) {\n        anchors.add(anchor);\n        props.push(`&${anchor}`);\n    }\n    const tag = node.tag ? node.tag : tagObj.default ? null : tagObj.tag;\n    if (tag)\n        props.push(doc.directives.tagString(tag));\n    return props.join(' ');\n}\nfunction stringify(item, ctx, onComment, onChompKeep) {\n    if (isPair(item))\n        return item.toString(ctx, onComment, onChompKeep);\n    if (isAlias(item)) {\n        if (ctx.doc.directives)\n            return item.toString(ctx);\n        if (ctx.resolvedAliases?.has(item)) {\n            throw new TypeError(`Cannot stringify circular structure without alias nodes`);\n        }\n        else {\n            if (ctx.resolvedAliases)\n                ctx.resolvedAliases.add(item);\n            else\n                ctx.resolvedAliases = new Set([item]);\n            item = item.resolve(ctx.doc);\n        }\n    }\n    let tagObj = undefined;\n    const node = isNode(item)\n        ? item\n        : ctx.doc.createNode(item, { onTagObj: o => (tagObj = o) });\n    if (!tagObj)\n        tagObj = getTagObject(ctx.doc.schema.tags, node);\n    const props = stringifyProps(node, tagObj, ctx);\n    if (props.length > 0)\n        ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;\n    const str = typeof tagObj.stringify === 'function'\n        ? tagObj.stringify(node, ctx, onComment, onChompKeep)\n        : isScalar(node)\n            ? stringifyString(node, ctx, onComment, onChompKeep)\n            : node.toString(ctx, onComment, onChompKeep);\n    if (!props)\n        return str;\n    return isScalar(node) || str[0] === '{' || str[0] === '['\n        ? `${props} ${str}`\n        : `${props}\\n${ctx.indent}${str}`;\n}\n\nexport { createStringifyContext, stringify };\n", "import { isCollection, isNode, isScalar, isSeq } from '../nodes/Node.js';\nimport { Scalar } from '../nodes/Scalar.js';\nimport { stringify } from './stringify.js';\nimport { lineComment, indentComment } from './stringifyComment.js';\n\nfunction stringifyPair({ key, value }, ctx, onComment, onChompKeep) {\n    const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;\n    let keyComment = (isNode(key) && key.comment) || null;\n    if (simpleKeys) {\n        if (keyComment) {\n            throw new Error('With simple keys, key nodes cannot have comments');\n        }\n        if (isCollection(key)) {\n            const msg = 'With simple keys, collection cannot be used as a key value';\n            throw new Error(msg);\n        }\n    }\n    let explicitKey = !simpleKeys &&\n        (!key ||\n            (keyComment && value == null && !ctx.inFlow) ||\n            isCollection(key) ||\n            (isScalar(key)\n                ? key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL\n                : typeof key === 'object'));\n    ctx = Object.assign({}, ctx, {\n        allNullValues: false,\n        implicitKey: !explicitKey && (simpleKeys || !allNullValues),\n        indent: indent + indentStep\n    });\n    let keyCommentDone = false;\n    let chompKeep = false;\n    let str = stringify(key, ctx, () => (keyCommentDone = true), () => (chompKeep = true));\n    if (!explicitKey && !ctx.inFlow && str.length > 1024) {\n        if (simpleKeys)\n            throw new Error('With simple keys, single line scalar must not span more than 1024 characters');\n        explicitKey = true;\n    }\n    if (ctx.inFlow) {\n        if (allNullValues || value == null) {\n            if (keyCommentDone && onComment)\n                onComment();\n            return str === '' ? '?' : explicitKey ? `? ${str}` : str;\n        }\n    }\n    else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) {\n        str = `? ${str}`;\n        if (keyComment && !keyCommentDone) {\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n        }\n        else if (chompKeep && onChompKeep)\n            onChompKeep();\n        return str;\n    }\n    if (keyCommentDone)\n        keyComment = null;\n    if (explicitKey) {\n        if (keyComment)\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n        str = `? ${str}\\n${indent}:`;\n    }\n    else {\n        str = `${str}:`;\n        if (keyComment)\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n    }\n    let vcb = '';\n    let valueComment = null;\n    if (isNode(value)) {\n        if (value.spaceBefore)\n            vcb = '\\n';\n        if (value.commentBefore) {\n            const cs = commentString(value.commentBefore);\n            vcb += `\\n${indentComment(cs, ctx.indent)}`;\n        }\n        valueComment = value.comment;\n    }\n    else if (value && typeof value === 'object') {\n        value = doc.createNode(value);\n    }\n    ctx.implicitKey = false;\n    if (!explicitKey && !keyComment && isScalar(value))\n        ctx.indentAtStart = str.length + 1;\n    chompKeep = false;\n    if (!indentSeq &&\n        indentStep.length >= 2 &&\n        !ctx.inFlow &&\n        !explicitKey &&\n        isSeq(value) &&\n        !value.flow &&\n        !value.tag &&\n        !value.anchor) {\n        // If indentSeq === false, consider '- ' as part of indentation where possible\n        ctx.indent = ctx.indent.substr(2);\n    }\n    let valueCommentDone = false;\n    const valueStr = stringify(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));\n    let ws = ' ';\n    if (vcb || keyComment) {\n        if (valueStr === '' && !ctx.inFlow)\n            ws = vcb === '\\n' ? '\\n\\n' : vcb;\n        else\n            ws = `${vcb}\\n${ctx.indent}`;\n    }\n    else if (!explicitKey && isCollection(value)) {\n        const flow = valueStr[0] === '[' || valueStr[0] === '{';\n        if (!flow || valueStr.includes('\\n'))\n            ws = `\\n${ctx.indent}`;\n    }\n    else if (valueStr === '' || valueStr[0] === '\\n')\n        ws = '';\n    str += ws + valueStr;\n    if (ctx.inFlow) {\n        if (valueCommentDone && onComment)\n            onComment();\n    }\n    else if (valueComment && !valueCommentDone) {\n        str += lineComment(str, ctx.indent, commentString(valueComment));\n    }\n    else if (chompKeep && onChompKeep) {\n        onChompKeep();\n    }\n    return str;\n}\n\nexport { stringifyPair };\n", "function debug(logLevel, ...messages) {\n    if (logLevel === 'debug')\n        console.log(...messages);\n}\nfunction warn(logLevel, warning) {\n    if (logLevel === 'debug' || logLevel === 'warn') {\n        if (typeof process !== 'undefined' && process.emitWarning)\n            process.emitWarning(warning);\n        else\n            console.warn(warning);\n    }\n}\n\nexport { debug, warn };\n", "import { warn } from '../log.js';\nimport { createStringifyContext } from '../stringify/stringify.js';\nimport { isAlias, isSeq, isScalar, isMap, isNode } from './Node.js';\nimport { Scalar } from './Scalar.js';\nimport { toJS } from './toJS.js';\n\nconst MERGE_KEY = '<<';\nfunction addPairToJSMap(ctx, map, { key, value }) {\n    if (ctx?.doc.schema.merge && isMergeKey(key)) {\n        value = isAlias(value) ? value.resolve(ctx.doc) : value;\n        if (isSeq(value))\n            for (const it of value.items)\n                mergeToJSMap(ctx, map, it);\n        else if (Array.isArray(value))\n            for (const it of value)\n                mergeToJSMap(ctx, map, it);\n        else\n            mergeToJSMap(ctx, map, value);\n    }\n    else {\n        const jsKey = toJS(key, '', ctx);\n        if (map instanceof Map) {\n            map.set(jsKey, toJS(value, jsKey, ctx));\n        }\n        else if (map instanceof Set) {\n            map.add(jsKey);\n        }\n        else {\n            const stringKey = stringifyKey(key, jsKey, ctx);\n            const jsValue = toJS(value, stringKey, ctx);\n            if (stringKey in map)\n                Object.defineProperty(map, stringKey, {\n                    value: jsValue,\n                    writable: true,\n                    enumerable: true,\n                    configurable: true\n                });\n            else\n                map[stringKey] = jsValue;\n        }\n    }\n    return map;\n}\nconst isMergeKey = (key) => key === MERGE_KEY ||\n    (isScalar(key) &&\n        key.value === MERGE_KEY &&\n        (!key.type || key.type === Scalar.PLAIN));\n// If the value associated with a merge key is a single mapping node, each of\n// its key/value pairs is inserted into the current mapping, unless the key\n// already exists in it. If the value associated with the merge key is a\n// sequence, then this sequence is expected to contain mapping nodes and each\n// of these nodes is merged in turn according to its order in the sequence.\n// Keys in mapping nodes earlier in the sequence override keys specified in\n// later mapping nodes. -- http://yaml.org/type/merge.html\nfunction mergeToJSMap(ctx, map, value) {\n    const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;\n    if (!isMap(source))\n        throw new Error('Merge sources must be maps or map aliases');\n    const srcMap = source.toJSON(null, ctx, Map);\n    for (const [key, value] of srcMap) {\n        if (map instanceof Map) {\n            if (!map.has(key))\n                map.set(key, value);\n        }\n        else if (map instanceof Set) {\n            map.add(key);\n        }\n        else if (!Object.prototype.hasOwnProperty.call(map, key)) {\n            Object.defineProperty(map, key, {\n                value,\n                writable: true,\n                enumerable: true,\n                configurable: true\n            });\n        }\n    }\n    return map;\n}\nfunction stringifyKey(key, jsKey, ctx) {\n    if (jsKey === null)\n        return '';\n    if (typeof jsKey !== 'object')\n        return String(jsKey);\n    if (isNode(key) && ctx && ctx.doc) {\n        const strCtx = createStringifyContext(ctx.doc, {});\n        strCtx.anchors = new Set();\n        for (const node of ctx.anchors.keys())\n            strCtx.anchors.add(node.anchor);\n        strCtx.inFlow = true;\n        strCtx.inStringifyKey = true;\n        const strKey = key.toString(strCtx);\n        if (!ctx.mapKeyWarned) {\n            let jsonStr = JSON.stringify(strKey);\n            if (jsonStr.length > 40)\n                jsonStr = jsonStr.substring(0, 36) + '...\"';\n            warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);\n            ctx.mapKeyWarned = true;\n        }\n        return strKey;\n    }\n    return JSON.stringify(jsKey);\n}\n\nexport { addPairToJSMap };\n", "import { createNode } from '../doc/createNode.js';\nimport { stringifyPair } from '../stringify/stringifyPair.js';\nimport { addPairToJSMap } from './addPairToJSMap.js';\nimport { NODE_TYPE, PAIR, isNode } from './Node.js';\n\nfunction createPair(key, value, ctx) {\n    const k = createNode(key, undefined, ctx);\n    const v = createNode(value, undefined, ctx);\n    return new Pair(k, v);\n}\nclass Pair {\n    constructor(key, value = null) {\n        Object.defineProperty(this, NODE_TYPE, { value: PAIR });\n        this.key = key;\n        this.value = value;\n    }\n    clone(schema) {\n        let { key, value } = this;\n        if (isNode(key))\n            key = key.clone(schema);\n        if (isNode(value))\n            value = value.clone(schema);\n        return new Pair(key, value);\n    }\n    toJSON(_, ctx) {\n        const pair = ctx?.mapAsMap ? new Map() : {};\n        return addPairToJSMap(ctx, pair, this);\n    }\n    toString(ctx, onComment, onChompKeep) {\n        return ctx?.doc\n            ? stringifyPair(this, ctx, onComment, onChompKeep)\n            : JSON.stringify(this);\n    }\n}\n\nexport { Pair, createPair };\n", "import { Collection } from '../nodes/Collection.js';\nimport { isNode, isPair } from '../nodes/Node.js';\nimport { stringify } from './stringify.js';\nimport { lineComment, indentComment } from './stringifyComment.js';\n\nfunction stringifyCollection(collection, ctx, options) {\n    const flow = ctx.inFlow ?? collection.flow;\n    const stringify = flow ? stringifyFlowCollection : stringifyBlockCollection;\n    return stringify(collection, ctx, options);\n}\nfunction stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) {\n    const { indent, options: { commentString } } = ctx;\n    const itemCtx = Object.assign({}, ctx, { indent: itemIndent, type: null });\n    let chompKeep = false; // flag for the preceding node's status\n    const lines = [];\n    for (let i = 0; i < items.length; ++i) {\n        const item = items[i];\n        let comment = null;\n        if (isNode(item)) {\n            if (!chompKeep && item.spaceBefore)\n                lines.push('');\n            addCommentBefore(ctx, lines, item.commentBefore, chompKeep);\n            if (item.comment)\n                comment = item.comment;\n        }\n        else if (isPair(item)) {\n            const ik = isNode(item.key) ? item.key : null;\n            if (ik) {\n                if (!chompKeep && ik.spaceBefore)\n                    lines.push('');\n                addCommentBefore(ctx, lines, ik.commentBefore, chompKeep);\n            }\n        }\n        chompKeep = false;\n        let str = stringify(item, itemCtx, () => (comment = null), () => (chompKeep = true));\n        if (comment)\n            str += lineComment(str, itemIndent, commentString(comment));\n        if (chompKeep && comment)\n            chompKeep = false;\n        lines.push(blockItemPrefix + str);\n    }\n    let str;\n    if (lines.length === 0) {\n        str = flowChars.start + flowChars.end;\n    }\n    else {\n        str = lines[0];\n        for (let i = 1; i < lines.length; ++i) {\n            const line = lines[i];\n            str += line ? `\\n${indent}${line}` : '\\n';\n        }\n    }\n    if (comment) {\n        str += '\\n' + indentComment(commentString(comment), indent);\n        if (onComment)\n            onComment();\n    }\n    else if (chompKeep && onChompKeep)\n        onChompKeep();\n    return str;\n}\nfunction stringifyFlowCollection({ comment, items }, ctx, { flowChars, itemIndent, onComment }) {\n    const { indent, indentStep, options: { commentString } } = ctx;\n    itemIndent += indentStep;\n    const itemCtx = Object.assign({}, ctx, {\n        indent: itemIndent,\n        inFlow: true,\n        type: null\n    });\n    let reqNewline = false;\n    let linesAtValue = 0;\n    const lines = [];\n    for (let i = 0; i < items.length; ++i) {\n        const item = items[i];\n        let comment = null;\n        if (isNode(item)) {\n            if (item.spaceBefore)\n                lines.push('');\n            addCommentBefore(ctx, lines, item.commentBefore, false);\n            if (item.comment)\n                comment = item.comment;\n        }\n        else if (isPair(item)) {\n            const ik = isNode(item.key) ? item.key : null;\n            if (ik) {\n                if (ik.spaceBefore)\n                    lines.push('');\n                addCommentBefore(ctx, lines, ik.commentBefore, false);\n                if (ik.comment)\n                    reqNewline = true;\n            }\n            const iv = isNode(item.value) ? item.value : null;\n            if (iv) {\n                if (iv.comment)\n                    comment = iv.comment;\n                if (iv.commentBefore)\n                    reqNewline = true;\n            }\n            else if (item.value == null && ik && ik.comment) {\n                comment = ik.comment;\n            }\n        }\n        if (comment)\n            reqNewline = true;\n        let str = stringify(item, itemCtx, () => (comment = null));\n        if (i < items.length - 1)\n            str += ',';\n        if (comment)\n            str += lineComment(str, itemIndent, commentString(comment));\n        if (!reqNewline && (lines.length > linesAtValue || str.includes('\\n')))\n            reqNewline = true;\n        lines.push(str);\n        linesAtValue = lines.length;\n    }\n    let str;\n    const { start, end } = flowChars;\n    if (lines.length === 0) {\n        str = start + end;\n    }\n    else {\n        if (!reqNewline) {\n            const len = lines.reduce((sum, line) => sum + line.length + 2, 2);\n            reqNewline = len > Collection.maxFlowStringSingleLineLength;\n        }\n        if (reqNewline) {\n            str = start;\n            for (const line of lines)\n                str += line ? `\\n${indentStep}${indent}${line}` : '\\n';\n            str += `\\n${indent}${end}`;\n        }\n        else {\n            str = `${start} ${lines.join(' ')} ${end}`;\n        }\n    }\n    if (comment) {\n        str += lineComment(str, commentString(comment), indent);\n        if (onComment)\n            onComment();\n    }\n    return str;\n}\nfunction addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) {\n    if (comment && chompKeep)\n        comment = comment.replace(/^\\n+/, '');\n    if (comment) {\n        const ic = indentComment(commentString(comment), indent);\n        lines.push(ic.trimStart()); // Avoid double indent on first line\n    }\n}\n\nexport { stringifyCollection };\n", "import { stringifyCollection } from '../stringify/stringifyCollection.js';\nimport { addPairToJSMap } from './addPairToJSMap.js';\nimport { Collection } from './Collection.js';\nimport { isPair, isScalar, MAP } from './Node.js';\nimport { Pair } from './Pair.js';\nimport { isScalarValue } from './Scalar.js';\n\nfunction findPair(items, key) {\n    const k = isScalar(key) ? key.value : key;\n    for (const it of items) {\n        if (isPair(it)) {\n            if (it.key === key || it.key === k)\n                return it;\n            if (isScalar(it.key) && it.key.value === k)\n                return it;\n        }\n    }\n    return undefined;\n}\nclass YAMLMap extends Collection {\n    constructor(schema) {\n        super(MAP, schema);\n        this.items = [];\n    }\n    static get tagName() {\n        return 'tag:yaml.org,2002:map';\n    }\n    /**\n     * Adds a value to the collection.\n     *\n     * @param overwrite - If not set `true`, using a key that is already in the\n     *   collection will throw. Otherwise, overwrites the previous value.\n     */\n    add(pair, overwrite) {\n        let _pair;\n        if (isPair(pair))\n            _pair = pair;\n        else if (!pair || typeof pair !== 'object' || !('key' in pair)) {\n            // In TypeScript, this never happens.\n            _pair = new Pair(pair, pair?.value);\n        }\n        else\n            _pair = new Pair(pair.key, pair.value);\n        const prev = findPair(this.items, _pair.key);\n        const sortEntries = this.schema?.sortMapEntries;\n        if (prev) {\n            if (!overwrite)\n                throw new Error(`Key ${_pair.key} already set`);\n            // For scalars, keep the old node & its comments and anchors\n            if (isScalar(prev.value) && isScalarValue(_pair.value))\n                prev.value.value = _pair.value;\n            else\n                prev.value = _pair.value;\n        }\n        else if (sortEntries) {\n            const i = this.items.findIndex(item => sortEntries(_pair, item) < 0);\n            if (i === -1)\n                this.items.push(_pair);\n            else\n                this.items.splice(i, 0, _pair);\n        }\n        else {\n            this.items.push(_pair);\n        }\n    }\n    delete(key) {\n        const it = findPair(this.items, key);\n        if (!it)\n            return false;\n        const del = this.items.splice(this.items.indexOf(it), 1);\n        return del.length > 0;\n    }\n    get(key, keepScalar) {\n        const it = findPair(this.items, key);\n        const node = it?.value;\n        return (!keepScalar && isScalar(node) ? node.value : node) ?? undefined;\n    }\n    has(key) {\n        return !!findPair(this.items, key);\n    }\n    set(key, value) {\n        this.add(new Pair(key, value), true);\n    }\n    /**\n     * @param ctx - Conversion context, originally set in Document#toJS()\n     * @param {Class} Type - If set, forces the returned collection type\n     * @returns Instance of Type, Map, or Object\n     */\n    toJSON(_, ctx, Type) {\n        const map = Type ? new Type() : ctx?.mapAsMap ? new Map() : {};\n        if (ctx?.onCreate)\n            ctx.onCreate(map);\n        for (const item of this.items)\n            addPairToJSMap(ctx, map, item);\n        return map;\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        for (const item of this.items) {\n            if (!isPair(item))\n                throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);\n        }\n        if (!ctx.allNullValues && this.hasAllNullValues(false))\n            ctx = Object.assign({}, ctx, { allNullValues: true });\n        return stringifyCollection(this, ctx, {\n            blockItemPrefix: '',\n            flowChars: { start: '{', end: '}' },\n            itemIndent: ctx.indent || '',\n            onChompKeep,\n            onComment\n        });\n    }\n}\n\nexport { YAMLMap, findPair };\n", "import { isMap } from '../../nodes/Node.js';\nimport { createPair } from '../../nodes/Pair.js';\nimport { YAMLMap } from '../../nodes/YAMLMap.js';\n\nfunction createMap(schema, obj, ctx) {\n    const { keepUndefined, replacer } = ctx;\n    const map = new YAMLMap(schema);\n    const add = (key, value) => {\n        if (typeof replacer === 'function')\n            value = replacer.call(obj, key, value);\n        else if (Array.isArray(replacer) && !replacer.includes(key))\n            return;\n        if (value !== undefined || keepUndefined)\n            map.items.push(createPair(key, value, ctx));\n    };\n    if (obj instanceof Map) {\n        for (const [key, value] of obj)\n            add(key, value);\n    }\n    else if (obj && typeof obj === 'object') {\n        for (const key of Object.keys(obj))\n            add(key, obj[key]);\n    }\n    if (typeof schema.sortMapEntries === 'function') {\n        map.items.sort(schema.sortMapEntries);\n    }\n    return map;\n}\nconst map = {\n    collection: 'map',\n    createNode: createMap,\n    default: true,\n    nodeClass: YAMLMap,\n    tag: 'tag:yaml.org,2002:map',\n    resolve(map, onError) {\n        if (!isMap(map))\n            onError('Expected a mapping for this tag');\n        return map;\n    }\n};\n\nexport { map };\n", "import { stringifyCollection } from '../stringify/stringifyCollection.js';\nimport { Collection } from './Collection.js';\nimport { SEQ, isScalar } from './Node.js';\nimport { isScalarValue } from './Scalar.js';\nimport { toJS } from './toJS.js';\n\nclass YAMLSeq extends Collection {\n    constructor(schema) {\n        super(SEQ, schema);\n        this.items = [];\n    }\n    static get tagName() {\n        return 'tag:yaml.org,2002:seq';\n    }\n    add(value) {\n        this.items.push(value);\n    }\n    /**\n     * Removes a value from the collection.\n     *\n     * `key` must contain a representation of an integer for this to succeed.\n     * It may be wrapped in a `Scalar`.\n     *\n     * @returns `true` if the item was found and removed.\n     */\n    delete(key) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            return false;\n        const del = this.items.splice(idx, 1);\n        return del.length > 0;\n    }\n    get(key, keepScalar) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            return undefined;\n        const it = this.items[idx];\n        return !keepScalar && isScalar(it) ? it.value : it;\n    }\n    /**\n     * Checks if the collection includes a value with the key `key`.\n     *\n     * `key` must contain a representation of an integer for this to succeed.\n     * It may be wrapped in a `Scalar`.\n     */\n    has(key) {\n        const idx = asItemIndex(key);\n        return typeof idx === 'number' && idx < this.items.length;\n    }\n    /**\n     * Sets a value in this collection. For `!!set`, `value` needs to be a\n     * boolean to add/remove the item from the set.\n     *\n     * If `key` does not contain a representation of an integer, this will throw.\n     * It may be wrapped in a `Scalar`.\n     */\n    set(key, value) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            throw new Error(`Expected a valid index, not ${key}.`);\n        const prev = this.items[idx];\n        if (isScalar(prev) && isScalarValue(value))\n            prev.value = value;\n        else\n            this.items[idx] = value;\n    }\n    toJSON(_, ctx) {\n        const seq = [];\n        if (ctx?.onCreate)\n            ctx.onCreate(seq);\n        let i = 0;\n        for (const item of this.items)\n            seq.push(toJS(item, String(i++), ctx));\n        return seq;\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        return stringifyCollection(this, ctx, {\n            blockItemPrefix: '- ',\n            flowChars: { start: '[', end: ']' },\n            itemIndent: (ctx.indent || '') + '  ',\n            onChompKeep,\n            onComment\n        });\n    }\n}\nfunction asItemIndex(key) {\n    let idx = isScalar(key) ? key.value : key;\n    if (idx && typeof idx === 'string')\n        idx = Number(idx);\n    return typeof idx === 'number' && Number.isInteger(idx) && idx >= 0\n        ? idx\n        : null;\n}\n\nexport { YAMLSeq };\n", "import { createNode } from '../../doc/createNode.js';\nimport { isSeq } from '../../nodes/Node.js';\nimport { YAMLSeq } from '../../nodes/YAMLSeq.js';\n\nfunction createSeq(schema, obj, ctx) {\n    const { replacer } = ctx;\n    const seq = new YAMLSeq(schema);\n    if (obj && Symbol.iterator in Object(obj)) {\n        let i = 0;\n        for (let it of obj) {\n            if (typeof replacer === 'function') {\n                const key = obj instanceof Set ? it : String(i++);\n                it = replacer.call(obj, key, it);\n            }\n            seq.items.push(createNode(it, undefined, ctx));\n        }\n    }\n    return seq;\n}\nconst seq = {\n    collection: 'seq',\n    createNode: createSeq,\n    default: true,\n    nodeClass: YAMLSeq,\n    tag: 'tag:yaml.org,2002:seq',\n    resolve(seq, onError) {\n        if (!isSeq(seq))\n            onError('Expected a sequence for this tag');\n        return seq;\n    }\n};\n\nexport { seq };\n", "import { stringifyString } from '../../stringify/stringifyString.js';\n\nconst string = {\n    identify: value => typeof value === 'string',\n    default: true,\n    tag: 'tag:yaml.org,2002:str',\n    resolve: str => str,\n    stringify(item, ctx, onComment, onChompKeep) {\n        ctx = Object.assign({ actualString: true }, ctx);\n        return stringifyString(item, ctx, onComment, onChompKeep);\n    }\n};\n\nexport { string };\n", "import { Scalar } from '../../nodes/Scalar.js';\n\nconst nullTag = {\n    identify: value => value == null,\n    createNode: () => new Scalar(null),\n    default: true,\n    tag: 'tag:yaml.org,2002:null',\n    test: /^(?:~|[Nn]ull|NULL)?$/,\n    resolve: () => new Scalar(null),\n    stringify: ({ source }, ctx) => typeof source === 'string' && nullTag.test.test(source)\n        ? source\n        : ctx.options.nullStr\n};\n\nexport { nullTag };\n", "import { Scalar } from '../../nodes/Scalar.js';\n\nconst boolTag = {\n    identify: value => typeof value === 'boolean',\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,\n    resolve: str => new Scalar(str[0] === 't' || str[0] === 'T'),\n    stringify({ source, value }, ctx) {\n        if (source && boolTag.test.test(source)) {\n            const sv = source[0] === 't' || source[0] === 'T';\n            if (value === sv)\n                return source;\n        }\n        return value ? ctx.options.trueStr : ctx.options.falseStr;\n    }\n};\n\nexport { boolTag };\n", "function stringifyNumber({ format, minFractionDigits, tag, value }) {\n    if (typeof value === 'bigint')\n        return String(value);\n    const num = typeof value === 'number' ? value : Number(value);\n    if (!isFinite(num))\n        return isNaN(num) ? '.nan' : num < 0 ? '-.inf' : '.inf';\n    let n = JSON.stringify(value);\n    if (!format &&\n        minFractionDigits &&\n        (!tag || tag === 'tag:yaml.org,2002:float') &&\n        /^\\d/.test(n)) {\n        let i = n.indexOf('.');\n        if (i < 0) {\n            i = n.length;\n            n += '.';\n        }\n        let d = minFractionDigits - (n.length - i - 1);\n        while (d-- > 0)\n            n += '0';\n    }\n    return n;\n}\n\nexport { stringifyNumber };\n", "import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst floatNaN = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^(?:[-+]?\\.(?:inf|Inf|INF|nan|NaN|NAN))$/,\n    resolve: str => str.slice(-3).toLowerCase() === 'nan'\n        ? NaN\n        : str[0] === '-'\n            ? Number.NEGATIVE_INFINITY\n            : Number.POSITIVE_INFINITY,\n    stringify: stringifyNumber\n};\nconst floatExp = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'EXP',\n    test: /^[-+]?(?:\\.[0-9]+|[0-9]+(?:\\.[0-9]*)?)[eE][-+]?[0-9]+$/,\n    resolve: str => parseFloat(str),\n    stringify(node) {\n        const num = Number(node.value);\n        return isFinite(num) ? num.toExponential() : stringifyNumber(node);\n    }\n};\nconst float = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^[-+]?(?:\\.[0-9]+|[0-9]+\\.[0-9]*)$/,\n    resolve(str) {\n        const node = new Scalar(parseFloat(str));\n        const dot = str.indexOf('.');\n        if (dot !== -1 && str[str.length - 1] === '0')\n            node.minFractionDigits = str.length - dot - 1;\n        return node;\n    },\n    stringify: stringifyNumber\n};\n\nexport { float, floatExp, floatNaN };\n", "import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);\nconst intResolve = (str, offset, radix, { intAsBigInt }) => (intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix));\nfunction intStringify(node, radix, prefix) {\n    const { value } = node;\n    if (intIdentify(value) && value >= 0)\n        return prefix + value.toString(radix);\n    return stringifyNumber(node);\n}\nconst intOct = {\n    identify: value => intIdentify(value) && value >= 0,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'OCT',\n    test: /^0o[0-7]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt),\n    stringify: node => intStringify(node, 8, '0o')\n};\nconst int = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    test: /^[-+]?[0-9]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),\n    stringify: stringifyNumber\n};\nconst intHex = {\n    identify: value => intIdentify(value) && value >= 0,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'HEX',\n    test: /^0x[0-9a-fA-F]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),\n    stringify: node => intStringify(node, 16, '0x')\n};\n\nexport { int, intHex, intOct };\n", "import { map } from '../common/map.js';\nimport { nullTag } from '../common/null.js';\nimport { seq } from '../common/seq.js';\nimport { string } from '../common/string.js';\nimport { boolTag } from './bool.js';\nimport { floatNaN, floatExp, float } from './float.js';\nimport { intOct, int, intHex } from './int.js';\n\nconst schema = [\n    map,\n    seq,\n    string,\n    nullTag,\n    boolTag,\n    intOct,\n    int,\n    intHex,\n    floatNaN,\n    floatExp,\n    float\n];\n\nexport { schema };\n", "import { Scalar } from '../../nodes/Scalar.js';\nimport { map } from '../common/map.js';\nimport { seq } from '../common/seq.js';\n\nfunction intIdentify(value) {\n    return typeof value === 'bigint' || Number.isInteger(value);\n}\nconst stringifyJSON = ({ value }) => JSON.stringify(value);\nconst jsonScalars = [\n    {\n        identify: value => typeof value === 'string',\n        default: true,\n        tag: 'tag:yaml.org,2002:str',\n        resolve: str => str,\n        stringify: stringifyJSON\n    },\n    {\n        identify: value => value == null,\n        createNode: () => new Scalar(null),\n        default: true,\n        tag: 'tag:yaml.org,2002:null',\n        test: /^null$/,\n        resolve: () => null,\n        stringify: stringifyJSON\n    },\n    {\n        identify: value => typeof value === 'boolean',\n        default: true,\n        tag: 'tag:yaml.org,2002:bool',\n        test: /^true|false$/,\n        resolve: str => str === 'true',\n        stringify: stringifyJSON\n    },\n    {\n        identify: intIdentify,\n        default: true,\n        tag: 'tag:yaml.org,2002:int',\n        test: /^-?(?:0|[1-9][0-9]*)$/,\n        resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10),\n        stringify: ({ value }) => intIdentify(value) ? value.toString() : JSON.stringify(value)\n    },\n    {\n        identify: value => typeof value === 'number',\n        default: true,\n        tag: 'tag:yaml.org,2002:float',\n        test: /^-?(?:0|[1-9][0-9]*)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,\n        resolve: str => parseFloat(str),\n        stringify: stringifyJSON\n    }\n];\nconst jsonError = {\n    default: true,\n    tag: '',\n    test: /^/,\n    resolve(str, onError) {\n        onError(`Unresolved plain scalar ${JSON.stringify(str)}`);\n        return str;\n    }\n};\nconst schema = [map, seq].concat(jsonScalars, jsonError);\n\nexport { schema };\n", "import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyString } from '../../stringify/stringifyString.js';\n\nconst binary = {\n    identify: value => value instanceof Uint8Array,\n    default: false,\n    tag: 'tag:yaml.org,2002:binary',\n    /**\n     * Returns a Buffer in node and an Uint8Array in browsers\n     *\n     * To use the resulting buffer as an image, you'll want to do something like:\n     *\n     *   const blob = new Blob([buffer], { type: 'image/jpeg' })\n     *   document.querySelector('#photo').src = URL.createObjectURL(blob)\n     */\n    resolve(src, onError) {\n        if (typeof Buffer === 'function') {\n            return Buffer.from(src, 'base64');\n        }\n        else if (typeof atob === 'function') {\n            // On IE 11, atob() can't handle newlines\n            const str = atob(src.replace(/[\\n\\r]/g, ''));\n            const buffer = new Uint8Array(str.length);\n            for (let i = 0; i < str.length; ++i)\n                buffer[i] = str.charCodeAt(i);\n            return buffer;\n        }\n        else {\n            onError('This environment does not support reading binary tags; either Buffer or atob is required');\n            return src;\n        }\n    },\n    stringify({ comment, type, value }, ctx, onComment, onChompKeep) {\n        const buf = value; // checked earlier by binary.identify()\n        let str;\n        if (typeof Buffer === 'function') {\n            str =\n                buf instanceof Buffer\n                    ? buf.toString('base64')\n                    : Buffer.from(buf.buffer).toString('base64');\n        }\n        else if (typeof btoa === 'function') {\n            let s = '';\n            for (let i = 0; i < buf.length; ++i)\n                s += String.fromCharCode(buf[i]);\n            str = btoa(s);\n        }\n        else {\n            throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required');\n        }\n        if (!type)\n            type = Scalar.BLOCK_LITERAL;\n        if (type !== Scalar.QUOTE_DOUBLE) {\n            const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);\n            const n = Math.ceil(str.length / lineWidth);\n            const lines = new Array(n);\n            for (let i = 0, o = 0; i < n; ++i, o += lineWidth) {\n                lines[i] = str.substr(o, lineWidth);\n            }\n            str = lines.join(type === Scalar.BLOCK_LITERAL ? '\\n' : ' ');\n        }\n        return stringifyString({ comment, type, value: str }, ctx, onComment, onChompKeep);\n    }\n};\n\nexport { binary };\n", "import { isSeq, isPair, isMap } from '../../nodes/Node.js';\nimport { Pair, createPair } from '../../nodes/Pair.js';\nimport { Scalar } from '../../nodes/Scalar.js';\nimport { YAMLSeq } from '../../nodes/YAMLSeq.js';\n\nfunction resolvePairs(seq, onError) {\n    if (isSeq(seq)) {\n        for (let i = 0; i < seq.items.length; ++i) {\n            let item = seq.items[i];\n            if (isPair(item))\n                continue;\n            else if (isMap(item)) {\n                if (item.items.length > 1)\n                    onError('Each pair must have its own sequence indicator');\n                const pair = item.items[0] || new Pair(new Scalar(null));\n                if (item.commentBefore)\n                    pair.key.commentBefore = pair.key.commentBefore\n                        ? `${item.commentBefore}\\n${pair.key.commentBefore}`\n                        : item.commentBefore;\n                if (item.comment) {\n                    const cn = pair.value ?? pair.key;\n                    cn.comment = cn.comment\n                        ? `${item.comment}\\n${cn.comment}`\n                        : item.comment;\n                }\n                item = pair;\n            }\n            seq.items[i] = isPair(item) ? item : new Pair(item);\n        }\n    }\n    else\n        onError('Expected a sequence for this tag');\n    return seq;\n}\nfunction createPairs(schema, iterable, ctx) {\n    const { replacer } = ctx;\n    const pairs = new YAMLSeq(schema);\n    pairs.tag = 'tag:yaml.org,2002:pairs';\n    let i = 0;\n    if (iterable && Symbol.iterator in Object(iterable))\n        for (let it of iterable) {\n            if (typeof replacer === 'function')\n                it = replacer.call(iterable, String(i++), it);\n            let key, value;\n            if (Array.isArray(it)) {\n                if (it.length === 2) {\n                    key = it[0];\n                    value = it[1];\n                }\n                else\n                    throw new TypeError(`Expected [key, value] tuple: ${it}`);\n            }\n            else if (it && it instanceof Object) {\n                const keys = Object.keys(it);\n                if (keys.length === 1) {\n                    key = keys[0];\n                    value = it[key];\n                }\n                else\n                    throw new TypeError(`Expected { key: value } tuple: ${it}`);\n            }\n            else {\n                key = it;\n            }\n            pairs.items.push(createPair(key, value, ctx));\n        }\n    return pairs;\n}\nconst pairs = {\n    collection: 'seq',\n    default: false,\n    tag: 'tag:yaml.org,2002:pairs',\n    resolve: resolvePairs,\n    createNode: createPairs\n};\n\nexport { createPairs, pairs, resolvePairs };\n", "import { YAMLSeq } from '../../nodes/YAMLSeq.js';\nimport { toJS } from '../../nodes/toJS.js';\nimport { isScalar, isPair } from '../../nodes/Node.js';\nimport { YAMLMap } from '../../nodes/YAMLMap.js';\nimport { resolvePairs, createPairs } from './pairs.js';\n\nclass YAMLOMap extends YAMLSeq {\n    constructor() {\n        super();\n        this.add = YAMLMap.prototype.add.bind(this);\n        this.delete = YAMLMap.prototype.delete.bind(this);\n        this.get = YAMLMap.prototype.get.bind(this);\n        this.has = YAMLMap.prototype.has.bind(this);\n        this.set = YAMLMap.prototype.set.bind(this);\n        this.tag = YAMLOMap.tag;\n    }\n    /**\n     * If `ctx` is given, the return type is actually `Map<unknown, unknown>`,\n     * but TypeScript won't allow widening the signature of a child method.\n     */\n    toJSON(_, ctx) {\n        if (!ctx)\n            return super.toJSON(_);\n        const map = new Map();\n        if (ctx?.onCreate)\n            ctx.onCreate(map);\n        for (const pair of this.items) {\n            let key, value;\n            if (isPair(pair)) {\n                key = toJS(pair.key, '', ctx);\n                value = toJS(pair.value, key, ctx);\n            }\n            else {\n                key = toJS(pair, '', ctx);\n            }\n            if (map.has(key))\n                throw new Error('Ordered maps must not include duplicate keys');\n            map.set(key, value);\n        }\n        return map;\n    }\n}\nYAMLOMap.tag = 'tag:yaml.org,2002:omap';\nconst omap = {\n    collection: 'seq',\n    identify: value => value instanceof Map,\n    nodeClass: YAMLOMap,\n    default: false,\n    tag: 'tag:yaml.org,2002:omap',\n    resolve(seq, onError) {\n        const pairs = resolvePairs(seq, onError);\n        const seenKeys = [];\n        for (const { key } of pairs.items) {\n            if (isScalar(key)) {\n                if (seenKeys.includes(key.value)) {\n                    onError(`Ordered maps must not include duplicate keys: ${key.value}`);\n                }\n                else {\n                    seenKeys.push(key.value);\n                }\n            }\n        }\n        return Object.assign(new YAMLOMap(), pairs);\n    },\n    createNode(schema, iterable, ctx) {\n        const pairs = createPairs(schema, iterable, ctx);\n        const omap = new YAMLOMap();\n        omap.items = pairs.items;\n        return omap;\n    }\n};\n\nexport { YAMLOMap, omap };\n", "import { Scalar } from '../../nodes/Scalar.js';\n\nfunction boolStringify({ value, source }, ctx) {\n    const boolObj = value ? trueTag : falseTag;\n    if (source && boolObj.test.test(source))\n        return source;\n    return value ? ctx.options.trueStr : ctx.options.falseStr;\n}\nconst trueTag = {\n    identify: value => value === true,\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,\n    resolve: () => new Scalar(true),\n    stringify: boolStringify\n};\nconst falseTag = {\n    identify: value => value === false,\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i,\n    resolve: () => new Scalar(false),\n    stringify: boolStringify\n};\n\nexport { falseTag, trueTag };\n", "import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst floatNaN = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^[-+]?\\.(?:inf|Inf|INF|nan|NaN|NAN)$/,\n    resolve: (str) => str.slice(-3).toLowerCase() === 'nan'\n        ? NaN\n        : str[0] === '-'\n            ? Number.NEGATIVE_INFINITY\n            : Number.POSITIVE_INFINITY,\n    stringify: stringifyNumber\n};\nconst floatExp = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'EXP',\n    test: /^[-+]?(?:[0-9][0-9_]*)?(?:\\.[0-9_]*)?[eE][-+]?[0-9]+$/,\n    resolve: (str) => parseFloat(str.replace(/_/g, '')),\n    stringify(node) {\n        const num = Number(node.value);\n        return isFinite(num) ? num.toExponential() : stringifyNumber(node);\n    }\n};\nconst float = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^[-+]?(?:[0-9][0-9_]*)?\\.[0-9_]*$/,\n    resolve(str) {\n        const node = new Scalar(parseFloat(str.replace(/_/g, '')));\n        const dot = str.indexOf('.');\n        if (dot !== -1) {\n            const f = str.substring(dot + 1).replace(/_/g, '');\n            if (f[f.length - 1] === '0')\n                node.minFractionDigits = f.length;\n        }\n        return node;\n    },\n    stringify: stringifyNumber\n};\n\nexport { float, floatExp, floatNaN };\n", "import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);\nfunction intResolve(str, offset, radix, { intAsBigInt }) {\n    const sign = str[0];\n    if (sign === '-' || sign === '+')\n        offset += 1;\n    str = str.substring(offset).replace(/_/g, '');\n    if (intAsBigInt) {\n        switch (radix) {\n            case 2:\n                str = `0b${str}`;\n                break;\n            case 8:\n                str = `0o${str}`;\n                break;\n            case 16:\n                str = `0x${str}`;\n                break;\n        }\n        const n = BigInt(str);\n        return sign === '-' ? BigInt(-1) * n : n;\n    }\n    const n = parseInt(str, radix);\n    return sign === '-' ? -1 * n : n;\n}\nfunction intStringify(node, radix, prefix) {\n    const { value } = node;\n    if (intIdentify(value)) {\n        const str = value.toString(radix);\n        return value < 0 ? '-' + prefix + str.substr(1) : prefix + str;\n    }\n    return stringifyNumber(node);\n}\nconst intBin = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'BIN',\n    test: /^[-+]?0b[0-1_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt),\n    stringify: node => intStringify(node, 2, '0b')\n};\nconst intOct = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'OCT',\n    test: /^[-+]?0[0-7_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt),\n    stringify: node => intStringify(node, 8, '0')\n};\nconst int = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    test: /^[-+]?[0-9][0-9_]*$/,\n    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),\n    stringify: stringifyNumber\n};\nconst intHex = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'HEX',\n    test: /^[-+]?0x[0-9a-fA-F_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),\n    stringify: node => intStringify(node, 16, '0x')\n};\n\nexport { int, intBin, intHex, intOct };\n", "import { isMap, isPair, isScalar } from '../../nodes/Node.js';\nimport { createPair, Pair } from '../../nodes/Pair.js';\nimport { YAMLMap, findPair } from '../../nodes/YAMLMap.js';\n\nclass YAMLSet extends YAMLMap {\n    constructor(schema) {\n        super(schema);\n        this.tag = YAMLSet.tag;\n    }\n    add(key) {\n        let pair;\n        if (isPair(key))\n            pair = key;\n        else if (typeof key === 'object' &&\n            'key' in key &&\n            'value' in key &&\n            key.value === null)\n            pair = new Pair(key.key, null);\n        else\n            pair = new Pair(key, null);\n        const prev = findPair(this.items, pair.key);\n        if (!prev)\n            this.items.push(pair);\n    }\n    /**\n     * If `keepPair` is `true`, returns the Pair matching `key`.\n     * Otherwise, returns the value of that Pair's key.\n     */\n    get(key, keepPair) {\n        const pair = findPair(this.items, key);\n        return !keepPair && isPair(pair)\n            ? isScalar(pair.key)\n                ? pair.key.value\n                : pair.key\n            : pair;\n    }\n    set(key, value) {\n        if (typeof value !== 'boolean')\n            throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);\n        const prev = findPair(this.items, key);\n        if (prev && !value) {\n            this.items.splice(this.items.indexOf(prev), 1);\n        }\n        else if (!prev && value) {\n            this.items.push(new Pair(key));\n        }\n    }\n    toJSON(_, ctx) {\n        return super.toJSON(_, ctx, Set);\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        if (this.hasAllNullValues(true))\n            return super.toString(Object.assign({}, ctx, { allNullValues: true }), onComment, onChompKeep);\n        else\n            throw new Error('Set items must all have null values');\n    }\n}\nYAMLSet.tag = 'tag:yaml.org,2002:set';\nconst set = {\n    collection: 'map',\n    identify: value => value instanceof Set,\n    nodeClass: YAMLSet,\n    default: false,\n    tag: 'tag:yaml.org,2002:set',\n    resolve(map, onError) {\n        if (isMap(map)) {\n            if (map.hasAllNullValues(true))\n                return Object.assign(new YAMLSet(), map);\n            else\n                onError('Set items must all have null values');\n        }\n        else\n            onError('Expected a mapping for this tag');\n        return map;\n    },\n    createNode(schema, iterable, ctx) {\n        const { replacer } = ctx;\n        const set = new YAMLSet(schema);\n        if (iterable && Symbol.iterator in Object(iterable))\n            for (let value of iterable) {\n                if (typeof replacer === 'function')\n                    value = replacer.call(iterable, value, value);\n                set.items.push(createPair(value, null, ctx));\n            }\n        return set;\n    }\n};\n\nexport { YAMLSet, set };\n", "import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\n/** Internal types handle bigint as number, because TS can't figure it out. */\nfunction parseSexagesimal(str, asBigInt) {\n    const sign = str[0];\n    const parts = sign === '-' || sign === '+' ? str.substring(1) : str;\n    const num = (n) => asBigInt ? BigInt(n) : Number(n);\n    const res = parts\n        .replace(/_/g, '')\n        .split(':')\n        .reduce((res, p) => res * num(60) + num(p), num(0));\n    return (sign === '-' ? num(-1) * res : res);\n}\n/**\n * hhhh:mm:ss.sss\n *\n * Internal types handle bigint as number, because TS can't figure it out.\n */\nfunction stringifySexagesimal(node) {\n    let { value } = node;\n    let num = (n) => n;\n    if (typeof value === 'bigint')\n        num = n => BigInt(n);\n    else if (isNaN(value) || !isFinite(value))\n        return stringifyNumber(node);\n    let sign = '';\n    if (value < 0) {\n        sign = '-';\n        value *= num(-1);\n    }\n    const _60 = num(60);\n    const parts = [value % _60]; // seconds, including ms\n    if (value < 60) {\n        parts.unshift(0); // at least one : is required\n    }\n    else {\n        value = (value - parts[0]) / _60;\n        parts.unshift(value % _60); // minutes\n        if (value >= 60) {\n            value = (value - parts[0]) / _60;\n            parts.unshift(value); // hours\n        }\n    }\n    return (sign +\n        parts\n            .map(n => (n < 10 ? '0' + String(n) : String(n)))\n            .join(':')\n            .replace(/000000\\d*$/, '') // % 60 may introduce error\n    );\n}\nconst intTime = {\n    identify: value => typeof value === 'bigint' || Number.isInteger(value),\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'TIME',\n    test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,\n    resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt),\n    stringify: stringifySexagesimal\n};\nconst floatTime = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'TIME',\n    test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*$/,\n    resolve: str => parseSexagesimal(str, false),\n    stringify: stringifySexagesimal\n};\nconst timestamp = {\n    identify: value => value instanceof Date,\n    default: true,\n    tag: 'tag:yaml.org,2002:timestamp',\n    // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part\n    // may be omitted altogether, resulting in a date format. In such a case, the time part is\n    // assumed to be 00:00:00Z (start of day, UTC).\n    test: RegExp('^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})' + // YYYY-Mm-Dd\n        '(?:' + // time is optional\n        '(?:t|T|[ \\\\t]+)' + // t | T | whitespace\n        '([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\\\.[0-9]+)?)' + // Hh:Mm:Ss(.ss)?\n        '(?:[ \\\\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?' + // Z | +5 | -03:30\n        ')?$'),\n    resolve(str) {\n        const match = str.match(timestamp.test);\n        if (!match)\n            throw new Error('!!timestamp expects a date, starting with yyyy-mm-dd');\n        const [, year, month, day, hour, minute, second] = match.map(Number);\n        const millisec = match[7] ? Number((match[7] + '00').substr(1, 3)) : 0;\n        let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);\n        const tz = match[8];\n        if (tz && tz !== 'Z') {\n            let d = parseSexagesimal(tz, false);\n            if (Math.abs(d) < 30)\n                d *= 60;\n            date -= 60000 * d;\n        }\n        return new Date(date);\n    },\n    stringify: ({ value }) => value.toISOString().replace(/((T00:00)?:00)?\\.000Z$/, '')\n};\n\nexport { floatTime, intTime, timestamp };\n", "import { map } from '../common/map.js';\nimport { nullTag } from '../common/null.js';\nimport { seq } from '../common/seq.js';\nimport { string } from '../common/string.js';\nimport { binary } from './binary.js';\nimport { trueTag, falseTag } from './bool.js';\nimport { floatNaN, floatExp, float } from './float.js';\nimport { intBin, intOct, int, intHex } from './int.js';\nimport { omap } from './omap.js';\nimport { pairs } from './pairs.js';\nimport { set } from './set.js';\nimport { intTime, floatTime, timestamp } from './timestamp.js';\n\nconst schema = [\n    map,\n    seq,\n    string,\n    nullTag,\n    trueTag,\n    falseTag,\n    intBin,\n    intOct,\n    int,\n    intHex,\n    floatNaN,\n    floatExp,\n    float,\n    binary,\n    omap,\n    pairs,\n    set,\n    intTime,\n    floatTime,\n    timestamp\n];\n\nexport { schema };\n", "import { map } from './common/map.js';\nimport { nullTag } from './common/null.js';\nimport { seq } from './common/seq.js';\nimport { string } from './common/string.js';\nimport { boolTag } from './core/bool.js';\nimport { float, floatExp, floatNaN } from './core/float.js';\nimport { int, intHex, intOct } from './core/int.js';\nimport { schema } from './core/schema.js';\nimport { schema as schema$1 } from './json/schema.js';\nimport { binary } from './yaml-1.1/binary.js';\nimport { omap } from './yaml-1.1/omap.js';\nimport { pairs } from './yaml-1.1/pairs.js';\nimport { schema as schema$2 } from './yaml-1.1/schema.js';\nimport { set } from './yaml-1.1/set.js';\nimport { floatTime, intTime, timestamp } from './yaml-1.1/timestamp.js';\n\nconst schemas = new Map([\n    ['core', schema],\n    ['failsafe', [map, seq, string]],\n    ['json', schema$1],\n    ['yaml11', schema$2],\n    ['yaml-1.1', schema$2]\n]);\nconst tagsByName = {\n    binary,\n    bool: boolTag,\n    float,\n    floatExp,\n    floatNaN,\n    floatTime,\n    int,\n    intHex,\n    intOct,\n    intTime,\n    map,\n    null: nullTag,\n    omap,\n    pairs,\n    seq,\n    set,\n    timestamp\n};\nconst coreKnownTags = {\n    'tag:yaml.org,2002:binary': binary,\n    'tag:yaml.org,2002:omap': omap,\n    'tag:yaml.org,2002:pairs': pairs,\n    'tag:yaml.org,2002:set': set,\n    'tag:yaml.org,2002:timestamp': timestamp\n};\nfunction getTags(customTags, schemaName) {\n    let tags = schemas.get(schemaName);\n    if (!tags) {\n        if (Array.isArray(customTags))\n            tags = [];\n        else {\n            const keys = Array.from(schemas.keys())\n                .filter(key => key !== 'yaml11')\n                .map(key => JSON.stringify(key))\n                .join(', ');\n            throw new Error(`Unknown schema \"${schemaName}\"; use one of ${keys} or define customTags array`);\n        }\n    }\n    if (Array.isArray(customTags)) {\n        for (const tag of customTags)\n            tags = tags.concat(tag);\n    }\n    else if (typeof customTags === 'function') {\n        tags = customTags(tags.slice());\n    }\n    return tags.map(tag => {\n        if (typeof tag !== 'string')\n            return tag;\n        const tagObj = tagsByName[tag];\n        if (tagObj)\n            return tagObj;\n        const keys = Object.keys(tagsByName)\n            .map(key => JSON.stringify(key))\n            .join(', ');\n        throw new Error(`Unknown custom tag \"${tag}\"; use one of ${keys}`);\n    });\n}\n\nexport { coreKnownTags, getTags };\n", "import { MAP, SCALAR, SEQ } from '../nodes/Node.js';\nimport { map } from './common/map.js';\nimport { seq } from './common/seq.js';\nimport { string } from './common/string.js';\nimport { getTags, coreKnownTags } from './tags.js';\n\nconst sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;\nclass Schema {\n    constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {\n        this.compat = Array.isArray(compat)\n            ? getTags(compat, 'compat')\n            : compat\n                ? getTags(null, compat)\n                : null;\n        this.merge = !!merge;\n        this.name = (typeof schema === 'string' && schema) || 'core';\n        this.knownTags = resolveKnownTags ? coreKnownTags : {};\n        this.tags = getTags(customTags, this.name);\n        this.toStringOptions = toStringDefaults ?? null;\n        Object.defineProperty(this, MAP, { value: map });\n        Object.defineProperty(this, SCALAR, { value: string });\n        Object.defineProperty(this, SEQ, { value: seq });\n        // Used by createMap()\n        this.sortMapEntries =\n            typeof sortMapEntries === 'function'\n                ? sortMapEntries\n                : sortMapEntries === true\n                    ? sortMapEntriesByKey\n                    : null;\n    }\n    clone() {\n        const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this));\n        copy.tags = this.tags.slice();\n        return copy;\n    }\n}\n\nexport { Schema };\n", "import { isNode } from '../nodes/Node.js';\nimport { createStringifyContext, stringify } from './stringify.js';\nimport { indentComment, lineComment } from './stringifyComment.js';\n\nfunction stringifyDocument(doc, options) {\n    const lines = [];\n    let hasDirectives = options.directives === true;\n    if (options.directives !== false && doc.directives) {\n        const dir = doc.directives.toString(doc);\n        if (dir) {\n            lines.push(dir);\n            hasDirectives = true;\n        }\n        else if (doc.directives.docStart)\n            hasDirectives = true;\n    }\n    if (hasDirectives)\n        lines.push('---');\n    const ctx = createStringifyContext(doc, options);\n    const { commentString } = ctx.options;\n    if (doc.commentBefore) {\n        if (lines.length !== 1)\n            lines.unshift('');\n        const cs = commentString(doc.commentBefore);\n        lines.unshift(indentComment(cs, ''));\n    }\n    let chompKeep = false;\n    let contentComment = null;\n    if (doc.contents) {\n        if (isNode(doc.contents)) {\n            if (doc.contents.spaceBefore && hasDirectives)\n                lines.push('');\n            if (doc.contents.commentBefore) {\n                const cs = commentString(doc.contents.commentBefore);\n                lines.push(indentComment(cs, ''));\n            }\n            // top-level block scalars need to be indented if followed by a comment\n            ctx.forceBlockIndent = !!doc.comment;\n            contentComment = doc.contents.comment;\n        }\n        const onChompKeep = contentComment ? undefined : () => (chompKeep = true);\n        let body = stringify(doc.contents, ctx, () => (contentComment = null), onChompKeep);\n        if (contentComment)\n            body += lineComment(body, '', commentString(contentComment));\n        if ((body[0] === '|' || body[0] === '>') &&\n            lines[lines.length - 1] === '---') {\n            // Top-level block scalars with a preceding doc marker ought to use the\n            // same line for their header.\n            lines[lines.length - 1] = `--- ${body}`;\n        }\n        else\n            lines.push(body);\n    }\n    else {\n        lines.push(stringify(doc.contents, ctx));\n    }\n    if (doc.directives?.docEnd) {\n        if (doc.comment) {\n            const cs = commentString(doc.comment);\n            if (cs.includes('\\n')) {\n                lines.push('...');\n                lines.push(indentComment(cs, ''));\n            }\n            else {\n                lines.push(`... ${cs}`);\n            }\n        }\n        else {\n            lines.push('...');\n        }\n    }\n    else {\n        let dc = doc.comment;\n        if (dc && chompKeep)\n            dc = dc.replace(/^\\n+/, '');\n        if (dc) {\n            if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')\n                lines.push('');\n            lines.push(indentComment(commentString(dc), ''));\n        }\n    }\n    return lines.join('\\n') + '\\n';\n}\n\nexport { stringifyDocument };\n", "/**\n * Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,\n * in section 24.5.1.1 \"Runtime Semantics: InternalizeJSONProperty\" of the\n * 2021 edition: https://tc39.es/ecma262/#sec-json.parse\n *\n * Includes extensions for handling Map and Set objects.\n */\nfunction applyReviver(reviver, obj, key, val) {\n    if (val && typeof val === 'object') {\n        if (Array.isArray(val)) {\n            for (let i = 0, len = val.length; i < len; ++i) {\n                const v0 = val[i];\n                const v1 = applyReviver(reviver, val, String(i), v0);\n                if (v1 === undefined)\n                    delete val[i];\n                else if (v1 !== v0)\n                    val[i] = v1;\n            }\n        }\n        else if (val instanceof Map) {\n            for (const k of Array.from(val.keys())) {\n                const v0 = val.get(k);\n                const v1 = applyReviver(reviver, val, k, v0);\n                if (v1 === undefined)\n                    val.delete(k);\n                else if (v1 !== v0)\n                    val.set(k, v1);\n            }\n        }\n        else if (val instanceof Set) {\n            for (const v0 of Array.from(val)) {\n                const v1 = applyReviver(reviver, val, v0, v0);\n                if (v1 === undefined)\n                    val.delete(v0);\n                else if (v1 !== v0) {\n                    val.delete(v0);\n                    val.add(v1);\n                }\n            }\n        }\n        else {\n            for (const [k, v0] of Object.entries(val)) {\n                const v1 = applyReviver(reviver, val, k, v0);\n                if (v1 === undefined)\n                    delete val[k];\n                else if (v1 !== v0)\n                    val[k] = v1;\n            }\n        }\n    }\n    return reviver.call(obj, key, val);\n}\n\nexport { applyReviver };\n", "import { Alias } from '../nodes/Alias.js';\nimport { isEmptyPath, collectionFromPath } from '../nodes/Collection.js';\nimport { NODE_TYPE, DOC, isNode, isCollection, isScalar } from '../nodes/Node.js';\nimport { Pair } from '../nodes/Pair.js';\nimport { toJS } from '../nodes/toJS.js';\nimport { Schema } from '../schema/Schema.js';\nimport { stringify } from '../stringify/stringify.js';\nimport { stringifyDocument } from '../stringify/stringifyDocument.js';\nimport { anchorNames, findNewAnchor, createNodeAnchors } from './anchors.js';\nimport { applyReviver } from './applyReviver.js';\nimport { createNode } from './createNode.js';\nimport { Directives } from './directives.js';\n\nclass Document {\n    constructor(value, replacer, options) {\n        /** A comment before this Document */\n        this.commentBefore = null;\n        /** A comment immediately after this Document */\n        this.comment = null;\n        /** Errors encountered during parsing. */\n        this.errors = [];\n        /** Warnings encountered during parsing. */\n        this.warnings = [];\n        Object.defineProperty(this, NODE_TYPE, { value: DOC });\n        let _replacer = null;\n        if (typeof replacer === 'function' || Array.isArray(replacer)) {\n            _replacer = replacer;\n        }\n        else if (options === undefined && replacer) {\n            options = replacer;\n            replacer = undefined;\n        }\n        const opt = Object.assign({\n            intAsBigInt: false,\n            keepSourceTokens: false,\n            logLevel: 'warn',\n            prettyErrors: true,\n            strict: true,\n            uniqueKeys: true,\n            version: '1.2'\n        }, options);\n        this.options = opt;\n        let { version } = opt;\n        if (options?._directives) {\n            this.directives = options._directives.atDocument();\n            if (this.directives.yaml.explicit)\n                version = this.directives.yaml.version;\n        }\n        else\n            this.directives = new Directives({ version });\n        this.setSchema(version, options);\n        if (value === undefined)\n            this.contents = null;\n        else {\n            this.contents = this.createNode(value, _replacer, options);\n        }\n    }\n    /**\n     * Create a deep copy of this Document and its contents.\n     *\n     * Custom Node values that inherit from `Object` still refer to their original instances.\n     */\n    clone() {\n        const copy = Object.create(Document.prototype, {\n            [NODE_TYPE]: { value: DOC }\n        });\n        copy.commentBefore = this.commentBefore;\n        copy.comment = this.comment;\n        copy.errors = this.errors.slice();\n        copy.warnings = this.warnings.slice();\n        copy.options = Object.assign({}, this.options);\n        if (this.directives)\n            copy.directives = this.directives.clone();\n        copy.schema = this.schema.clone();\n        copy.contents = isNode(this.contents)\n            ? this.contents.clone(copy.schema)\n            : this.contents;\n        if (this.range)\n            copy.range = this.range.slice();\n        return copy;\n    }\n    /** Adds a value to the document. */\n    add(value) {\n        if (assertCollection(this.contents))\n            this.contents.add(value);\n    }\n    /** Adds a value to the document. */\n    addIn(path, value) {\n        if (assertCollection(this.contents))\n            this.contents.addIn(path, value);\n    }\n    /**\n     * Create a new `Alias` node, ensuring that the target `node` has the required anchor.\n     *\n     * If `node` already has an anchor, `name` is ignored.\n     * Otherwise, the `node.anchor` value will be set to `name`,\n     * or if an anchor with that name is already present in the document,\n     * `name` will be used as a prefix for a new unique anchor.\n     * If `name` is undefined, the generated anchor will use 'a' as a prefix.\n     */\n    createAlias(node, name) {\n        if (!node.anchor) {\n            const prev = anchorNames(this);\n            node.anchor =\n                // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing\n                !name || prev.has(name) ? findNewAnchor(name || 'a', prev) : name;\n        }\n        return new Alias(node.anchor);\n    }\n    createNode(value, replacer, options) {\n        let _replacer = undefined;\n        if (typeof replacer === 'function') {\n            value = replacer.call({ '': value }, '', value);\n            _replacer = replacer;\n        }\n        else if (Array.isArray(replacer)) {\n            const keyToStr = (v) => typeof v === 'number' || v instanceof String || v instanceof Number;\n            const asStr = replacer.filter(keyToStr).map(String);\n            if (asStr.length > 0)\n                replacer = replacer.concat(asStr);\n            _replacer = replacer;\n        }\n        else if (options === undefined && replacer) {\n            options = replacer;\n            replacer = undefined;\n        }\n        const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options ?? {};\n        const { onAnchor, setAnchors, sourceObjects } = createNodeAnchors(this, \n        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing\n        anchorPrefix || 'a');\n        const ctx = {\n            aliasDuplicateObjects: aliasDuplicateObjects ?? true,\n            keepUndefined: keepUndefined ?? false,\n            onAnchor,\n            onTagObj,\n            replacer: _replacer,\n            schema: this.schema,\n            sourceObjects\n        };\n        const node = createNode(value, tag, ctx);\n        if (flow && isCollection(node))\n            node.flow = true;\n        setAnchors();\n        return node;\n    }\n    /**\n     * Convert a key and a value into a `Pair` using the current schema,\n     * recursively wrapping all values as `Scalar` or `Collection` nodes.\n     */\n    createPair(key, value, options = {}) {\n        const k = this.createNode(key, null, options);\n        const v = this.createNode(value, null, options);\n        return new Pair(k, v);\n    }\n    /**\n     * Removes a value from the document.\n     * @returns `true` if the item was found and removed.\n     */\n    delete(key) {\n        return assertCollection(this.contents) ? this.contents.delete(key) : false;\n    }\n    /**\n     * Removes a value from the document.\n     * @returns `true` if the item was found and removed.\n     */\n    deleteIn(path) {\n        if (isEmptyPath(path)) {\n            if (this.contents == null)\n                return false;\n            this.contents = null;\n            return true;\n        }\n        return assertCollection(this.contents)\n            ? this.contents.deleteIn(path)\n            : false;\n    }\n    /**\n     * Returns item at `key`, or `undefined` if not found. By default unwraps\n     * scalar values from their surrounding node; to disable set `keepScalar` to\n     * `true` (collections are always returned intact).\n     */\n    get(key, keepScalar) {\n        return isCollection(this.contents)\n            ? this.contents.get(key, keepScalar)\n            : undefined;\n    }\n    /**\n     * Returns item at `path`, or `undefined` if not found. By default unwraps\n     * scalar values from their surrounding node; to disable set `keepScalar` to\n     * `true` (collections are always returned intact).\n     */\n    getIn(path, keepScalar) {\n        if (isEmptyPath(path))\n            return !keepScalar && isScalar(this.contents)\n                ? this.contents.value\n                : this.contents;\n        return isCollection(this.contents)\n            ? this.contents.getIn(path, keepScalar)\n            : undefined;\n    }\n    /**\n     * Checks if the document includes a value with the key `key`.\n     */\n    has(key) {\n        return isCollection(this.contents) ? this.contents.has(key) : false;\n    }\n    /**\n     * Checks if the document includes a value at `path`.\n     */\n    hasIn(path) {\n        if (isEmptyPath(path))\n            return this.contents !== undefined;\n        return isCollection(this.contents) ? this.contents.hasIn(path) : false;\n    }\n    /**\n     * Sets a value in this document. For `!!set`, `value` needs to be a\n     * boolean to add/remove the item from the set.\n     */\n    set(key, value) {\n        if (this.contents == null) {\n            this.contents = collectionFromPath(this.schema, [key], value);\n        }\n        else if (assertCollection(this.contents)) {\n            this.contents.set(key, value);\n        }\n    }\n    /**\n     * Sets a value in this document. For `!!set`, `value` needs to be a\n     * boolean to add/remove the item from the set.\n     */\n    setIn(path, value) {\n        if (isEmptyPath(path))\n            this.contents = value;\n        else if (this.contents == null) {\n            this.contents = collectionFromPath(this.schema, Array.from(path), value);\n        }\n        else if (assertCollection(this.contents)) {\n            this.contents.setIn(path, value);\n        }\n    }\n    /**\n     * Change the YAML version and schema used by the document.\n     * A `null` version disables support for directives, explicit tags, anchors, and aliases.\n     * It also requires the `schema` option to be given as a `Schema` instance value.\n     *\n     * Overrides all previously set schema options.\n     */\n    setSchema(version, options = {}) {\n        if (typeof version === 'number')\n            version = String(version);\n        let opt;\n        switch (version) {\n            case '1.1':\n                if (this.directives)\n                    this.directives.yaml.version = '1.1';\n                else\n                    this.directives = new Directives({ version: '1.1' });\n                opt = { merge: true, resolveKnownTags: false, schema: 'yaml-1.1' };\n                break;\n            case '1.2':\n            case 'next':\n                if (this.directives)\n                    this.directives.yaml.version = version;\n                else\n                    this.directives = new Directives({ version });\n                opt = { merge: false, resolveKnownTags: true, schema: 'core' };\n                break;\n            case null:\n                if (this.directives)\n                    delete this.directives;\n                opt = null;\n                break;\n            default: {\n                const sv = JSON.stringify(version);\n                throw new Error(`Expected '1.1', '1.2' or null as first argument, but found: ${sv}`);\n            }\n        }\n        // Not using `instanceof Schema` to allow for duck typing\n        if (options.schema instanceof Object)\n            this.schema = options.schema;\n        else if (opt)\n            this.schema = new Schema(Object.assign(opt, options));\n        else\n            throw new Error(`With a null YAML version, the { schema: Schema } option is required`);\n    }\n    // json & jsonArg are only used from toJSON()\n    toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {\n        const ctx = {\n            anchors: new Map(),\n            doc: this,\n            keep: !json,\n            mapAsMap: mapAsMap === true,\n            mapKeyWarned: false,\n            maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100,\n            stringify\n        };\n        const res = toJS(this.contents, jsonArg ?? '', ctx);\n        if (typeof onAnchor === 'function')\n            for (const { count, res } of ctx.anchors.values())\n                onAnchor(res, count);\n        return typeof reviver === 'function'\n            ? applyReviver(reviver, { '': res }, '', res)\n            : res;\n    }\n    /**\n     * A JSON representation of the document `contents`.\n     *\n     * @param jsonArg Used by `JSON.stringify` to indicate the array index or\n     *   property name.\n     */\n    toJSON(jsonArg, onAnchor) {\n        return this.toJS({ json: true, jsonArg, mapAsMap: false, onAnchor });\n    }\n    /** A YAML representation of the document. */\n    toString(options = {}) {\n        if (this.errors.length > 0)\n            throw new Error('Document with errors cannot be stringified');\n        if ('indent' in options &&\n            (!Number.isInteger(options.indent) || Number(options.indent) <= 0)) {\n            const s = JSON.stringify(options.indent);\n            throw new Error(`\"indent\" option must be a positive integer, not ${s}`);\n        }\n        return stringifyDocument(this, options);\n    }\n}\nfunction assertCollection(contents) {\n    if (isCollection(contents))\n        return true;\n    throw new Error('Expected a YAML collection as document contents');\n}\n\nexport { Document };\n", "const BREAK = Symbol('break visit');\nconst SKIP = Symbol('skip children');\nconst REMOVE = Symbol('remove item');\n/**\n * Apply a visitor to a CST document or item.\n *\n * Walks through the tree (depth-first) starting from the root, calling a\n * `visitor` function with two arguments when entering each item:\n *   - `item`: The current item, which included the following members:\n *     - `start: SourceToken[]` \u2013 Source tokens before the key or value,\n *       possibly including its anchor or tag.\n *     - `key?: Token | null` \u2013 Set for pair values. May then be `null`, if\n *       the key before the `:` separator is empty.\n *     - `sep?: SourceToken[]` \u2013 Source tokens between the key and the value,\n *       which should include the `:` map value indicator if `value` is set.\n *     - `value?: Token` \u2013 The value of a sequence item, or of a map pair.\n *   - `path`: The steps from the root to the current node, as an array of\n *     `['key' | 'value', number]` tuples.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this token, continue with\n *      next sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current item, then continue with the next one\n *   - `number`: Set the index of the next step. This is useful especially if\n *     the index of the current token has changed.\n *   - `function`: Define the next visitor for this item. After the original\n *     visitor is called on item entry, next visitors are called after handling\n *     a non-empty `key` and when exiting the item.\n */\nfunction visit(cst, visitor) {\n    if ('type' in cst && cst.type === 'document')\n        cst = { start: cst.start, value: cst.value };\n    _visit(Object.freeze([]), cst, visitor);\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisit.BREAK = BREAK;\n/** Do not visit the children of the current item */\nvisit.SKIP = SKIP;\n/** Remove the current item */\nvisit.REMOVE = REMOVE;\n/** Find the item at `path` from `cst` as the root */\nvisit.itemAtPath = (cst, path) => {\n    let item = cst;\n    for (const [field, index] of path) {\n        const tok = item?.[field];\n        if (tok && 'items' in tok) {\n            item = tok.items[index];\n        }\n        else\n            return undefined;\n    }\n    return item;\n};\n/**\n * Get the immediate parent collection of the item at `path` from `cst` as the root.\n *\n * Throws an error if the collection is not found, which should never happen if the item itself exists.\n */\nvisit.parentCollection = (cst, path) => {\n    const parent = visit.itemAtPath(cst, path.slice(0, -1));\n    const field = path[path.length - 1][0];\n    const coll = parent?.[field];\n    if (coll && 'items' in coll)\n        return coll;\n    throw new Error('Parent collection not found');\n};\nfunction _visit(path, item, visitor) {\n    let ctrl = visitor(item, path);\n    if (typeof ctrl === 'symbol')\n        return ctrl;\n    for (const field of ['key', 'value']) {\n        const token = item[field];\n        if (token && 'items' in token) {\n            for (let i = 0; i < token.items.length; ++i) {\n                const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    token.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n            if (typeof ctrl === 'function' && field === 'key')\n                ctrl = ctrl(item, path);\n        }\n    }\n    return typeof ctrl === 'function' ? ctrl(item, path) : ctrl;\n}\n\nexport { visit };\n", "import { BOM, DOCUMENT, FLOW_END, SCALAR } from './cst.js';\n\n/*\nSTART -> stream\n\nstream\n  directive -> line-end -> stream\n  indent + line-end -> stream\n  [else] -> line-start\n\nline-end\n  comment -> line-end\n  newline -> .\n  input-end -> END\n\nline-start\n  doc-start -> doc\n  doc-end -> stream\n  [else] -> indent -> block-start\n\nblock-start\n  seq-item-start -> block-start\n  explicit-key-start -> block-start\n  map-value-start -> block-start\n  [else] -> doc\n\ndoc\n  line-end -> line-start\n  spaces -> doc\n  anchor -> doc\n  tag -> doc\n  flow-start -> flow -> doc\n  flow-end -> error -> doc\n  seq-item-start -> error -> doc\n  explicit-key-start -> error -> doc\n  map-value-start -> doc\n  alias -> doc\n  quote-start -> quoted-scalar -> doc\n  block-scalar-header -> line-end -> block-scalar(min) -> line-start\n  [else] -> plain-scalar(false, min) -> doc\n\nflow\n  line-end -> flow\n  spaces -> flow\n  anchor -> flow\n  tag -> flow\n  flow-start -> flow -> flow\n  flow-end -> .\n  seq-item-start -> error -> flow\n  explicit-key-start -> flow\n  map-value-start -> flow\n  alias -> flow\n  quote-start -> quoted-scalar -> flow\n  comma -> flow\n  [else] -> plain-scalar(true, 0) -> flow\n\nquoted-scalar\n  quote-end -> .\n  [else] -> quoted-scalar\n\nblock-scalar(min)\n  newline + peek(indent < min) -> .\n  [else] -> block-scalar(min)\n\nplain-scalar(is-flow, min)\n  scalar-end(is-flow) -> .\n  peek(newline + (indent < min)) -> .\n  [else] -> plain-scalar(min)\n*/\nfunction isEmpty(ch) {\n    switch (ch) {\n        case undefined:\n        case ' ':\n        case '\\n':\n        case '\\r':\n        case '\\t':\n            return true;\n        default:\n            return false;\n    }\n}\nconst hexDigits = '0123456789ABCDEFabcdef'.split('');\nconst tagChars = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()\".split('');\nconst invalidFlowScalarChars = ',[]{}'.split('');\nconst invalidAnchorChars = ' ,[]{}\\n\\r\\t'.split('');\nconst isNotAnchorChar = (ch) => !ch || invalidAnchorChars.includes(ch);\n/**\n * Splits an input string into lexical tokens, i.e. smaller strings that are\n * easily identifiable by `tokens.tokenType()`.\n *\n * Lexing starts always in a \"stream\" context. Incomplete input may be buffered\n * until a complete token can be emitted.\n *\n * In addition to slices of the original input, the following control characters\n * may also be emitted:\n *\n * - `\\x02` (Start of Text): A document starts with the next token\n * - `\\x18` (Cancel): Unexpected end of flow-mode (indicates an error)\n * - `\\x1f` (Unit Separator): Next token is a scalar value\n * - `\\u{FEFF}` (Byte order mark): Emitted separately outside documents\n */\nclass Lexer {\n    constructor() {\n        /**\n         * Flag indicating whether the end of the current buffer marks the end of\n         * all input\n         */\n        this.atEnd = false;\n        /**\n         * Explicit indent set in block scalar header, as an offset from the current\n         * minimum indent, so e.g. set to 1 from a header `|2+`. Set to -1 if not\n         * explicitly set.\n         */\n        this.blockScalarIndent = -1;\n        /**\n         * Block scalars that include a + (keep) chomping indicator in their header\n         * include trailing empty lines, which are otherwise excluded from the\n         * scalar's contents.\n         */\n        this.blockScalarKeep = false;\n        /** Current input */\n        this.buffer = '';\n        /**\n         * Flag noting whether the map value indicator : can immediately follow this\n         * node within a flow context.\n         */\n        this.flowKey = false;\n        /** Count of surrounding flow collection levels. */\n        this.flowLevel = 0;\n        /**\n         * Minimum level of indentation required for next lines to be parsed as a\n         * part of the current scalar value.\n         */\n        this.indentNext = 0;\n        /** Indentation level of the current line. */\n        this.indentValue = 0;\n        /** Position of the next \\n character. */\n        this.lineEndPos = null;\n        /** Stores the state of the lexer if reaching the end of incpomplete input */\n        this.next = null;\n        /** A pointer to `buffer`; the current position of the lexer. */\n        this.pos = 0;\n    }\n    /**\n     * Generate YAML tokens from the `source` string. If `incomplete`,\n     * a part of the last line may be left as a buffer for the next call.\n     *\n     * @returns A generator of lexical tokens\n     */\n    *lex(source, incomplete = false) {\n        if (source) {\n            this.buffer = this.buffer ? this.buffer + source : source;\n            this.lineEndPos = null;\n        }\n        this.atEnd = !incomplete;\n        let next = this.next ?? 'stream';\n        while (next && (incomplete || this.hasChars(1)))\n            next = yield* this.parseNext(next);\n    }\n    atLineEnd() {\n        let i = this.pos;\n        let ch = this.buffer[i];\n        while (ch === ' ' || ch === '\\t')\n            ch = this.buffer[++i];\n        if (!ch || ch === '#' || ch === '\\n')\n            return true;\n        if (ch === '\\r')\n            return this.buffer[i + 1] === '\\n';\n        return false;\n    }\n    charAt(n) {\n        return this.buffer[this.pos + n];\n    }\n    continueScalar(offset) {\n        let ch = this.buffer[offset];\n        if (this.indentNext > 0) {\n            let indent = 0;\n            while (ch === ' ')\n                ch = this.buffer[++indent + offset];\n            if (ch === '\\r') {\n                const next = this.buffer[indent + offset + 1];\n                if (next === '\\n' || (!next && !this.atEnd))\n                    return offset + indent + 1;\n            }\n            return ch === '\\n' || indent >= this.indentNext || (!ch && !this.atEnd)\n                ? offset + indent\n                : -1;\n        }\n        if (ch === '-' || ch === '.') {\n            const dt = this.buffer.substr(offset, 3);\n            if ((dt === '---' || dt === '...') && isEmpty(this.buffer[offset + 3]))\n                return -1;\n        }\n        return offset;\n    }\n    getLine() {\n        let end = this.lineEndPos;\n        if (typeof end !== 'number' || (end !== -1 && end < this.pos)) {\n            end = this.buffer.indexOf('\\n', this.pos);\n            this.lineEndPos = end;\n        }\n        if (end === -1)\n            return this.atEnd ? this.buffer.substring(this.pos) : null;\n        if (this.buffer[end - 1] === '\\r')\n            end -= 1;\n        return this.buffer.substring(this.pos, end);\n    }\n    hasChars(n) {\n        return this.pos + n <= this.buffer.length;\n    }\n    setNext(state) {\n        this.buffer = this.buffer.substring(this.pos);\n        this.pos = 0;\n        this.lineEndPos = null;\n        this.next = state;\n        return null;\n    }\n    peek(n) {\n        return this.buffer.substr(this.pos, n);\n    }\n    *parseNext(next) {\n        switch (next) {\n            case 'stream':\n                return yield* this.parseStream();\n            case 'line-start':\n                return yield* this.parseLineStart();\n            case 'block-start':\n                return yield* this.parseBlockStart();\n            case 'doc':\n                return yield* this.parseDocument();\n            case 'flow':\n                return yield* this.parseFlowCollection();\n            case 'quoted-scalar':\n                return yield* this.parseQuotedScalar();\n            case 'block-scalar':\n                return yield* this.parseBlockScalar();\n            case 'plain-scalar':\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseStream() {\n        let line = this.getLine();\n        if (line === null)\n            return this.setNext('stream');\n        if (line[0] === BOM) {\n            yield* this.pushCount(1);\n            line = line.substring(1);\n        }\n        if (line[0] === '%') {\n            let dirEnd = line.length;\n            const cs = line.indexOf('#');\n            if (cs !== -1) {\n                const ch = line[cs - 1];\n                if (ch === ' ' || ch === '\\t')\n                    dirEnd = cs - 1;\n            }\n            while (true) {\n                const ch = line[dirEnd - 1];\n                if (ch === ' ' || ch === '\\t')\n                    dirEnd -= 1;\n                else\n                    break;\n            }\n            const n = (yield* this.pushCount(dirEnd)) + (yield* this.pushSpaces(true));\n            yield* this.pushCount(line.length - n); // possible comment\n            this.pushNewline();\n            return 'stream';\n        }\n        if (this.atLineEnd()) {\n            const sp = yield* this.pushSpaces(true);\n            yield* this.pushCount(line.length - sp);\n            yield* this.pushNewline();\n            return 'stream';\n        }\n        yield DOCUMENT;\n        return yield* this.parseLineStart();\n    }\n    *parseLineStart() {\n        const ch = this.charAt(0);\n        if (!ch && !this.atEnd)\n            return this.setNext('line-start');\n        if (ch === '-' || ch === '.') {\n            if (!this.atEnd && !this.hasChars(4))\n                return this.setNext('line-start');\n            const s = this.peek(3);\n            if (s === '---' && isEmpty(this.charAt(3))) {\n                yield* this.pushCount(3);\n                this.indentValue = 0;\n                this.indentNext = 0;\n                return 'doc';\n            }\n            else if (s === '...' && isEmpty(this.charAt(3))) {\n                yield* this.pushCount(3);\n                return 'stream';\n            }\n        }\n        this.indentValue = yield* this.pushSpaces(false);\n        if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1)))\n            this.indentNext = this.indentValue;\n        return yield* this.parseBlockStart();\n    }\n    *parseBlockStart() {\n        const [ch0, ch1] = this.peek(2);\n        if (!ch1 && !this.atEnd)\n            return this.setNext('block-start');\n        if ((ch0 === '-' || ch0 === '?' || ch0 === ':') && isEmpty(ch1)) {\n            const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));\n            this.indentNext = this.indentValue + 1;\n            this.indentValue += n;\n            return yield* this.parseBlockStart();\n        }\n        return 'doc';\n    }\n    *parseDocument() {\n        yield* this.pushSpaces(true);\n        const line = this.getLine();\n        if (line === null)\n            return this.setNext('doc');\n        let n = yield* this.pushIndicators();\n        switch (line[n]) {\n            case '#':\n                yield* this.pushCount(line.length - n);\n            // fallthrough\n            case undefined:\n                yield* this.pushNewline();\n                return yield* this.parseLineStart();\n            case '{':\n            case '[':\n                yield* this.pushCount(1);\n                this.flowKey = false;\n                this.flowLevel = 1;\n                return 'flow';\n            case '}':\n            case ']':\n                // this is an error\n                yield* this.pushCount(1);\n                return 'doc';\n            case '*':\n                yield* this.pushUntil(isNotAnchorChar);\n                return 'doc';\n            case '\"':\n            case \"'\":\n                return yield* this.parseQuotedScalar();\n            case '|':\n            case '>':\n                n += yield* this.parseBlockScalarHeader();\n                n += yield* this.pushSpaces(true);\n                yield* this.pushCount(line.length - n);\n                yield* this.pushNewline();\n                return yield* this.parseBlockScalar();\n            default:\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseFlowCollection() {\n        let nl, sp;\n        let indent = -1;\n        do {\n            nl = yield* this.pushNewline();\n            if (nl > 0) {\n                sp = yield* this.pushSpaces(false);\n                this.indentValue = indent = sp;\n            }\n            else {\n                sp = 0;\n            }\n            sp += yield* this.pushSpaces(true);\n        } while (nl + sp > 0);\n        const line = this.getLine();\n        if (line === null)\n            return this.setNext('flow');\n        if ((indent !== -1 && indent < this.indentNext && line[0] !== '#') ||\n            (indent === 0 &&\n                (line.startsWith('---') || line.startsWith('...')) &&\n                isEmpty(line[3]))) {\n            // Allowing for the terminal ] or } at the same (rather than greater)\n            // indent level as the initial [ or { is technically invalid, but\n            // failing here would be surprising to users.\n            const atFlowEndMarker = indent === this.indentNext - 1 &&\n                this.flowLevel === 1 &&\n                (line[0] === ']' || line[0] === '}');\n            if (!atFlowEndMarker) {\n                // this is an error\n                this.flowLevel = 0;\n                yield FLOW_END;\n                return yield* this.parseLineStart();\n            }\n        }\n        let n = 0;\n        while (line[n] === ',') {\n            n += yield* this.pushCount(1);\n            n += yield* this.pushSpaces(true);\n            this.flowKey = false;\n        }\n        n += yield* this.pushIndicators();\n        switch (line[n]) {\n            case undefined:\n                return 'flow';\n            case '#':\n                yield* this.pushCount(line.length - n);\n                return 'flow';\n            case '{':\n            case '[':\n                yield* this.pushCount(1);\n                this.flowKey = false;\n                this.flowLevel += 1;\n                return 'flow';\n            case '}':\n            case ']':\n                yield* this.pushCount(1);\n                this.flowKey = true;\n                this.flowLevel -= 1;\n                return this.flowLevel ? 'flow' : 'doc';\n            case '*':\n                yield* this.pushUntil(isNotAnchorChar);\n                return 'flow';\n            case '\"':\n            case \"'\":\n                this.flowKey = true;\n                return yield* this.parseQuotedScalar();\n            case ':': {\n                const next = this.charAt(1);\n                if (this.flowKey || isEmpty(next) || next === ',') {\n                    this.flowKey = false;\n                    yield* this.pushCount(1);\n                    yield* this.pushSpaces(true);\n                    return 'flow';\n                }\n            }\n            // fallthrough\n            default:\n                this.flowKey = false;\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseQuotedScalar() {\n        const quote = this.charAt(0);\n        let end = this.buffer.indexOf(quote, this.pos + 1);\n        if (quote === \"'\") {\n            while (end !== -1 && this.buffer[end + 1] === \"'\")\n                end = this.buffer.indexOf(\"'\", end + 2);\n        }\n        else {\n            // double-quote\n            while (end !== -1) {\n                let n = 0;\n                while (this.buffer[end - 1 - n] === '\\\\')\n                    n += 1;\n                if (n % 2 === 0)\n                    break;\n                end = this.buffer.indexOf('\"', end + 1);\n            }\n        }\n        // Only looking for newlines within the quotes\n        const qb = this.buffer.substring(0, end);\n        let nl = qb.indexOf('\\n', this.pos);\n        if (nl !== -1) {\n            while (nl !== -1) {\n                const cs = this.continueScalar(nl + 1);\n                if (cs === -1)\n                    break;\n                nl = qb.indexOf('\\n', cs);\n            }\n            if (nl !== -1) {\n                // this is an error caused by an unexpected unindent\n                end = nl - (qb[nl - 1] === '\\r' ? 2 : 1);\n            }\n        }\n        if (end === -1) {\n            if (!this.atEnd)\n                return this.setNext('quoted-scalar');\n            end = this.buffer.length;\n        }\n        yield* this.pushToIndex(end + 1, false);\n        return this.flowLevel ? 'flow' : 'doc';\n    }\n    *parseBlockScalarHeader() {\n        this.blockScalarIndent = -1;\n        this.blockScalarKeep = false;\n        let i = this.pos;\n        while (true) {\n            const ch = this.buffer[++i];\n            if (ch === '+')\n                this.blockScalarKeep = true;\n            else if (ch > '0' && ch <= '9')\n                this.blockScalarIndent = Number(ch) - 1;\n            else if (ch !== '-')\n                break;\n        }\n        return yield* this.pushUntil(ch => isEmpty(ch) || ch === '#');\n    }\n    *parseBlockScalar() {\n        let nl = this.pos - 1; // may be -1 if this.pos === 0\n        let indent = 0;\n        let ch;\n        loop: for (let i = this.pos; (ch = this.buffer[i]); ++i) {\n            switch (ch) {\n                case ' ':\n                    indent += 1;\n                    break;\n                case '\\n':\n                    nl = i;\n                    indent = 0;\n                    break;\n                case '\\r': {\n                    const next = this.buffer[i + 1];\n                    if (!next && !this.atEnd)\n                        return this.setNext('block-scalar');\n                    if (next === '\\n')\n                        break;\n                } // fallthrough\n                default:\n                    break loop;\n            }\n        }\n        if (!ch && !this.atEnd)\n            return this.setNext('block-scalar');\n        if (indent >= this.indentNext) {\n            if (this.blockScalarIndent === -1)\n                this.indentNext = indent;\n            else\n                this.indentNext += this.blockScalarIndent;\n            do {\n                const cs = this.continueScalar(nl + 1);\n                if (cs === -1)\n                    break;\n                nl = this.buffer.indexOf('\\n', cs);\n            } while (nl !== -1);\n            if (nl === -1) {\n                if (!this.atEnd)\n                    return this.setNext('block-scalar');\n                nl = this.buffer.length;\n            }\n        }\n        if (!this.blockScalarKeep) {\n            do {\n                let i = nl - 1;\n                let ch = this.buffer[i];\n                if (ch === '\\r')\n                    ch = this.buffer[--i];\n                const lastChar = i; // Drop the line if last char not more indented\n                while (ch === ' ' || ch === '\\t')\n                    ch = this.buffer[--i];\n                if (ch === '\\n' && i >= this.pos && i + 1 + indent > lastChar)\n                    nl = i;\n                else\n                    break;\n            } while (true);\n        }\n        yield SCALAR;\n        yield* this.pushToIndex(nl + 1, true);\n        return yield* this.parseLineStart();\n    }\n    *parsePlainScalar() {\n        const inFlow = this.flowLevel > 0;\n        let end = this.pos - 1;\n        let i = this.pos - 1;\n        let ch;\n        while ((ch = this.buffer[++i])) {\n            if (ch === ':') {\n                const next = this.buffer[i + 1];\n                if (isEmpty(next) || (inFlow && next === ','))\n                    break;\n                end = i;\n            }\n            else if (isEmpty(ch)) {\n                let next = this.buffer[i + 1];\n                if (ch === '\\r') {\n                    if (next === '\\n') {\n                        i += 1;\n                        ch = '\\n';\n                        next = this.buffer[i + 1];\n                    }\n                    else\n                        end = i;\n                }\n                if (next === '#' || (inFlow && invalidFlowScalarChars.includes(next)))\n                    break;\n                if (ch === '\\n') {\n                    const cs = this.continueScalar(i + 1);\n                    if (cs === -1)\n                        break;\n                    i = Math.max(i, cs - 2); // to advance, but still account for ' #'\n                }\n            }\n            else {\n                if (inFlow && invalidFlowScalarChars.includes(ch))\n                    break;\n                end = i;\n            }\n        }\n        if (!ch && !this.atEnd)\n            return this.setNext('plain-scalar');\n        yield SCALAR;\n        yield* this.pushToIndex(end + 1, true);\n        return inFlow ? 'flow' : 'doc';\n    }\n    *pushCount(n) {\n        if (n > 0) {\n            yield this.buffer.substr(this.pos, n);\n            this.pos += n;\n            return n;\n        }\n        return 0;\n    }\n    *pushToIndex(i, allowEmpty) {\n        const s = this.buffer.slice(this.pos, i);\n        if (s) {\n            yield s;\n            this.pos += s.length;\n            return s.length;\n        }\n        else if (allowEmpty)\n            yield '';\n        return 0;\n    }\n    *pushIndicators() {\n        switch (this.charAt(0)) {\n            case '!':\n                return ((yield* this.pushTag()) +\n                    (yield* this.pushSpaces(true)) +\n                    (yield* this.pushIndicators()));\n            case '&':\n                return ((yield* this.pushUntil(isNotAnchorChar)) +\n                    (yield* this.pushSpaces(true)) +\n                    (yield* this.pushIndicators()));\n            case '-': // this is an error\n            case '?': // this is an error outside flow collections\n            case ':': {\n                const inFlow = this.flowLevel > 0;\n                const ch1 = this.charAt(1);\n                if (isEmpty(ch1) || (inFlow && invalidFlowScalarChars.includes(ch1))) {\n                    if (!inFlow)\n                        this.indentNext = this.indentValue + 1;\n                    else if (this.flowKey)\n                        this.flowKey = false;\n                    return ((yield* this.pushCount(1)) +\n                        (yield* this.pushSpaces(true)) +\n                        (yield* this.pushIndicators()));\n                }\n            }\n        }\n        return 0;\n    }\n    *pushTag() {\n        if (this.charAt(1) === '<') {\n            let i = this.pos + 2;\n            let ch = this.buffer[i];\n            while (!isEmpty(ch) && ch !== '>')\n                ch = this.buffer[++i];\n            return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false);\n        }\n        else {\n            let i = this.pos + 1;\n            let ch = this.buffer[i];\n            while (ch) {\n                if (tagChars.includes(ch))\n                    ch = this.buffer[++i];\n                else if (ch === '%' &&\n                    hexDigits.includes(this.buffer[i + 1]) &&\n                    hexDigits.includes(this.buffer[i + 2])) {\n                    ch = this.buffer[(i += 3)];\n                }\n                else\n                    break;\n            }\n            return yield* this.pushToIndex(i, false);\n        }\n    }\n    *pushNewline() {\n        const ch = this.buffer[this.pos];\n        if (ch === '\\n')\n            return yield* this.pushCount(1);\n        else if (ch === '\\r' && this.charAt(1) === '\\n')\n            return yield* this.pushCount(2);\n        else\n            return 0;\n    }\n    *pushSpaces(allowTabs) {\n        let i = this.pos - 1;\n        let ch;\n        do {\n            ch = this.buffer[++i];\n        } while (ch === ' ' || (allowTabs && ch === '\\t'));\n        const n = i - this.pos;\n        if (n > 0) {\n            yield this.buffer.substr(this.pos, n);\n            this.pos = i;\n        }\n        return n;\n    }\n    *pushUntil(test) {\n        let i = this.pos;\n        let ch = this.buffer[i];\n        while (!test(ch))\n            ch = this.buffer[++i];\n        return yield* this.pushToIndex(i, false);\n    }\n}\n\nexport { Lexer };\n", "import { Composer } from './compose/composer.js';\nimport { Document } from './doc/Document.js';\nimport { prettifyError, YAMLParseError } from './errors.js';\nimport { warn } from './log.js';\nimport { LineCounter } from './parse/line-counter.js';\nimport { Parser } from './parse/parser.js';\n\nfunction parseOptions(options) {\n    const prettyErrors = options.prettyErrors !== false;\n    const lineCounter = options.lineCounter || (prettyErrors && new LineCounter()) || null;\n    return { lineCounter, prettyErrors };\n}\n/**\n * Parse the input as a stream of YAML documents.\n *\n * Documents should be separated from each other by `...` or `---` marker lines.\n *\n * @returns If an empty `docs` array is returned, it will be of type\n *   EmptyStream and contain additional stream information. In\n *   TypeScript, you should use `'empty' in docs` as a type guard for it.\n */\nfunction parseAllDocuments(source, options = {}) {\n    const { lineCounter, prettyErrors } = parseOptions(options);\n    const parser = new Parser(lineCounter?.addNewLine);\n    const composer = new Composer(options);\n    const docs = Array.from(composer.compose(parser.parse(source)));\n    if (prettyErrors && lineCounter)\n        for (const doc of docs) {\n            doc.errors.forEach(prettifyError(source, lineCounter));\n            doc.warnings.forEach(prettifyError(source, lineCounter));\n        }\n    if (docs.length > 0)\n        return docs;\n    return Object.assign([], { empty: true }, composer.streamInfo());\n}\n/** Parse an input string into a single YAML.Document */\nfunction parseDocument(source, options = {}) {\n    const { lineCounter, prettyErrors } = parseOptions(options);\n    const parser = new Parser(lineCounter?.addNewLine);\n    const composer = new Composer(options);\n    // `doc` is always set by compose.end(true) at the very latest\n    let doc = null;\n    for (const _doc of composer.compose(parser.parse(source), true, source.length)) {\n        if (!doc)\n            doc = _doc;\n        else if (doc.options.logLevel !== 'silent') {\n            doc.errors.push(new YAMLParseError(_doc.range.slice(0, 2), 'MULTIPLE_DOCS', 'Source contains multiple documents; please use YAML.parseAllDocuments()'));\n            break;\n        }\n    }\n    if (prettyErrors && lineCounter) {\n        doc.errors.forEach(prettifyError(source, lineCounter));\n        doc.warnings.forEach(prettifyError(source, lineCounter));\n    }\n    return doc;\n}\nfunction parse(src, reviver, options) {\n    let _reviver = undefined;\n    if (typeof reviver === 'function') {\n        _reviver = reviver;\n    }\n    else if (options === undefined && reviver && typeof reviver === 'object') {\n        options = reviver;\n    }\n    const doc = parseDocument(src, options);\n    if (!doc)\n        return null;\n    doc.warnings.forEach(warning => warn(doc.options.logLevel, warning));\n    if (doc.errors.length > 0) {\n        if (doc.options.logLevel !== 'silent')\n            throw doc.errors[0];\n        else\n            doc.errors = [];\n    }\n    return doc.toJS(Object.assign({ reviver: _reviver }, options));\n}\nfunction stringify(value, replacer, options) {\n    let _replacer = null;\n    if (typeof replacer === 'function' || Array.isArray(replacer)) {\n        _replacer = replacer;\n    }\n    else if (options === undefined && replacer) {\n        options = replacer;\n    }\n    if (typeof options === 'string')\n        options = options.length;\n    if (typeof options === 'number') {\n        const indent = Math.round(options);\n        options = indent < 1 ? undefined : indent > 8 ? { indent: 8 } : { indent };\n    }\n    if (value === undefined) {\n        const { keepUndefined } = options ?? replacer ?? {};\n        if (!keepUndefined)\n            return undefined;\n    }\n    return new Document(value, _replacer, options).toString(options);\n}\n\nexport { parse, parseAllDocuments, parseDocument, stringify };\n"],
  "mappings": "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",
  "names": []
}
