diff --git a/.gitignore b/.gitignore
index 6802ded..9024954 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
/.obsidian/workspace.json
/.obsidian/workspace-mobile.json
/.obsidian/plugins/recent-files-obsidian/data.json
-/.obsidian/plugins/novel-word-count/data.json
\ No newline at end of file
+/.obsidian/plugins/novel-word-count/data.json
+/out/
diff --git a/.obsidian/community-plugins.json b/.obsidian/community-plugins.json
index 342aff5..ec03963 100644
--- a/.obsidian/community-plugins.json
+++ b/.obsidian/community-plugins.json
@@ -19,5 +19,6 @@
"anchor-display-text",
"calendar",
"periodic-notes",
- "spellcheck-toggler"
+ "spellcheck-toggler",
+ "obsidian-pandoc"
]
\ No newline at end of file
diff --git a/.obsidian/plugins/obsidian-pandoc/data.json b/.obsidian/plugins/obsidian-pandoc/data.json
new file mode 100644
index 0000000..2313eca
--- /dev/null
+++ b/.obsidian/plugins/obsidian-pandoc/data.json
@@ -0,0 +1,15 @@
+{
+ "showCLICommands": false,
+ "addExtensionsToInternalLinks": "html",
+ "injectAppCSS": "light",
+ "injectThemeCSS": false,
+ "customCSSFile": null,
+ "displayYAMLFrontmatter": false,
+ "linkStrippingBehaviour": "text",
+ "highDPIDiagrams": true,
+ "pandoc": null,
+ "pdflatex": null,
+ "outputFolder": "C:\\Users\\zmeyers\\zmVault\\out",
+ "extraArguments": "",
+ "exportFrom": "md"
+}
\ No newline at end of file
diff --git a/.obsidian/plugins/obsidian-pandoc/main.js b/.obsidian/plugins/obsidian-pandoc/main.js
new file mode 100644
index 0000000..098548c
--- /dev/null
+++ b/.obsidian/plugins/obsidian-pandoc/main.js
@@ -0,0 +1,10221 @@
+/*
+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 __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/lookpath/lib/index.js
+var require_lib = __commonJS({
+ "node_modules/lookpath/lib/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 __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 __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+ function adopt(value) {
+ return value instanceof P ? value : new P(function(resolve) {
+ resolve(value);
+ });
+ }
+ return new (P || (P = Promise))(function(resolve, reject) {
+ function fulfilled(value) {
+ try {
+ step(generator.next(value));
+ } catch (e) {
+ reject(e);
+ }
+ }
+ function rejected(value) {
+ try {
+ step(generator["throw"](value));
+ } catch (e) {
+ reject(e);
+ }
+ }
+ function step(result) {
+ result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+ }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+ };
+ var __generator = exports && exports.__generator || function(thisArg, body2) {
+ var _ = { label: 0, sent: function() {
+ if (t[0] & 1)
+ throw t[1];
+ return t[1];
+ }, trys: [], ops: [] }, f, y, t, g;
+ return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+ return this;
+ }), g;
+ function verb(n) {
+ return function(v) {
+ return step([n, v]);
+ };
+ }
+ function step(op) {
+ if (f)
+ throw new TypeError("Generator is already executing.");
+ while (_)
+ try {
+ if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+ return t;
+ if (y = 0, t)
+ op = [op[0] & 2, t.value];
+ switch (op[0]) {
+ case 0:
+ case 1:
+ t = op;
+ break;
+ case 4:
+ _.label++;
+ return { value: op[1], done: false };
+ case 5:
+ _.label++;
+ y = op[1];
+ op = [0];
+ continue;
+ case 7:
+ op = _.ops.pop();
+ _.trys.pop();
+ continue;
+ default:
+ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+ _ = 0;
+ continue;
+ }
+ if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+ _.label = op[1];
+ break;
+ }
+ if (op[0] === 6 && _.label < t[1]) {
+ _.label = t[1];
+ t = op;
+ break;
+ }
+ if (t && _.label < t[2]) {
+ _.label = t[2];
+ _.ops.push(op);
+ break;
+ }
+ if (t[2])
+ _.ops.pop();
+ _.trys.pop();
+ continue;
+ }
+ op = body2.call(thisArg, _);
+ } catch (e) {
+ op = [6, e];
+ y = 0;
+ } finally {
+ f = t = 0;
+ }
+ if (op[0] & 5)
+ throw op[1];
+ return { value: op[0] ? op[1] : void 0, done: true };
+ }
+ };
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.lookpath = void 0;
+ var fs5 = __importStar(require("fs"));
+ var path5 = __importStar(require("path"));
+ var isWindows = /^win/i.test(process.platform);
+ var isFilepath = function(cmd) {
+ return cmd.includes(path5.sep) ? path5.resolve(cmd) : void 0;
+ };
+ var access = function(fpath) {
+ return new Promise(function(resolve) {
+ return fs5.access(fpath, fs5.constants.X_OK, function(err) {
+ return resolve(err ? void 0 : fpath);
+ });
+ });
+ };
+ var isExecutable = function(abspath, opt) {
+ if (opt === void 0) {
+ opt = {};
+ }
+ return __awaiter(void 0, void 0, void 0, function() {
+ var envvars, exts, bins;
+ return __generator(this, function(_a) {
+ switch (_a.label) {
+ case 0:
+ envvars = opt.env || process.env;
+ exts = (envvars.PATHEXT || "").split(path5.delimiter).concat("");
+ return [4, Promise.all(exts.map(function(ext) {
+ return access(abspath + ext);
+ }))];
+ case 1:
+ bins = _a.sent();
+ return [2, bins.find(function(bin) {
+ return !!bin;
+ })];
+ }
+ });
+ });
+ };
+ var getDirsToWalkThrough = function(opt) {
+ var envvars = opt.env || process.env;
+ var envname = isWindows ? "Path" : "PATH";
+ return (envvars[envname] || "").split(path5.delimiter).concat(opt.include || []).filter(function(p) {
+ return !(opt.exclude || []).includes(p);
+ });
+ };
+ function lookpath3(command, opt) {
+ if (opt === void 0) {
+ opt = {};
+ }
+ return __awaiter(this, void 0, void 0, function() {
+ var directpath, dirs, bins;
+ return __generator(this, function(_a) {
+ switch (_a.label) {
+ case 0:
+ directpath = isFilepath(command);
+ if (directpath)
+ return [2, isExecutable(directpath, opt)];
+ dirs = getDirsToWalkThrough(opt);
+ return [4, Promise.all(dirs.map(function(dir) {
+ return isExecutable(path5.join(dir, command), opt);
+ }))];
+ case 1:
+ bins = _a.sent();
+ return [2, bins.find(function(bin) {
+ return !!bin;
+ })];
+ }
+ });
+ });
+ }
+ exports.lookpath = lookpath3;
+ }
+});
+
+// node_modules/fs.realpath/old.js
+var require_old = __commonJS({
+ "node_modules/fs.realpath/old.js"(exports) {
+ var pathModule = require("path");
+ var isWindows = process.platform === "win32";
+ var fs5 = require("fs");
+ var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
+ function rethrow() {
+ var callback;
+ if (DEBUG) {
+ var backtrace = new Error();
+ callback = debugCallback;
+ } else
+ callback = missingCallback;
+ return callback;
+ function debugCallback(err) {
+ if (err) {
+ backtrace.message = err.message;
+ err = backtrace;
+ missingCallback(err);
+ }
+ }
+ function missingCallback(err) {
+ if (err) {
+ if (process.throwDeprecation)
+ throw err;
+ else if (!process.noDeprecation) {
+ var msg = "fs: missing callback " + (err.stack || err.message);
+ if (process.traceDeprecation)
+ console.trace(msg);
+ else
+ console.error(msg);
+ }
+ }
+ }
+ }
+ function maybeCallback(cb) {
+ return typeof cb === "function" ? cb : rethrow();
+ }
+ var normalize = pathModule.normalize;
+ if (isWindows) {
+ nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
+ } else {
+ nextPartRe = /(.*?)(?:[\/]+|$)/g;
+ }
+ var nextPartRe;
+ if (isWindows) {
+ splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
+ } else {
+ splitRootRe = /^[\/]*/;
+ }
+ var splitRootRe;
+ exports.realpathSync = function realpathSync(p, cache) {
+ p = pathModule.resolve(p);
+ if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+ return cache[p];
+ }
+ var original = p, seenLinks = {}, knownHard = {};
+ var pos;
+ var current;
+ var base;
+ var previous;
+ start();
+ function start() {
+ var m = splitRootRe.exec(p);
+ pos = m[0].length;
+ current = m[0];
+ base = m[0];
+ previous = "";
+ if (isWindows && !knownHard[base]) {
+ fs5.lstatSync(base);
+ knownHard[base] = true;
+ }
+ }
+ while (pos < p.length) {
+ nextPartRe.lastIndex = pos;
+ var result = nextPartRe.exec(p);
+ previous = current;
+ current += result[0];
+ base = previous + result[1];
+ pos = nextPartRe.lastIndex;
+ if (knownHard[base] || cache && cache[base] === base) {
+ continue;
+ }
+ var resolvedLink;
+ if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+ resolvedLink = cache[base];
+ } else {
+ var stat3 = fs5.lstatSync(base);
+ if (!stat3.isSymbolicLink()) {
+ knownHard[base] = true;
+ if (cache)
+ cache[base] = base;
+ continue;
+ }
+ var linkTarget = null;
+ if (!isWindows) {
+ var id = stat3.dev.toString(32) + ":" + stat3.ino.toString(32);
+ if (seenLinks.hasOwnProperty(id)) {
+ linkTarget = seenLinks[id];
+ }
+ }
+ if (linkTarget === null) {
+ fs5.statSync(base);
+ linkTarget = fs5.readlinkSync(base);
+ }
+ resolvedLink = pathModule.resolve(previous, linkTarget);
+ if (cache)
+ cache[base] = resolvedLink;
+ if (!isWindows)
+ seenLinks[id] = linkTarget;
+ }
+ p = pathModule.resolve(resolvedLink, p.slice(pos));
+ start();
+ }
+ if (cache)
+ cache[original] = p;
+ return p;
+ };
+ exports.realpath = function realpath(p, cache, cb) {
+ if (typeof cb !== "function") {
+ cb = maybeCallback(cache);
+ cache = null;
+ }
+ p = pathModule.resolve(p);
+ if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+ return process.nextTick(cb.bind(null, null, cache[p]));
+ }
+ var original = p, seenLinks = {}, knownHard = {};
+ var pos;
+ var current;
+ var base;
+ var previous;
+ start();
+ function start() {
+ var m = splitRootRe.exec(p);
+ pos = m[0].length;
+ current = m[0];
+ base = m[0];
+ previous = "";
+ if (isWindows && !knownHard[base]) {
+ fs5.lstat(base, function(err) {
+ if (err)
+ return cb(err);
+ knownHard[base] = true;
+ LOOP();
+ });
+ } else {
+ process.nextTick(LOOP);
+ }
+ }
+ function LOOP() {
+ if (pos >= p.length) {
+ if (cache)
+ cache[original] = p;
+ return cb(null, p);
+ }
+ nextPartRe.lastIndex = pos;
+ var result = nextPartRe.exec(p);
+ previous = current;
+ current += result[0];
+ base = previous + result[1];
+ pos = nextPartRe.lastIndex;
+ if (knownHard[base] || cache && cache[base] === base) {
+ return process.nextTick(LOOP);
+ }
+ if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+ return gotResolvedLink(cache[base]);
+ }
+ return fs5.lstat(base, gotStat);
+ }
+ function gotStat(err, stat3) {
+ if (err)
+ return cb(err);
+ if (!stat3.isSymbolicLink()) {
+ knownHard[base] = true;
+ if (cache)
+ cache[base] = base;
+ return process.nextTick(LOOP);
+ }
+ if (!isWindows) {
+ var id = stat3.dev.toString(32) + ":" + stat3.ino.toString(32);
+ if (seenLinks.hasOwnProperty(id)) {
+ return gotTarget(null, seenLinks[id], base);
+ }
+ }
+ fs5.stat(base, function(err2) {
+ if (err2)
+ return cb(err2);
+ fs5.readlink(base, function(err3, target) {
+ if (!isWindows)
+ seenLinks[id] = target;
+ gotTarget(err3, target);
+ });
+ });
+ }
+ function gotTarget(err, target, base2) {
+ if (err)
+ return cb(err);
+ var resolvedLink = pathModule.resolve(previous, target);
+ if (cache)
+ cache[base2] = resolvedLink;
+ gotResolvedLink(resolvedLink);
+ }
+ function gotResolvedLink(resolvedLink) {
+ p = pathModule.resolve(resolvedLink, p.slice(pos));
+ start();
+ }
+ };
+ }
+});
+
+// node_modules/fs.realpath/index.js
+var require_fs = __commonJS({
+ "node_modules/fs.realpath/index.js"(exports, module2) {
+ module2.exports = realpath;
+ realpath.realpath = realpath;
+ realpath.sync = realpathSync;
+ realpath.realpathSync = realpathSync;
+ realpath.monkeypatch = monkeypatch;
+ realpath.unmonkeypatch = unmonkeypatch;
+ var fs5 = require("fs");
+ var origRealpath = fs5.realpath;
+ var origRealpathSync = fs5.realpathSync;
+ var version2 = process.version;
+ var ok = /^v[0-5]\./.test(version2);
+ var old = require_old();
+ function newError(er) {
+ return er && er.syscall === "realpath" && (er.code === "ELOOP" || er.code === "ENOMEM" || er.code === "ENAMETOOLONG");
+ }
+ function realpath(p, cache, cb) {
+ if (ok) {
+ return origRealpath(p, cache, cb);
+ }
+ if (typeof cache === "function") {
+ cb = cache;
+ cache = null;
+ }
+ origRealpath(p, cache, function(er, result) {
+ if (newError(er)) {
+ old.realpath(p, cache, cb);
+ } else {
+ cb(er, result);
+ }
+ });
+ }
+ function realpathSync(p, cache) {
+ if (ok) {
+ return origRealpathSync(p, cache);
+ }
+ try {
+ return origRealpathSync(p, cache);
+ } catch (er) {
+ if (newError(er)) {
+ return old.realpathSync(p, cache);
+ } else {
+ throw er;
+ }
+ }
+ }
+ function monkeypatch() {
+ fs5.realpath = realpath;
+ fs5.realpathSync = realpathSync;
+ }
+ function unmonkeypatch() {
+ fs5.realpath = origRealpath;
+ fs5.realpathSync = origRealpathSync;
+ }
+ }
+});
+
+// node_modules/concat-map/index.js
+var require_concat_map = __commonJS({
+ "node_modules/concat-map/index.js"(exports, module2) {
+ module2.exports = function(xs, fn) {
+ var res = [];
+ for (var i = 0; i < xs.length; i++) {
+ var x = fn(xs[i], i);
+ if (isArray(x))
+ res.push.apply(res, x);
+ else
+ res.push(x);
+ }
+ return res;
+ };
+ var isArray = Array.isArray || function(xs) {
+ return Object.prototype.toString.call(xs) === "[object Array]";
+ };
+ }
+});
+
+// node_modules/balanced-match/index.js
+var require_balanced_match = __commonJS({
+ "node_modules/balanced-match/index.js"(exports, module2) {
+ "use strict";
+ module2.exports = balanced;
+ function balanced(a, b, str) {
+ if (a instanceof RegExp)
+ a = maybeMatch(a, str);
+ if (b instanceof RegExp)
+ b = maybeMatch(b, str);
+ var r = range(a, b, str);
+ return r && {
+ start: r[0],
+ end: r[1],
+ pre: str.slice(0, r[0]),
+ body: str.slice(r[0] + a.length, r[1]),
+ post: str.slice(r[1] + b.length)
+ };
+ }
+ function maybeMatch(reg, str) {
+ var m = str.match(reg);
+ return m ? m[0] : null;
+ }
+ balanced.range = range;
+ function range(a, b, str) {
+ var begs, beg, left, right, result;
+ var ai = str.indexOf(a);
+ var bi = str.indexOf(b, ai + 1);
+ var i = ai;
+ if (ai >= 0 && bi > 0) {
+ if (a === b) {
+ return [ai, bi];
+ }
+ begs = [];
+ left = str.length;
+ while (i >= 0 && !result) {
+ if (i == ai) {
+ begs.push(i);
+ ai = str.indexOf(a, i + 1);
+ } else if (begs.length == 1) {
+ result = [begs.pop(), bi];
+ } else {
+ beg = begs.pop();
+ if (beg < left) {
+ left = beg;
+ right = bi;
+ }
+ bi = str.indexOf(b, i + 1);
+ }
+ i = ai < bi && ai >= 0 ? ai : bi;
+ }
+ if (begs.length) {
+ result = [left, right];
+ }
+ }
+ return result;
+ }
+ }
+});
+
+// node_modules/brace-expansion/index.js
+var require_brace_expansion = __commonJS({
+ "node_modules/brace-expansion/index.js"(exports, module2) {
+ var concatMap = require_concat_map();
+ var balanced = require_balanced_match();
+ module2.exports = expandTop;
+ var escSlash = "\0SLASH" + Math.random() + "\0";
+ var escOpen = "\0OPEN" + Math.random() + "\0";
+ var escClose = "\0CLOSE" + Math.random() + "\0";
+ var escComma = "\0COMMA" + Math.random() + "\0";
+ var escPeriod = "\0PERIOD" + Math.random() + "\0";
+ function numeric(str) {
+ return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+ }
+ function escapeBraces(str) {
+ return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+ }
+ function unescapeBraces(str) {
+ return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+ }
+ function parseCommaParts(str) {
+ if (!str)
+ return [""];
+ var parts = [];
+ var m = balanced("{", "}", str);
+ if (!m)
+ return str.split(",");
+ var pre = m.pre;
+ var body2 = m.body;
+ var post = m.post;
+ var p = pre.split(",");
+ p[p.length - 1] += "{" + body2 + "}";
+ var postParts = parseCommaParts(post);
+ if (post.length) {
+ p[p.length - 1] += postParts.shift();
+ p.push.apply(p, postParts);
+ }
+ parts.push.apply(parts, p);
+ return parts;
+ }
+ function expandTop(str) {
+ if (!str)
+ return [];
+ if (str.substr(0, 2) === "{}") {
+ str = "\\{\\}" + str.substr(2);
+ }
+ return expand(escapeBraces(str), true).map(unescapeBraces);
+ }
+ function embrace(str) {
+ return "{" + str + "}";
+ }
+ function isPadded(el) {
+ return /^-?0\d/.test(el);
+ }
+ function lte(i, y) {
+ return i <= y;
+ }
+ function gte(i, y) {
+ return i >= y;
+ }
+ function expand(str, isTop) {
+ var expansions = [];
+ var m = balanced("{", "}", str);
+ if (!m || /\$$/.test(m.pre))
+ return [str];
+ var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+ var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+ var isSequence = isNumericSequence || isAlphaSequence;
+ var isOptions = m.body.indexOf(",") >= 0;
+ if (!isSequence && !isOptions) {
+ if (m.post.match(/,.*\}/)) {
+ str = m.pre + "{" + m.body + escClose + m.post;
+ return expand(str);
+ }
+ return [str];
+ }
+ var n;
+ if (isSequence) {
+ n = m.body.split(/\.\./);
+ } else {
+ n = parseCommaParts(m.body);
+ if (n.length === 1) {
+ n = expand(n[0], false).map(embrace);
+ if (n.length === 1) {
+ var post = m.post.length ? expand(m.post, false) : [""];
+ return post.map(function(p) {
+ return m.pre + n[0] + p;
+ });
+ }
+ }
+ }
+ var pre = m.pre;
+ var post = m.post.length ? expand(m.post, false) : [""];
+ var N;
+ if (isSequence) {
+ var x = numeric(n[0]);
+ var y = numeric(n[1]);
+ var width = Math.max(n[0].length, n[1].length);
+ var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
+ var test = lte;
+ var reverse = y < x;
+ if (reverse) {
+ incr *= -1;
+ test = gte;
+ }
+ var pad = n.some(isPadded);
+ N = [];
+ for (var i = x; test(i, y); i += incr) {
+ var c;
+ if (isAlphaSequence) {
+ c = String.fromCharCode(i);
+ if (c === "\\")
+ c = "";
+ } else {
+ c = String(i);
+ if (pad) {
+ var need = width - c.length;
+ if (need > 0) {
+ var z = new Array(need + 1).join("0");
+ if (i < 0)
+ c = "-" + z + c.slice(1);
+ else
+ c = z + c;
+ }
+ }
+ }
+ N.push(c);
+ }
+ } else {
+ N = concatMap(n, function(el) {
+ return expand(el, false);
+ });
+ }
+ for (var j = 0; j < N.length; j++) {
+ for (var k = 0; k < post.length; k++) {
+ var expansion = pre + N[j] + post[k];
+ if (!isTop || isSequence || expansion)
+ expansions.push(expansion);
+ }
+ }
+ return expansions;
+ }
+ }
+});
+
+// node_modules/minimatch/minimatch.js
+var require_minimatch = __commonJS({
+ "node_modules/minimatch/minimatch.js"(exports, module2) {
+ module2.exports = minimatch;
+ minimatch.Minimatch = Minimatch;
+ var path5 = function() {
+ try {
+ return require("path");
+ } catch (e) {
+ }
+ }() || {
+ sep: "/"
+ };
+ minimatch.sep = path5.sep;
+ var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
+ var expand = require_brace_expansion();
+ var plTypes = {
+ "!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
+ "?": { open: "(?:", close: ")?" },
+ "+": { open: "(?:", close: ")+" },
+ "*": { open: "(?:", close: ")*" },
+ "@": { open: "(?:", close: ")" }
+ };
+ var qmark = "[^/]";
+ var star = qmark + "*?";
+ var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+ var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+ var reSpecials = charSet("().*{}+?[]^$\\!");
+ function charSet(s) {
+ return s.split("").reduce(function(set2, c) {
+ set2[c] = true;
+ return set2;
+ }, {});
+ }
+ var slashSplit = /\/+/;
+ minimatch.filter = filter;
+ function filter(pattern, options) {
+ options = options || {};
+ return function(p, i, list) {
+ return minimatch(p, pattern, options);
+ };
+ }
+ function ext(a, b) {
+ b = b || {};
+ var t = {};
+ Object.keys(a).forEach(function(k) {
+ t[k] = a[k];
+ });
+ Object.keys(b).forEach(function(k) {
+ t[k] = b[k];
+ });
+ return t;
+ }
+ minimatch.defaults = function(def) {
+ if (!def || typeof def !== "object" || !Object.keys(def).length) {
+ return minimatch;
+ }
+ var orig = minimatch;
+ var m = function minimatch2(p, pattern, options) {
+ return orig(p, pattern, ext(def, options));
+ };
+ m.Minimatch = function Minimatch2(pattern, options) {
+ return new orig.Minimatch(pattern, ext(def, options));
+ };
+ m.Minimatch.defaults = function defaults(options) {
+ return orig.defaults(ext(def, options)).Minimatch;
+ };
+ m.filter = function filter2(pattern, options) {
+ return orig.filter(pattern, ext(def, options));
+ };
+ m.defaults = function defaults(options) {
+ return orig.defaults(ext(def, options));
+ };
+ m.makeRe = function makeRe2(pattern, options) {
+ return orig.makeRe(pattern, ext(def, options));
+ };
+ m.braceExpand = function braceExpand2(pattern, options) {
+ return orig.braceExpand(pattern, ext(def, options));
+ };
+ m.match = function(list, pattern, options) {
+ return orig.match(list, pattern, ext(def, options));
+ };
+ return m;
+ };
+ Minimatch.defaults = function(def) {
+ return minimatch.defaults(def).Minimatch;
+ };
+ function minimatch(p, pattern, options) {
+ assertValidPattern(pattern);
+ if (!options)
+ options = {};
+ if (!options.nocomment && pattern.charAt(0) === "#") {
+ return false;
+ }
+ return new Minimatch(pattern, options).match(p);
+ }
+ function Minimatch(pattern, options) {
+ if (!(this instanceof Minimatch)) {
+ return new Minimatch(pattern, options);
+ }
+ assertValidPattern(pattern);
+ if (!options)
+ options = {};
+ pattern = pattern.trim();
+ if (!options.allowWindowsEscape && path5.sep !== "/") {
+ pattern = pattern.split(path5.sep).join("/");
+ }
+ this.options = options;
+ this.set = [];
+ this.pattern = pattern;
+ this.regexp = null;
+ this.negate = false;
+ this.comment = false;
+ this.empty = false;
+ this.partial = !!options.partial;
+ this.make();
+ }
+ Minimatch.prototype.debug = function() {
+ };
+ Minimatch.prototype.make = make;
+ function make() {
+ var pattern = this.pattern;
+ var options = this.options;
+ if (!options.nocomment && pattern.charAt(0) === "#") {
+ this.comment = true;
+ return;
+ }
+ if (!pattern) {
+ this.empty = true;
+ return;
+ }
+ this.parseNegate();
+ var set2 = this.globSet = this.braceExpand();
+ if (options.debug)
+ this.debug = function debug() {
+ console.error.apply(console, arguments);
+ };
+ this.debug(this.pattern, set2);
+ set2 = this.globParts = set2.map(function(s) {
+ return s.split(slashSplit);
+ });
+ this.debug(this.pattern, set2);
+ set2 = set2.map(function(s, si, set3) {
+ return s.map(this.parse, this);
+ }, this);
+ this.debug(this.pattern, set2);
+ set2 = set2.filter(function(s) {
+ return s.indexOf(false) === -1;
+ });
+ this.debug(this.pattern, set2);
+ this.set = set2;
+ }
+ Minimatch.prototype.parseNegate = parseNegate;
+ function parseNegate() {
+ var pattern = this.pattern;
+ var negate = false;
+ var options = this.options;
+ var negateOffset = 0;
+ if (options.nonegate)
+ return;
+ for (var i = 0, l = pattern.length; i < l && pattern.charAt(i) === "!"; i++) {
+ negate = !negate;
+ negateOffset++;
+ }
+ if (negateOffset)
+ this.pattern = pattern.substr(negateOffset);
+ this.negate = negate;
+ }
+ minimatch.braceExpand = function(pattern, options) {
+ return braceExpand(pattern, options);
+ };
+ Minimatch.prototype.braceExpand = braceExpand;
+ function braceExpand(pattern, options) {
+ if (!options) {
+ if (this instanceof Minimatch) {
+ options = this.options;
+ } else {
+ options = {};
+ }
+ }
+ pattern = typeof pattern === "undefined" ? this.pattern : pattern;
+ assertValidPattern(pattern);
+ if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+ return [pattern];
+ }
+ return expand(pattern);
+ }
+ var MAX_PATTERN_LENGTH = 1024 * 64;
+ var assertValidPattern = function(pattern) {
+ if (typeof pattern !== "string") {
+ throw new TypeError("invalid pattern");
+ }
+ if (pattern.length > MAX_PATTERN_LENGTH) {
+ throw new TypeError("pattern is too long");
+ }
+ };
+ Minimatch.prototype.parse = parse2;
+ var SUBPARSE = {};
+ function parse2(pattern, isSub) {
+ assertValidPattern(pattern);
+ var options = this.options;
+ if (pattern === "**") {
+ if (!options.noglobstar)
+ return GLOBSTAR;
+ else
+ pattern = "*";
+ }
+ if (pattern === "")
+ return "";
+ var re = "";
+ var hasMagic = !!options.nocase;
+ var escaping = false;
+ var patternListStack = [];
+ var negativeLists = [];
+ var stateChar;
+ var inClass = false;
+ var reClassStart = -1;
+ var classStart = -1;
+ var patternStart = pattern.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
+ var self = this;
+ function clearStateChar() {
+ if (stateChar) {
+ switch (stateChar) {
+ case "*":
+ re += star;
+ hasMagic = true;
+ break;
+ case "?":
+ re += qmark;
+ hasMagic = true;
+ break;
+ default:
+ re += "\\" + stateChar;
+ break;
+ }
+ self.debug("clearStateChar %j %j", stateChar, re);
+ stateChar = false;
+ }
+ }
+ for (var i = 0, len = pattern.length, c; i < len && (c = pattern.charAt(i)); i++) {
+ this.debug("%s %s %s %j", pattern, i, re, c);
+ if (escaping && reSpecials[c]) {
+ re += "\\" + c;
+ escaping = false;
+ continue;
+ }
+ switch (c) {
+ case "/": {
+ return false;
+ }
+ case "\\":
+ clearStateChar();
+ escaping = true;
+ continue;
+ case "?":
+ case "*":
+ case "+":
+ case "@":
+ case "!":
+ this.debug("%s %s %s %j <-- stateChar", pattern, i, re, c);
+ if (inClass) {
+ this.debug(" in class");
+ if (c === "!" && i === classStart + 1)
+ c = "^";
+ re += c;
+ continue;
+ }
+ self.debug("call clearStateChar %j", stateChar);
+ clearStateChar();
+ stateChar = c;
+ if (options.noext)
+ clearStateChar();
+ continue;
+ case "(":
+ if (inClass) {
+ re += "(";
+ continue;
+ }
+ if (!stateChar) {
+ re += "\\(";
+ continue;
+ }
+ patternListStack.push({
+ type: stateChar,
+ start: i - 1,
+ reStart: re.length,
+ open: plTypes[stateChar].open,
+ close: plTypes[stateChar].close
+ });
+ re += stateChar === "!" ? "(?:(?!(?:" : "(?:";
+ this.debug("plType %j %j", stateChar, re);
+ stateChar = false;
+ continue;
+ case ")":
+ if (inClass || !patternListStack.length) {
+ re += "\\)";
+ continue;
+ }
+ clearStateChar();
+ hasMagic = true;
+ var pl = patternListStack.pop();
+ re += pl.close;
+ if (pl.type === "!") {
+ negativeLists.push(pl);
+ }
+ pl.reEnd = re.length;
+ continue;
+ case "|":
+ if (inClass || !patternListStack.length || escaping) {
+ re += "\\|";
+ escaping = false;
+ continue;
+ }
+ clearStateChar();
+ re += "|";
+ continue;
+ case "[":
+ clearStateChar();
+ if (inClass) {
+ re += "\\" + c;
+ continue;
+ }
+ inClass = true;
+ classStart = i;
+ reClassStart = re.length;
+ re += c;
+ continue;
+ case "]":
+ if (i === classStart + 1 || !inClass) {
+ re += "\\" + c;
+ escaping = false;
+ continue;
+ }
+ var cs = pattern.substring(classStart + 1, i);
+ try {
+ RegExp("[" + cs + "]");
+ } catch (er) {
+ var sp = this.parse(cs, SUBPARSE);
+ re = re.substr(0, reClassStart) + "\\[" + sp[0] + "\\]";
+ hasMagic = hasMagic || sp[1];
+ inClass = false;
+ continue;
+ }
+ hasMagic = true;
+ inClass = false;
+ re += c;
+ continue;
+ default:
+ clearStateChar();
+ if (escaping) {
+ escaping = false;
+ } else if (reSpecials[c] && !(c === "^" && inClass)) {
+ re += "\\";
+ }
+ re += c;
+ }
+ }
+ if (inClass) {
+ cs = pattern.substr(classStart + 1);
+ sp = this.parse(cs, SUBPARSE);
+ re = re.substr(0, reClassStart) + "\\[" + sp[0];
+ hasMagic = hasMagic || sp[1];
+ }
+ for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+ var tail = re.slice(pl.reStart + pl.open.length);
+ this.debug("setting tail", re, pl);
+ tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function(_, $1, $2) {
+ if (!$2) {
+ $2 = "\\";
+ }
+ return $1 + $1 + $2 + "|";
+ });
+ this.debug("tail=%j\n %s", tail, tail, pl, re);
+ var t = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
+ hasMagic = true;
+ re = re.slice(0, pl.reStart) + t + "\\(" + tail;
+ }
+ clearStateChar();
+ if (escaping) {
+ re += "\\\\";
+ }
+ var addPatternStart = false;
+ switch (re.charAt(0)) {
+ case "[":
+ case ".":
+ case "(":
+ addPatternStart = true;
+ }
+ for (var n = negativeLists.length - 1; n > -1; n--) {
+ var nl = negativeLists[n];
+ var nlBefore = re.slice(0, nl.reStart);
+ var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
+ var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
+ var nlAfter = re.slice(nl.reEnd);
+ nlLast += nlAfter;
+ var openParensBefore = nlBefore.split("(").length - 1;
+ var cleanAfter = nlAfter;
+ for (i = 0; i < openParensBefore; i++) {
+ cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
+ }
+ nlAfter = cleanAfter;
+ var dollar = "";
+ if (nlAfter === "" && isSub !== SUBPARSE) {
+ dollar = "$";
+ }
+ var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+ re = newRe;
+ }
+ if (re !== "" && hasMagic) {
+ re = "(?=.)" + re;
+ }
+ if (addPatternStart) {
+ re = patternStart + re;
+ }
+ if (isSub === SUBPARSE) {
+ return [re, hasMagic];
+ }
+ if (!hasMagic) {
+ return globUnescape(pattern);
+ }
+ var flags = options.nocase ? "i" : "";
+ try {
+ var regExp = new RegExp("^" + re + "$", flags);
+ } catch (er) {
+ return new RegExp("$.");
+ }
+ regExp._glob = pattern;
+ regExp._src = re;
+ return regExp;
+ }
+ minimatch.makeRe = function(pattern, options) {
+ return new Minimatch(pattern, options || {}).makeRe();
+ };
+ Minimatch.prototype.makeRe = makeRe;
+ function makeRe() {
+ if (this.regexp || this.regexp === false)
+ return this.regexp;
+ var set2 = this.set;
+ if (!set2.length) {
+ this.regexp = false;
+ return this.regexp;
+ }
+ var options = this.options;
+ var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
+ var flags = options.nocase ? "i" : "";
+ var re = set2.map(function(pattern) {
+ return pattern.map(function(p) {
+ return p === GLOBSTAR ? twoStar : typeof p === "string" ? regExpEscape(p) : p._src;
+ }).join("\\/");
+ }).join("|");
+ re = "^(?:" + re + ")$";
+ if (this.negate)
+ re = "^(?!" + re + ").*$";
+ try {
+ this.regexp = new RegExp(re, flags);
+ } catch (ex) {
+ this.regexp = false;
+ }
+ return this.regexp;
+ }
+ minimatch.match = function(list, pattern, options) {
+ options = options || {};
+ var mm = new Minimatch(pattern, options);
+ list = list.filter(function(f) {
+ return mm.match(f);
+ });
+ if (mm.options.nonull && !list.length) {
+ list.push(pattern);
+ }
+ return list;
+ };
+ Minimatch.prototype.match = function match(f, partial) {
+ if (typeof partial === "undefined")
+ partial = this.partial;
+ this.debug("match", f, this.pattern);
+ if (this.comment)
+ return false;
+ if (this.empty)
+ return f === "";
+ if (f === "/" && partial)
+ return true;
+ var options = this.options;
+ if (path5.sep !== "/") {
+ f = f.split(path5.sep).join("/");
+ }
+ f = f.split(slashSplit);
+ this.debug(this.pattern, "split", f);
+ var set2 = this.set;
+ this.debug(this.pattern, "set", set2);
+ var filename;
+ var i;
+ for (i = f.length - 1; i >= 0; i--) {
+ filename = f[i];
+ if (filename)
+ break;
+ }
+ for (i = 0; i < set2.length; i++) {
+ var pattern = set2[i];
+ var file = f;
+ if (options.matchBase && pattern.length === 1) {
+ file = [filename];
+ }
+ var hit = this.matchOne(file, pattern, partial);
+ if (hit) {
+ if (options.flipNegate)
+ return true;
+ return !this.negate;
+ }
+ }
+ if (options.flipNegate)
+ return false;
+ return this.negate;
+ };
+ Minimatch.prototype.matchOne = function(file, pattern, partial) {
+ var options = this.options;
+ this.debug("matchOne", { "this": this, file, pattern });
+ this.debug("matchOne", file.length, pattern.length);
+ for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+ this.debug("matchOne loop");
+ var p = pattern[pi];
+ var f = file[fi];
+ this.debug(pattern, p, f);
+ if (p === false)
+ return false;
+ if (p === GLOBSTAR) {
+ this.debug("GLOBSTAR", [pattern, p, f]);
+ var fr = fi;
+ var pr = pi + 1;
+ if (pr === pl) {
+ this.debug("** at the end");
+ for (; fi < fl; fi++) {
+ if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
+ return false;
+ }
+ return true;
+ }
+ while (fr < fl) {
+ var swallowee = file[fr];
+ this.debug("\nglobstar while", file, fr, pattern, pr, swallowee);
+ if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+ this.debug("globstar found match!", fr, fl, swallowee);
+ return true;
+ } else {
+ if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
+ this.debug("dot detected!", file, fr, pattern, pr);
+ break;
+ }
+ this.debug("globstar swallow a segment, and continue");
+ fr++;
+ }
+ }
+ if (partial) {
+ this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
+ if (fr === fl)
+ return true;
+ }
+ return false;
+ }
+ var hit;
+ if (typeof p === "string") {
+ hit = f === p;
+ this.debug("string match", p, f, hit);
+ } else {
+ hit = f.match(p);
+ this.debug("pattern match", p, f, hit);
+ }
+ if (!hit)
+ return false;
+ }
+ if (fi === fl && pi === pl) {
+ return true;
+ } else if (fi === fl) {
+ return partial;
+ } else if (pi === pl) {
+ return fi === fl - 1 && file[fi] === "";
+ }
+ throw new Error("wtf?");
+ };
+ function globUnescape(s) {
+ return s.replace(/\\(.)/g, "$1");
+ }
+ function regExpEscape(s) {
+ return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+ }
+ }
+});
+
+// node_modules/inherits/inherits_browser.js
+var require_inherits_browser = __commonJS({
+ "node_modules/inherits/inherits_browser.js"(exports, module2) {
+ if (typeof Object.create === "function") {
+ module2.exports = function inherits(ctor, superCtor) {
+ if (superCtor) {
+ ctor.super_ = superCtor;
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ }
+ };
+ } else {
+ module2.exports = function inherits(ctor, superCtor) {
+ if (superCtor) {
+ ctor.super_ = superCtor;
+ var TempCtor = function() {
+ };
+ TempCtor.prototype = superCtor.prototype;
+ ctor.prototype = new TempCtor();
+ ctor.prototype.constructor = ctor;
+ }
+ };
+ }
+ }
+});
+
+// node_modules/path-is-absolute/index.js
+var require_path_is_absolute = __commonJS({
+ "node_modules/path-is-absolute/index.js"(exports, module2) {
+ "use strict";
+ function posix(path5) {
+ return path5.charAt(0) === "/";
+ }
+ function win32(path5) {
+ var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+ var result = splitDeviceRe.exec(path5);
+ var device = result[1] || "";
+ var isUnc = Boolean(device && device.charAt(1) !== ":");
+ return Boolean(result[2] || isUnc);
+ }
+ module2.exports = process.platform === "win32" ? win32 : posix;
+ module2.exports.posix = posix;
+ module2.exports.win32 = win32;
+ }
+});
+
+// node_modules/glob/common.js
+var require_common = __commonJS({
+ "node_modules/glob/common.js"(exports) {
+ exports.setopts = setopts;
+ exports.ownProp = ownProp;
+ exports.makeAbs = makeAbs;
+ exports.finish = finish;
+ exports.mark = mark;
+ exports.isIgnored = isIgnored;
+ exports.childrenIgnored = childrenIgnored;
+ function ownProp(obj, field) {
+ return Object.prototype.hasOwnProperty.call(obj, field);
+ }
+ var fs5 = require("fs");
+ var path5 = require("path");
+ var minimatch = require_minimatch();
+ var isAbsolute = require_path_is_absolute();
+ var Minimatch = minimatch.Minimatch;
+ function alphasort(a, b) {
+ return a.localeCompare(b, "en");
+ }
+ function setupIgnores(self, options) {
+ self.ignore = options.ignore || [];
+ if (!Array.isArray(self.ignore))
+ self.ignore = [self.ignore];
+ if (self.ignore.length) {
+ self.ignore = self.ignore.map(ignoreMap);
+ }
+ }
+ function ignoreMap(pattern) {
+ var gmatcher = null;
+ if (pattern.slice(-3) === "/**") {
+ var gpattern = pattern.replace(/(\/\*\*)+$/, "");
+ gmatcher = new Minimatch(gpattern, { dot: true });
+ }
+ return {
+ matcher: new Minimatch(pattern, { dot: true }),
+ gmatcher
+ };
+ }
+ function setopts(self, pattern, options) {
+ if (!options)
+ options = {};
+ if (options.matchBase && pattern.indexOf("/") === -1) {
+ if (options.noglobstar) {
+ throw new Error("base matching requires globstar");
+ }
+ pattern = "**/" + pattern;
+ }
+ self.silent = !!options.silent;
+ self.pattern = pattern;
+ self.strict = options.strict !== false;
+ self.realpath = !!options.realpath;
+ self.realpathCache = options.realpathCache || Object.create(null);
+ self.follow = !!options.follow;
+ self.dot = !!options.dot;
+ self.mark = !!options.mark;
+ self.nodir = !!options.nodir;
+ if (self.nodir)
+ self.mark = true;
+ self.sync = !!options.sync;
+ self.nounique = !!options.nounique;
+ self.nonull = !!options.nonull;
+ self.nosort = !!options.nosort;
+ self.nocase = !!options.nocase;
+ self.stat = !!options.stat;
+ self.noprocess = !!options.noprocess;
+ self.absolute = !!options.absolute;
+ self.fs = options.fs || fs5;
+ self.maxLength = options.maxLength || Infinity;
+ self.cache = options.cache || Object.create(null);
+ self.statCache = options.statCache || Object.create(null);
+ self.symlinks = options.symlinks || Object.create(null);
+ setupIgnores(self, options);
+ self.changedCwd = false;
+ var cwd = process.cwd();
+ if (!ownProp(options, "cwd"))
+ self.cwd = cwd;
+ else {
+ self.cwd = path5.resolve(options.cwd);
+ self.changedCwd = self.cwd !== cwd;
+ }
+ self.root = options.root || path5.resolve(self.cwd, "/");
+ self.root = path5.resolve(self.root);
+ if (process.platform === "win32")
+ self.root = self.root.replace(/\\/g, "/");
+ self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
+ if (process.platform === "win32")
+ self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
+ self.nomount = !!options.nomount;
+ options.nonegate = true;
+ options.nocomment = true;
+ options.allowWindowsEscape = false;
+ self.minimatch = new Minimatch(pattern, options);
+ self.options = self.minimatch.options;
+ }
+ function finish(self) {
+ var nou = self.nounique;
+ var all = nou ? [] : Object.create(null);
+ for (var i = 0, l = self.matches.length; i < l; i++) {
+ var matches = self.matches[i];
+ if (!matches || Object.keys(matches).length === 0) {
+ if (self.nonull) {
+ var literal = self.minimatch.globSet[i];
+ if (nou)
+ all.push(literal);
+ else
+ all[literal] = true;
+ }
+ } else {
+ var m = Object.keys(matches);
+ if (nou)
+ all.push.apply(all, m);
+ else
+ m.forEach(function(m2) {
+ all[m2] = true;
+ });
+ }
+ }
+ if (!nou)
+ all = Object.keys(all);
+ if (!self.nosort)
+ all = all.sort(alphasort);
+ if (self.mark) {
+ for (var i = 0; i < all.length; i++) {
+ all[i] = self._mark(all[i]);
+ }
+ if (self.nodir) {
+ all = all.filter(function(e) {
+ var notDir = !/\/$/.test(e);
+ var c = self.cache[e] || self.cache[makeAbs(self, e)];
+ if (notDir && c)
+ notDir = c !== "DIR" && !Array.isArray(c);
+ return notDir;
+ });
+ }
+ }
+ if (self.ignore.length)
+ all = all.filter(function(m2) {
+ return !isIgnored(self, m2);
+ });
+ self.found = all;
+ }
+ function mark(self, p) {
+ var abs = makeAbs(self, p);
+ var c = self.cache[abs];
+ var m = p;
+ if (c) {
+ var isDir = c === "DIR" || Array.isArray(c);
+ var slash = p.slice(-1) === "/";
+ if (isDir && !slash)
+ m += "/";
+ else if (!isDir && slash)
+ m = m.slice(0, -1);
+ if (m !== p) {
+ var mabs = makeAbs(self, m);
+ self.statCache[mabs] = self.statCache[abs];
+ self.cache[mabs] = self.cache[abs];
+ }
+ }
+ return m;
+ }
+ function makeAbs(self, f) {
+ var abs = f;
+ if (f.charAt(0) === "/") {
+ abs = path5.join(self.root, f);
+ } else if (isAbsolute(f) || f === "") {
+ abs = f;
+ } else if (self.changedCwd) {
+ abs = path5.resolve(self.cwd, f);
+ } else {
+ abs = path5.resolve(f);
+ }
+ if (process.platform === "win32")
+ abs = abs.replace(/\\/g, "/");
+ return abs;
+ }
+ function isIgnored(self, path6) {
+ if (!self.ignore.length)
+ return false;
+ return self.ignore.some(function(item) {
+ return item.matcher.match(path6) || !!(item.gmatcher && item.gmatcher.match(path6));
+ });
+ }
+ function childrenIgnored(self, path6) {
+ if (!self.ignore.length)
+ return false;
+ return self.ignore.some(function(item) {
+ return !!(item.gmatcher && item.gmatcher.match(path6));
+ });
+ }
+ }
+});
+
+// node_modules/glob/sync.js
+var require_sync = __commonJS({
+ "node_modules/glob/sync.js"(exports, module2) {
+ module2.exports = globSync;
+ globSync.GlobSync = GlobSync;
+ var rp = require_fs();
+ var minimatch = require_minimatch();
+ var Minimatch = minimatch.Minimatch;
+ var Glob = require_glob().Glob;
+ var util = require("util");
+ var path5 = require("path");
+ var assert = require("assert");
+ var isAbsolute = require_path_is_absolute();
+ var common = require_common();
+ var setopts = common.setopts;
+ var ownProp = common.ownProp;
+ var childrenIgnored = common.childrenIgnored;
+ var isIgnored = common.isIgnored;
+ function globSync(pattern, options) {
+ if (typeof options === "function" || arguments.length === 3)
+ throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
+ return new GlobSync(pattern, options).found;
+ }
+ function GlobSync(pattern, options) {
+ if (!pattern)
+ throw new Error("must provide pattern");
+ if (typeof options === "function" || arguments.length === 3)
+ throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
+ if (!(this instanceof GlobSync))
+ return new GlobSync(pattern, options);
+ setopts(this, pattern, options);
+ if (this.noprocess)
+ return this;
+ var n = this.minimatch.set.length;
+ this.matches = new Array(n);
+ for (var i = 0; i < n; i++) {
+ this._process(this.minimatch.set[i], i, false);
+ }
+ this._finish();
+ }
+ GlobSync.prototype._finish = function() {
+ assert.ok(this instanceof GlobSync);
+ if (this.realpath) {
+ var self = this;
+ this.matches.forEach(function(matchset, index) {
+ var set2 = self.matches[index] = Object.create(null);
+ for (var p in matchset) {
+ try {
+ p = self._makeAbs(p);
+ var real = rp.realpathSync(p, self.realpathCache);
+ set2[real] = true;
+ } catch (er) {
+ if (er.syscall === "stat")
+ set2[self._makeAbs(p)] = true;
+ else
+ throw er;
+ }
+ }
+ });
+ }
+ common.finish(this);
+ };
+ GlobSync.prototype._process = function(pattern, index, inGlobStar) {
+ assert.ok(this instanceof GlobSync);
+ var n = 0;
+ while (typeof pattern[n] === "string") {
+ n++;
+ }
+ var prefix;
+ switch (n) {
+ case pattern.length:
+ this._processSimple(pattern.join("/"), index);
+ return;
+ case 0:
+ prefix = null;
+ break;
+ default:
+ prefix = pattern.slice(0, n).join("/");
+ break;
+ }
+ var remain = pattern.slice(n);
+ var read;
+ if (prefix === null)
+ read = ".";
+ else if (isAbsolute(prefix) || isAbsolute(pattern.map(function(p) {
+ return typeof p === "string" ? p : "[*]";
+ }).join("/"))) {
+ if (!prefix || !isAbsolute(prefix))
+ prefix = "/" + prefix;
+ read = prefix;
+ } else
+ read = prefix;
+ var abs = this._makeAbs(read);
+ if (childrenIgnored(this, read))
+ return;
+ var isGlobStar = remain[0] === minimatch.GLOBSTAR;
+ if (isGlobStar)
+ this._processGlobStar(prefix, read, abs, remain, index, inGlobStar);
+ else
+ this._processReaddir(prefix, read, abs, remain, index, inGlobStar);
+ };
+ GlobSync.prototype._processReaddir = function(prefix, read, abs, remain, index, inGlobStar) {
+ var entries = this._readdir(abs, inGlobStar);
+ if (!entries)
+ return;
+ var pn = remain[0];
+ var negate = !!this.minimatch.negate;
+ var rawGlob = pn._glob;
+ var dotOk = this.dot || rawGlob.charAt(0) === ".";
+ var matchedEntries = [];
+ for (var i = 0; i < entries.length; i++) {
+ var e = entries[i];
+ if (e.charAt(0) !== "." || dotOk) {
+ var m;
+ if (negate && !prefix) {
+ m = !e.match(pn);
+ } else {
+ m = e.match(pn);
+ }
+ if (m)
+ matchedEntries.push(e);
+ }
+ }
+ var len = matchedEntries.length;
+ if (len === 0)
+ return;
+ if (remain.length === 1 && !this.mark && !this.stat) {
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null);
+ for (var i = 0; i < len; i++) {
+ var e = matchedEntries[i];
+ if (prefix) {
+ if (prefix.slice(-1) !== "/")
+ e = prefix + "/" + e;
+ else
+ e = prefix + e;
+ }
+ if (e.charAt(0) === "/" && !this.nomount) {
+ e = path5.join(this.root, e);
+ }
+ this._emitMatch(index, e);
+ }
+ return;
+ }
+ remain.shift();
+ for (var i = 0; i < len; i++) {
+ var e = matchedEntries[i];
+ var newPattern;
+ if (prefix)
+ newPattern = [prefix, e];
+ else
+ newPattern = [e];
+ this._process(newPattern.concat(remain), index, inGlobStar);
+ }
+ };
+ GlobSync.prototype._emitMatch = function(index, e) {
+ if (isIgnored(this, e))
+ return;
+ var abs = this._makeAbs(e);
+ if (this.mark)
+ e = this._mark(e);
+ if (this.absolute) {
+ e = abs;
+ }
+ if (this.matches[index][e])
+ return;
+ if (this.nodir) {
+ var c = this.cache[abs];
+ if (c === "DIR" || Array.isArray(c))
+ return;
+ }
+ this.matches[index][e] = true;
+ if (this.stat)
+ this._stat(e);
+ };
+ GlobSync.prototype._readdirInGlobStar = function(abs) {
+ if (this.follow)
+ return this._readdir(abs, false);
+ var entries;
+ var lstat;
+ var stat3;
+ try {
+ lstat = this.fs.lstatSync(abs);
+ } catch (er) {
+ if (er.code === "ENOENT") {
+ return null;
+ }
+ }
+ var isSym = lstat && lstat.isSymbolicLink();
+ this.symlinks[abs] = isSym;
+ if (!isSym && lstat && !lstat.isDirectory())
+ this.cache[abs] = "FILE";
+ else
+ entries = this._readdir(abs, false);
+ return entries;
+ };
+ GlobSync.prototype._readdir = function(abs, inGlobStar) {
+ var entries;
+ if (inGlobStar && !ownProp(this.symlinks, abs))
+ return this._readdirInGlobStar(abs);
+ if (ownProp(this.cache, abs)) {
+ var c = this.cache[abs];
+ if (!c || c === "FILE")
+ return null;
+ if (Array.isArray(c))
+ return c;
+ }
+ try {
+ return this._readdirEntries(abs, this.fs.readdirSync(abs));
+ } catch (er) {
+ this._readdirError(abs, er);
+ return null;
+ }
+ };
+ GlobSync.prototype._readdirEntries = function(abs, entries) {
+ if (!this.mark && !this.stat) {
+ for (var i = 0; i < entries.length; i++) {
+ var e = entries[i];
+ if (abs === "/")
+ e = abs + e;
+ else
+ e = abs + "/" + e;
+ this.cache[e] = true;
+ }
+ }
+ this.cache[abs] = entries;
+ return entries;
+ };
+ GlobSync.prototype._readdirError = function(f, er) {
+ switch (er.code) {
+ case "ENOTSUP":
+ case "ENOTDIR":
+ var abs = this._makeAbs(f);
+ this.cache[abs] = "FILE";
+ if (abs === this.cwdAbs) {
+ var error = new Error(er.code + " invalid cwd " + this.cwd);
+ error.path = this.cwd;
+ error.code = er.code;
+ throw error;
+ }
+ break;
+ case "ENOENT":
+ case "ELOOP":
+ case "ENAMETOOLONG":
+ case "UNKNOWN":
+ this.cache[this._makeAbs(f)] = false;
+ break;
+ default:
+ this.cache[this._makeAbs(f)] = false;
+ if (this.strict)
+ throw er;
+ if (!this.silent)
+ console.error("glob error", er);
+ break;
+ }
+ };
+ GlobSync.prototype._processGlobStar = function(prefix, read, abs, remain, index, inGlobStar) {
+ var entries = this._readdir(abs, inGlobStar);
+ if (!entries)
+ return;
+ var remainWithoutGlobStar = remain.slice(1);
+ var gspref = prefix ? [prefix] : [];
+ var noGlobStar = gspref.concat(remainWithoutGlobStar);
+ this._process(noGlobStar, index, false);
+ var len = entries.length;
+ var isSym = this.symlinks[abs];
+ if (isSym && inGlobStar)
+ return;
+ for (var i = 0; i < len; i++) {
+ var e = entries[i];
+ if (e.charAt(0) === "." && !this.dot)
+ continue;
+ var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+ this._process(instead, index, true);
+ var below = gspref.concat(entries[i], remain);
+ this._process(below, index, true);
+ }
+ };
+ GlobSync.prototype._processSimple = function(prefix, index) {
+ var exists = this._stat(prefix);
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null);
+ if (!exists)
+ return;
+ if (prefix && isAbsolute(prefix) && !this.nomount) {
+ var trail = /[\/\\]$/.test(prefix);
+ if (prefix.charAt(0) === "/") {
+ prefix = path5.join(this.root, prefix);
+ } else {
+ prefix = path5.resolve(this.root, prefix);
+ if (trail)
+ prefix += "/";
+ }
+ }
+ if (process.platform === "win32")
+ prefix = prefix.replace(/\\/g, "/");
+ this._emitMatch(index, prefix);
+ };
+ GlobSync.prototype._stat = function(f) {
+ var abs = this._makeAbs(f);
+ var needDir = f.slice(-1) === "/";
+ if (f.length > this.maxLength)
+ return false;
+ if (!this.stat && ownProp(this.cache, abs)) {
+ var c = this.cache[abs];
+ if (Array.isArray(c))
+ c = "DIR";
+ if (!needDir || c === "DIR")
+ return c;
+ if (needDir && c === "FILE")
+ return false;
+ }
+ var exists;
+ var stat3 = this.statCache[abs];
+ if (!stat3) {
+ var lstat;
+ try {
+ lstat = this.fs.lstatSync(abs);
+ } catch (er) {
+ if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
+ this.statCache[abs] = false;
+ return false;
+ }
+ }
+ if (lstat && lstat.isSymbolicLink()) {
+ try {
+ stat3 = this.fs.statSync(abs);
+ } catch (er) {
+ stat3 = lstat;
+ }
+ } else {
+ stat3 = lstat;
+ }
+ }
+ this.statCache[abs] = stat3;
+ var c = true;
+ if (stat3)
+ c = stat3.isDirectory() ? "DIR" : "FILE";
+ this.cache[abs] = this.cache[abs] || c;
+ if (needDir && c === "FILE")
+ return false;
+ return c;
+ };
+ GlobSync.prototype._mark = function(p) {
+ return common.mark(this, p);
+ };
+ GlobSync.prototype._makeAbs = function(f) {
+ return common.makeAbs(this, f);
+ };
+ }
+});
+
+// node_modules/wrappy/wrappy.js
+var require_wrappy = __commonJS({
+ "node_modules/wrappy/wrappy.js"(exports, module2) {
+ module2.exports = wrappy;
+ function wrappy(fn, cb) {
+ if (fn && cb)
+ return wrappy(fn)(cb);
+ if (typeof fn !== "function")
+ throw new TypeError("need wrapper function");
+ Object.keys(fn).forEach(function(k) {
+ wrapper[k] = fn[k];
+ });
+ return wrapper;
+ function wrapper() {
+ var args = new Array(arguments.length);
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i];
+ }
+ var ret = fn.apply(this, args);
+ var cb2 = args[args.length - 1];
+ if (typeof ret === "function" && ret !== cb2) {
+ Object.keys(cb2).forEach(function(k) {
+ ret[k] = cb2[k];
+ });
+ }
+ return ret;
+ }
+ }
+ }
+});
+
+// node_modules/once/once.js
+var require_once = __commonJS({
+ "node_modules/once/once.js"(exports, module2) {
+ var wrappy = require_wrappy();
+ module2.exports = wrappy(once);
+ module2.exports.strict = wrappy(onceStrict);
+ once.proto = once(function() {
+ Object.defineProperty(Function.prototype, "once", {
+ value: function() {
+ return once(this);
+ },
+ configurable: true
+ });
+ Object.defineProperty(Function.prototype, "onceStrict", {
+ value: function() {
+ return onceStrict(this);
+ },
+ configurable: true
+ });
+ });
+ function once(fn) {
+ var f = function() {
+ if (f.called)
+ return f.value;
+ f.called = true;
+ return f.value = fn.apply(this, arguments);
+ };
+ f.called = false;
+ return f;
+ }
+ function onceStrict(fn) {
+ var f = function() {
+ if (f.called)
+ throw new Error(f.onceError);
+ f.called = true;
+ return f.value = fn.apply(this, arguments);
+ };
+ var name = fn.name || "Function wrapped with `once`";
+ f.onceError = name + " shouldn't be called more than once";
+ f.called = false;
+ return f;
+ }
+ }
+});
+
+// node_modules/inflight/inflight.js
+var require_inflight = __commonJS({
+ "node_modules/inflight/inflight.js"(exports, module2) {
+ var wrappy = require_wrappy();
+ var reqs = Object.create(null);
+ var once = require_once();
+ module2.exports = wrappy(inflight);
+ function inflight(key, cb) {
+ if (reqs[key]) {
+ reqs[key].push(cb);
+ return null;
+ } else {
+ reqs[key] = [cb];
+ return makeres(key);
+ }
+ }
+ function makeres(key) {
+ return once(function RES() {
+ var cbs = reqs[key];
+ var len = cbs.length;
+ var args = slice(arguments);
+ try {
+ for (var i = 0; i < len; i++) {
+ cbs[i].apply(null, args);
+ }
+ } finally {
+ if (cbs.length > len) {
+ cbs.splice(0, len);
+ process.nextTick(function() {
+ RES.apply(null, args);
+ });
+ } else {
+ delete reqs[key];
+ }
+ }
+ });
+ }
+ function slice(args) {
+ var length = args.length;
+ var array = [];
+ for (var i = 0; i < length; i++)
+ array[i] = args[i];
+ return array;
+ }
+ }
+});
+
+// node_modules/glob/glob.js
+var require_glob = __commonJS({
+ "node_modules/glob/glob.js"(exports, module2) {
+ module2.exports = glob;
+ var rp = require_fs();
+ var minimatch = require_minimatch();
+ var Minimatch = minimatch.Minimatch;
+ var inherits = require_inherits_browser();
+ var EE = require("events").EventEmitter;
+ var path5 = require("path");
+ var assert = require("assert");
+ var isAbsolute = require_path_is_absolute();
+ var globSync = require_sync();
+ var common = require_common();
+ var setopts = common.setopts;
+ var ownProp = common.ownProp;
+ var inflight = require_inflight();
+ var util = require("util");
+ var childrenIgnored = common.childrenIgnored;
+ var isIgnored = common.isIgnored;
+ var once = require_once();
+ function glob(pattern, options, cb) {
+ if (typeof options === "function")
+ cb = options, options = {};
+ if (!options)
+ options = {};
+ if (options.sync) {
+ if (cb)
+ throw new TypeError("callback provided to sync glob");
+ return globSync(pattern, options);
+ }
+ return new Glob(pattern, options, cb);
+ }
+ glob.sync = globSync;
+ var GlobSync = glob.GlobSync = globSync.GlobSync;
+ glob.glob = glob;
+ function extend(origin, add) {
+ if (add === null || typeof add !== "object") {
+ return origin;
+ }
+ var keys = Object.keys(add);
+ var i = keys.length;
+ while (i--) {
+ origin[keys[i]] = add[keys[i]];
+ }
+ return origin;
+ }
+ glob.hasMagic = function(pattern, options_) {
+ var options = extend({}, options_);
+ options.noprocess = true;
+ var g = new Glob(pattern, options);
+ var set2 = g.minimatch.set;
+ if (!pattern)
+ return false;
+ if (set2.length > 1)
+ return true;
+ for (var j = 0; j < set2[0].length; j++) {
+ if (typeof set2[0][j] !== "string")
+ return true;
+ }
+ return false;
+ };
+ glob.Glob = Glob;
+ inherits(Glob, EE);
+ function Glob(pattern, options, cb) {
+ if (typeof options === "function") {
+ cb = options;
+ options = null;
+ }
+ if (options && options.sync) {
+ if (cb)
+ throw new TypeError("callback provided to sync glob");
+ return new GlobSync(pattern, options);
+ }
+ if (!(this instanceof Glob))
+ return new Glob(pattern, options, cb);
+ setopts(this, pattern, options);
+ this._didRealPath = false;
+ var n = this.minimatch.set.length;
+ this.matches = new Array(n);
+ if (typeof cb === "function") {
+ cb = once(cb);
+ this.on("error", cb);
+ this.on("end", function(matches) {
+ cb(null, matches);
+ });
+ }
+ var self = this;
+ this._processing = 0;
+ this._emitQueue = [];
+ this._processQueue = [];
+ this.paused = false;
+ if (this.noprocess)
+ return this;
+ if (n === 0)
+ return done();
+ var sync = true;
+ for (var i = 0; i < n; i++) {
+ this._process(this.minimatch.set[i], i, false, done);
+ }
+ sync = false;
+ function done() {
+ --self._processing;
+ if (self._processing <= 0) {
+ if (sync) {
+ process.nextTick(function() {
+ self._finish();
+ });
+ } else {
+ self._finish();
+ }
+ }
+ }
+ }
+ Glob.prototype._finish = function() {
+ assert(this instanceof Glob);
+ if (this.aborted)
+ return;
+ if (this.realpath && !this._didRealpath)
+ return this._realpath();
+ common.finish(this);
+ this.emit("end", this.found);
+ };
+ Glob.prototype._realpath = function() {
+ if (this._didRealpath)
+ return;
+ this._didRealpath = true;
+ var n = this.matches.length;
+ if (n === 0)
+ return this._finish();
+ var self = this;
+ for (var i = 0; i < this.matches.length; i++)
+ this._realpathSet(i, next);
+ function next() {
+ if (--n === 0)
+ self._finish();
+ }
+ };
+ Glob.prototype._realpathSet = function(index, cb) {
+ var matchset = this.matches[index];
+ if (!matchset)
+ return cb();
+ var found = Object.keys(matchset);
+ var self = this;
+ var n = found.length;
+ if (n === 0)
+ return cb();
+ var set2 = this.matches[index] = Object.create(null);
+ found.forEach(function(p, i) {
+ p = self._makeAbs(p);
+ rp.realpath(p, self.realpathCache, function(er, real) {
+ if (!er)
+ set2[real] = true;
+ else if (er.syscall === "stat")
+ set2[p] = true;
+ else
+ self.emit("error", er);
+ if (--n === 0) {
+ self.matches[index] = set2;
+ cb();
+ }
+ });
+ });
+ };
+ Glob.prototype._mark = function(p) {
+ return common.mark(this, p);
+ };
+ Glob.prototype._makeAbs = function(f) {
+ return common.makeAbs(this, f);
+ };
+ Glob.prototype.abort = function() {
+ this.aborted = true;
+ this.emit("abort");
+ };
+ Glob.prototype.pause = function() {
+ if (!this.paused) {
+ this.paused = true;
+ this.emit("pause");
+ }
+ };
+ Glob.prototype.resume = function() {
+ if (this.paused) {
+ this.emit("resume");
+ this.paused = false;
+ if (this._emitQueue.length) {
+ var eq = this._emitQueue.slice(0);
+ this._emitQueue.length = 0;
+ for (var i = 0; i < eq.length; i++) {
+ var e = eq[i];
+ this._emitMatch(e[0], e[1]);
+ }
+ }
+ if (this._processQueue.length) {
+ var pq = this._processQueue.slice(0);
+ this._processQueue.length = 0;
+ for (var i = 0; i < pq.length; i++) {
+ var p = pq[i];
+ this._processing--;
+ this._process(p[0], p[1], p[2], p[3]);
+ }
+ }
+ }
+ };
+ Glob.prototype._process = function(pattern, index, inGlobStar, cb) {
+ assert(this instanceof Glob);
+ assert(typeof cb === "function");
+ if (this.aborted)
+ return;
+ this._processing++;
+ if (this.paused) {
+ this._processQueue.push([pattern, index, inGlobStar, cb]);
+ return;
+ }
+ var n = 0;
+ while (typeof pattern[n] === "string") {
+ n++;
+ }
+ var prefix;
+ switch (n) {
+ case pattern.length:
+ this._processSimple(pattern.join("/"), index, cb);
+ return;
+ case 0:
+ prefix = null;
+ break;
+ default:
+ prefix = pattern.slice(0, n).join("/");
+ break;
+ }
+ var remain = pattern.slice(n);
+ var read;
+ if (prefix === null)
+ read = ".";
+ else if (isAbsolute(prefix) || isAbsolute(pattern.map(function(p) {
+ return typeof p === "string" ? p : "[*]";
+ }).join("/"))) {
+ if (!prefix || !isAbsolute(prefix))
+ prefix = "/" + prefix;
+ read = prefix;
+ } else
+ read = prefix;
+ var abs = this._makeAbs(read);
+ if (childrenIgnored(this, read))
+ return cb();
+ var isGlobStar = remain[0] === minimatch.GLOBSTAR;
+ if (isGlobStar)
+ this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);
+ else
+ this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
+ };
+ Glob.prototype._processReaddir = function(prefix, read, abs, remain, index, inGlobStar, cb) {
+ var self = this;
+ this._readdir(abs, inGlobStar, function(er, entries) {
+ return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+ });
+ };
+ Glob.prototype._processReaddir2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+ if (!entries)
+ return cb();
+ var pn = remain[0];
+ var negate = !!this.minimatch.negate;
+ var rawGlob = pn._glob;
+ var dotOk = this.dot || rawGlob.charAt(0) === ".";
+ var matchedEntries = [];
+ for (var i = 0; i < entries.length; i++) {
+ var e = entries[i];
+ if (e.charAt(0) !== "." || dotOk) {
+ var m;
+ if (negate && !prefix) {
+ m = !e.match(pn);
+ } else {
+ m = e.match(pn);
+ }
+ if (m)
+ matchedEntries.push(e);
+ }
+ }
+ var len = matchedEntries.length;
+ if (len === 0)
+ return cb();
+ if (remain.length === 1 && !this.mark && !this.stat) {
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null);
+ for (var i = 0; i < len; i++) {
+ var e = matchedEntries[i];
+ if (prefix) {
+ if (prefix !== "/")
+ e = prefix + "/" + e;
+ else
+ e = prefix + e;
+ }
+ if (e.charAt(0) === "/" && !this.nomount) {
+ e = path5.join(this.root, e);
+ }
+ this._emitMatch(index, e);
+ }
+ return cb();
+ }
+ remain.shift();
+ for (var i = 0; i < len; i++) {
+ var e = matchedEntries[i];
+ var newPattern;
+ if (prefix) {
+ if (prefix !== "/")
+ e = prefix + "/" + e;
+ else
+ e = prefix + e;
+ }
+ this._process([e].concat(remain), index, inGlobStar, cb);
+ }
+ cb();
+ };
+ Glob.prototype._emitMatch = function(index, e) {
+ if (this.aborted)
+ return;
+ if (isIgnored(this, e))
+ return;
+ if (this.paused) {
+ this._emitQueue.push([index, e]);
+ return;
+ }
+ var abs = isAbsolute(e) ? e : this._makeAbs(e);
+ if (this.mark)
+ e = this._mark(e);
+ if (this.absolute)
+ e = abs;
+ if (this.matches[index][e])
+ return;
+ if (this.nodir) {
+ var c = this.cache[abs];
+ if (c === "DIR" || Array.isArray(c))
+ return;
+ }
+ this.matches[index][e] = true;
+ var st = this.statCache[abs];
+ if (st)
+ this.emit("stat", e, st);
+ this.emit("match", e);
+ };
+ Glob.prototype._readdirInGlobStar = function(abs, cb) {
+ if (this.aborted)
+ return;
+ if (this.follow)
+ return this._readdir(abs, false, cb);
+ var lstatkey = "lstat\0" + abs;
+ var self = this;
+ var lstatcb = inflight(lstatkey, lstatcb_);
+ if (lstatcb)
+ self.fs.lstat(abs, lstatcb);
+ function lstatcb_(er, lstat) {
+ if (er && er.code === "ENOENT")
+ return cb();
+ var isSym = lstat && lstat.isSymbolicLink();
+ self.symlinks[abs] = isSym;
+ if (!isSym && lstat && !lstat.isDirectory()) {
+ self.cache[abs] = "FILE";
+ cb();
+ } else
+ self._readdir(abs, false, cb);
+ }
+ };
+ Glob.prototype._readdir = function(abs, inGlobStar, cb) {
+ if (this.aborted)
+ return;
+ cb = inflight("readdir\0" + abs + "\0" + inGlobStar, cb);
+ if (!cb)
+ return;
+ if (inGlobStar && !ownProp(this.symlinks, abs))
+ return this._readdirInGlobStar(abs, cb);
+ if (ownProp(this.cache, abs)) {
+ var c = this.cache[abs];
+ if (!c || c === "FILE")
+ return cb();
+ if (Array.isArray(c))
+ return cb(null, c);
+ }
+ var self = this;
+ self.fs.readdir(abs, readdirCb(this, abs, cb));
+ };
+ function readdirCb(self, abs, cb) {
+ return function(er, entries) {
+ if (er)
+ self._readdirError(abs, er, cb);
+ else
+ self._readdirEntries(abs, entries, cb);
+ };
+ }
+ Glob.prototype._readdirEntries = function(abs, entries, cb) {
+ if (this.aborted)
+ return;
+ if (!this.mark && !this.stat) {
+ for (var i = 0; i < entries.length; i++) {
+ var e = entries[i];
+ if (abs === "/")
+ e = abs + e;
+ else
+ e = abs + "/" + e;
+ this.cache[e] = true;
+ }
+ }
+ this.cache[abs] = entries;
+ return cb(null, entries);
+ };
+ Glob.prototype._readdirError = function(f, er, cb) {
+ if (this.aborted)
+ return;
+ switch (er.code) {
+ case "ENOTSUP":
+ case "ENOTDIR":
+ var abs = this._makeAbs(f);
+ this.cache[abs] = "FILE";
+ if (abs === this.cwdAbs) {
+ var error = new Error(er.code + " invalid cwd " + this.cwd);
+ error.path = this.cwd;
+ error.code = er.code;
+ this.emit("error", error);
+ this.abort();
+ }
+ break;
+ case "ENOENT":
+ case "ELOOP":
+ case "ENAMETOOLONG":
+ case "UNKNOWN":
+ this.cache[this._makeAbs(f)] = false;
+ break;
+ default:
+ this.cache[this._makeAbs(f)] = false;
+ if (this.strict) {
+ this.emit("error", er);
+ this.abort();
+ }
+ if (!this.silent)
+ console.error("glob error", er);
+ break;
+ }
+ return cb();
+ };
+ Glob.prototype._processGlobStar = function(prefix, read, abs, remain, index, inGlobStar, cb) {
+ var self = this;
+ this._readdir(abs, inGlobStar, function(er, entries) {
+ self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+ });
+ };
+ Glob.prototype._processGlobStar2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+ if (!entries)
+ return cb();
+ var remainWithoutGlobStar = remain.slice(1);
+ var gspref = prefix ? [prefix] : [];
+ var noGlobStar = gspref.concat(remainWithoutGlobStar);
+ this._process(noGlobStar, index, false, cb);
+ var isSym = this.symlinks[abs];
+ var len = entries.length;
+ if (isSym && inGlobStar)
+ return cb();
+ for (var i = 0; i < len; i++) {
+ var e = entries[i];
+ if (e.charAt(0) === "." && !this.dot)
+ continue;
+ var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+ this._process(instead, index, true, cb);
+ var below = gspref.concat(entries[i], remain);
+ this._process(below, index, true, cb);
+ }
+ cb();
+ };
+ Glob.prototype._processSimple = function(prefix, index, cb) {
+ var self = this;
+ this._stat(prefix, function(er, exists) {
+ self._processSimple2(prefix, index, er, exists, cb);
+ });
+ };
+ Glob.prototype._processSimple2 = function(prefix, index, er, exists, cb) {
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null);
+ if (!exists)
+ return cb();
+ if (prefix && isAbsolute(prefix) && !this.nomount) {
+ var trail = /[\/\\]$/.test(prefix);
+ if (prefix.charAt(0) === "/") {
+ prefix = path5.join(this.root, prefix);
+ } else {
+ prefix = path5.resolve(this.root, prefix);
+ if (trail)
+ prefix += "/";
+ }
+ }
+ if (process.platform === "win32")
+ prefix = prefix.replace(/\\/g, "/");
+ this._emitMatch(index, prefix);
+ cb();
+ };
+ Glob.prototype._stat = function(f, cb) {
+ var abs = this._makeAbs(f);
+ var needDir = f.slice(-1) === "/";
+ if (f.length > this.maxLength)
+ return cb();
+ if (!this.stat && ownProp(this.cache, abs)) {
+ var c = this.cache[abs];
+ if (Array.isArray(c))
+ c = "DIR";
+ if (!needDir || c === "DIR")
+ return cb(null, c);
+ if (needDir && c === "FILE")
+ return cb();
+ }
+ var exists;
+ var stat3 = this.statCache[abs];
+ if (stat3 !== void 0) {
+ if (stat3 === false)
+ return cb(null, stat3);
+ else {
+ var type = stat3.isDirectory() ? "DIR" : "FILE";
+ if (needDir && type === "FILE")
+ return cb();
+ else
+ return cb(null, type, stat3);
+ }
+ }
+ var self = this;
+ var statcb = inflight("stat\0" + abs, lstatcb_);
+ if (statcb)
+ self.fs.lstat(abs, statcb);
+ function lstatcb_(er, lstat) {
+ if (lstat && lstat.isSymbolicLink()) {
+ return self.fs.stat(abs, function(er2, stat4) {
+ if (er2)
+ self._stat2(f, abs, null, lstat, cb);
+ else
+ self._stat2(f, abs, er2, stat4, cb);
+ });
+ } else {
+ self._stat2(f, abs, er, lstat, cb);
+ }
+ }
+ };
+ Glob.prototype._stat2 = function(f, abs, er, stat3, cb) {
+ if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
+ this.statCache[abs] = false;
+ return cb();
+ }
+ var needDir = f.slice(-1) === "/";
+ this.statCache[abs] = stat3;
+ if (abs.slice(-1) === "/" && stat3 && !stat3.isDirectory())
+ return cb(null, false, stat3);
+ var c = true;
+ if (stat3)
+ c = stat3.isDirectory() ? "DIR" : "FILE";
+ this.cache[abs] = this.cache[abs] || c;
+ if (needDir && c === "FILE")
+ return cb();
+ return cb(null, c, stat3);
+ };
+ }
+});
+
+// node_modules/rimraf/rimraf.js
+var require_rimraf = __commonJS({
+ "node_modules/rimraf/rimraf.js"(exports, module2) {
+ module2.exports = rimraf;
+ rimraf.sync = rimrafSync;
+ var assert = require("assert");
+ var path5 = require("path");
+ var fs5 = require("fs");
+ var glob = require_glob();
+ var _0666 = parseInt("666", 8);
+ var defaultGlobOpts = {
+ nosort: true,
+ silent: true
+ };
+ var timeout = 0;
+ var isWindows = process.platform === "win32";
+ function defaults(options) {
+ var methods = [
+ "unlink",
+ "chmod",
+ "stat",
+ "lstat",
+ "rmdir",
+ "readdir"
+ ];
+ methods.forEach(function(m) {
+ options[m] = options[m] || fs5[m];
+ m = m + "Sync";
+ options[m] = options[m] || fs5[m];
+ });
+ options.maxBusyTries = options.maxBusyTries || 3;
+ options.emfileWait = options.emfileWait || 1e3;
+ if (options.glob === false) {
+ options.disableGlob = true;
+ }
+ options.disableGlob = options.disableGlob || false;
+ options.glob = options.glob || defaultGlobOpts;
+ }
+ function rimraf(p, options, cb) {
+ if (typeof options === "function") {
+ cb = options;
+ options = {};
+ }
+ assert(p, "rimraf: missing path");
+ assert.equal(typeof p, "string", "rimraf: path should be a string");
+ assert.equal(typeof cb, "function", "rimraf: callback function required");
+ assert(options, "rimraf: invalid options argument provided");
+ assert.equal(typeof options, "object", "rimraf: options should be object");
+ defaults(options);
+ var busyTries = 0;
+ var errState = null;
+ var n = 0;
+ if (options.disableGlob || !glob.hasMagic(p))
+ return afterGlob(null, [p]);
+ options.lstat(p, function(er, stat3) {
+ if (!er)
+ return afterGlob(null, [p]);
+ glob(p, options.glob, afterGlob);
+ });
+ function next(er) {
+ errState = errState || er;
+ if (--n === 0)
+ cb(errState);
+ }
+ function afterGlob(er, results) {
+ if (er)
+ return cb(er);
+ n = results.length;
+ if (n === 0)
+ return cb();
+ results.forEach(function(p2) {
+ rimraf_(p2, options, function CB(er2) {
+ if (er2) {
+ if ((er2.code === "EBUSY" || er2.code === "ENOTEMPTY" || er2.code === "EPERM") && busyTries < options.maxBusyTries) {
+ busyTries++;
+ var time = busyTries * 100;
+ return setTimeout(function() {
+ rimraf_(p2, options, CB);
+ }, time);
+ }
+ if (er2.code === "EMFILE" && timeout < options.emfileWait) {
+ return setTimeout(function() {
+ rimraf_(p2, options, CB);
+ }, timeout++);
+ }
+ if (er2.code === "ENOENT")
+ er2 = null;
+ }
+ timeout = 0;
+ next(er2);
+ });
+ });
+ }
+ }
+ function rimraf_(p, options, cb) {
+ assert(p);
+ assert(options);
+ assert(typeof cb === "function");
+ options.lstat(p, function(er, st) {
+ if (er && er.code === "ENOENT")
+ return cb(null);
+ if (er && er.code === "EPERM" && isWindows)
+ fixWinEPERM(p, options, er, cb);
+ if (st && st.isDirectory())
+ return rmdir(p, options, er, cb);
+ options.unlink(p, function(er2) {
+ if (er2) {
+ if (er2.code === "ENOENT")
+ return cb(null);
+ if (er2.code === "EPERM")
+ return isWindows ? fixWinEPERM(p, options, er2, cb) : rmdir(p, options, er2, cb);
+ if (er2.code === "EISDIR")
+ return rmdir(p, options, er2, cb);
+ }
+ return cb(er2);
+ });
+ });
+ }
+ function fixWinEPERM(p, options, er, cb) {
+ assert(p);
+ assert(options);
+ assert(typeof cb === "function");
+ if (er)
+ assert(er instanceof Error);
+ options.chmod(p, _0666, function(er2) {
+ if (er2)
+ cb(er2.code === "ENOENT" ? null : er);
+ else
+ options.stat(p, function(er3, stats) {
+ if (er3)
+ cb(er3.code === "ENOENT" ? null : er);
+ else if (stats.isDirectory())
+ rmdir(p, options, er, cb);
+ else
+ options.unlink(p, cb);
+ });
+ });
+ }
+ function fixWinEPERMSync(p, options, er) {
+ assert(p);
+ assert(options);
+ if (er)
+ assert(er instanceof Error);
+ try {
+ options.chmodSync(p, _0666);
+ } catch (er2) {
+ if (er2.code === "ENOENT")
+ return;
+ else
+ throw er;
+ }
+ try {
+ var stats = options.statSync(p);
+ } catch (er3) {
+ if (er3.code === "ENOENT")
+ return;
+ else
+ throw er;
+ }
+ if (stats.isDirectory())
+ rmdirSync(p, options, er);
+ else
+ options.unlinkSync(p);
+ }
+ function rmdir(p, options, originalEr, cb) {
+ assert(p);
+ assert(options);
+ if (originalEr)
+ assert(originalEr instanceof Error);
+ assert(typeof cb === "function");
+ options.rmdir(p, function(er) {
+ if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM"))
+ rmkids(p, options, cb);
+ else if (er && er.code === "ENOTDIR")
+ cb(originalEr);
+ else
+ cb(er);
+ });
+ }
+ function rmkids(p, options, cb) {
+ assert(p);
+ assert(options);
+ assert(typeof cb === "function");
+ options.readdir(p, function(er, files) {
+ if (er)
+ return cb(er);
+ var n = files.length;
+ if (n === 0)
+ return options.rmdir(p, cb);
+ var errState;
+ files.forEach(function(f) {
+ rimraf(path5.join(p, f), options, function(er2) {
+ if (errState)
+ return;
+ if (er2)
+ return cb(errState = er2);
+ if (--n === 0)
+ options.rmdir(p, cb);
+ });
+ });
+ });
+ }
+ function rimrafSync(p, options) {
+ options = options || {};
+ defaults(options);
+ assert(p, "rimraf: missing path");
+ assert.equal(typeof p, "string", "rimraf: path should be a string");
+ assert(options, "rimraf: missing options");
+ assert.equal(typeof options, "object", "rimraf: options should be object");
+ var results;
+ if (options.disableGlob || !glob.hasMagic(p)) {
+ results = [p];
+ } else {
+ try {
+ options.lstatSync(p);
+ results = [p];
+ } catch (er) {
+ results = glob.sync(p, options.glob);
+ }
+ }
+ if (!results.length)
+ return;
+ for (var i = 0; i < results.length; i++) {
+ var p = results[i];
+ try {
+ var st = options.lstatSync(p);
+ } catch (er) {
+ if (er.code === "ENOENT")
+ return;
+ if (er.code === "EPERM" && isWindows)
+ fixWinEPERMSync(p, options, er);
+ }
+ try {
+ if (st && st.isDirectory())
+ rmdirSync(p, options, null);
+ else
+ options.unlinkSync(p);
+ } catch (er) {
+ if (er.code === "ENOENT")
+ return;
+ if (er.code === "EPERM")
+ return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er);
+ if (er.code !== "EISDIR")
+ throw er;
+ rmdirSync(p, options, er);
+ }
+ }
+ }
+ function rmdirSync(p, options, originalEr) {
+ assert(p);
+ assert(options);
+ if (originalEr)
+ assert(originalEr instanceof Error);
+ try {
+ options.rmdirSync(p);
+ } catch (er) {
+ if (er.code === "ENOENT")
+ return;
+ if (er.code === "ENOTDIR")
+ throw originalEr;
+ if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")
+ rmkidsSync(p, options);
+ }
+ }
+ function rmkidsSync(p, options) {
+ assert(p);
+ assert(options);
+ options.readdirSync(p).forEach(function(f) {
+ rimrafSync(path5.join(p, f), options);
+ });
+ var retries = isWindows ? 100 : 1;
+ var i = 0;
+ do {
+ var threw = true;
+ try {
+ var ret = options.rmdirSync(p, options);
+ threw = false;
+ return ret;
+ } finally {
+ if (++i < retries && threw)
+ continue;
+ }
+ } while (true);
+ }
+ }
+});
+
+// node_modules/mkdirp/index.js
+var require_mkdirp = __commonJS({
+ "node_modules/mkdirp/index.js"(exports, module2) {
+ var path5 = require("path");
+ var fs5 = require("fs");
+ var _0777 = parseInt("0777", 8);
+ module2.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;
+ function mkdirP(p, opts, f, made) {
+ if (typeof opts === "function") {
+ f = opts;
+ opts = {};
+ } else if (!opts || typeof opts !== "object") {
+ opts = { mode: opts };
+ }
+ var mode = opts.mode;
+ var xfs = opts.fs || fs5;
+ if (mode === void 0) {
+ mode = _0777;
+ }
+ if (!made)
+ made = null;
+ var cb = f || function() {
+ };
+ p = path5.resolve(p);
+ xfs.mkdir(p, mode, function(er) {
+ if (!er) {
+ made = made || p;
+ return cb(null, made);
+ }
+ switch (er.code) {
+ case "ENOENT":
+ if (path5.dirname(p) === p)
+ return cb(er);
+ mkdirP(path5.dirname(p), opts, function(er2, made2) {
+ if (er2)
+ cb(er2, made2);
+ else
+ mkdirP(p, opts, cb, made2);
+ });
+ break;
+ default:
+ xfs.stat(p, function(er2, stat3) {
+ if (er2 || !stat3.isDirectory())
+ cb(er, made);
+ else
+ cb(null, made);
+ });
+ break;
+ }
+ });
+ }
+ mkdirP.sync = function sync(p, opts, made) {
+ if (!opts || typeof opts !== "object") {
+ opts = { mode: opts };
+ }
+ var mode = opts.mode;
+ var xfs = opts.fs || fs5;
+ if (mode === void 0) {
+ mode = _0777;
+ }
+ if (!made)
+ made = null;
+ p = path5.resolve(p);
+ try {
+ xfs.mkdirSync(p, mode);
+ made = made || p;
+ } catch (err0) {
+ switch (err0.code) {
+ case "ENOENT":
+ made = sync(path5.dirname(p), opts, made);
+ sync(p, opts, made);
+ break;
+ default:
+ var stat3;
+ try {
+ stat3 = xfs.statSync(p);
+ } catch (err1) {
+ throw err0;
+ }
+ if (!stat3.isDirectory())
+ throw err0;
+ break;
+ }
+ }
+ return made;
+ };
+ }
+});
+
+// node_modules/temp/lib/temp.js
+var require_temp = __commonJS({
+ "node_modules/temp/lib/temp.js"(exports, module2) {
+ var fs5 = require("fs");
+ var path5 = require("path");
+ var cnst = require("constants");
+ var os = require("os");
+ var rimraf = require_rimraf();
+ var mkdirp = require_mkdirp();
+ var osTmpdir = require("os").tmpdir();
+ var rimrafSync = rimraf.sync;
+ var dir = path5.resolve(os.tmpdir());
+ var RDWR_EXCL = cnst.O_CREAT | cnst.O_TRUNC | cnst.O_RDWR | cnst.O_EXCL;
+ var promisify = function(callback) {
+ if (typeof callback === "function") {
+ return [void 0, callback];
+ }
+ var promiseCallback;
+ var promise = new Promise(function(resolve, reject) {
+ promiseCallback = function() {
+ var args = Array.from(arguments);
+ var err = args.shift();
+ process.nextTick(function() {
+ if (err) {
+ reject(err);
+ } else if (args.length === 1) {
+ resolve(args[0]);
+ } else {
+ resolve(args);
+ }
+ });
+ };
+ });
+ return [promise, promiseCallback];
+ };
+ var generateName = function(rawAffixes, defaultPrefix) {
+ var affixes = parseAffixes(rawAffixes, defaultPrefix);
+ var now = new Date();
+ var name = [
+ affixes.prefix,
+ now.getFullYear(),
+ now.getMonth(),
+ now.getDate(),
+ "-",
+ process.pid,
+ "-",
+ (Math.random() * 4294967296 + 1).toString(36),
+ affixes.suffix
+ ].join("");
+ return path5.join(affixes.dir || dir, name);
+ };
+ var parseAffixes = function(rawAffixes, defaultPrefix) {
+ var affixes = { prefix: null, suffix: null };
+ if (rawAffixes) {
+ switch (typeof rawAffixes) {
+ case "string":
+ affixes.prefix = rawAffixes;
+ break;
+ case "object":
+ affixes = rawAffixes;
+ break;
+ default:
+ throw new Error("Unknown affix declaration: " + affixes);
+ }
+ } else {
+ affixes.prefix = defaultPrefix;
+ }
+ return affixes;
+ };
+ var tracking = false;
+ var track = function(value) {
+ tracking = value !== false;
+ return module2.exports;
+ };
+ var exitListenerAttached = false;
+ var filesToDelete = [];
+ var dirsToDelete = [];
+ function deleteFileOnExit(filePath) {
+ if (!tracking)
+ return false;
+ attachExitListener();
+ filesToDelete.push(filePath);
+ }
+ function deleteDirOnExit(dirPath) {
+ if (!tracking)
+ return false;
+ attachExitListener();
+ dirsToDelete.push(dirPath);
+ }
+ function attachExitListener() {
+ if (!tracking)
+ return false;
+ if (!exitListenerAttached) {
+ process.addListener("exit", function() {
+ try {
+ cleanupSync();
+ } catch (err) {
+ console.warn("Fail to clean temporary files on exit : ", err);
+ throw err;
+ }
+ });
+ exitListenerAttached = true;
+ }
+ }
+ function cleanupFilesSync() {
+ if (!tracking) {
+ return false;
+ }
+ var count = 0;
+ var toDelete;
+ while ((toDelete = filesToDelete.shift()) !== void 0) {
+ rimrafSync(toDelete, { maxBusyTries: 6 });
+ count++;
+ }
+ return count;
+ }
+ function cleanupFiles(callback) {
+ var p = promisify(callback);
+ var promise = p[0];
+ callback = p[1];
+ if (!tracking) {
+ callback(new Error("not tracking"));
+ return promise;
+ }
+ var count = 0;
+ var left = filesToDelete.length;
+ if (!left) {
+ callback(null, count);
+ return promise;
+ }
+ var toDelete;
+ var rimrafCallback = function(err) {
+ if (!left) {
+ return;
+ }
+ if (err) {
+ callback(err);
+ left = 0;
+ return;
+ } else {
+ count++;
+ }
+ left--;
+ if (!left) {
+ callback(null, count);
+ }
+ };
+ while ((toDelete = filesToDelete.shift()) !== void 0) {
+ rimraf(toDelete, { maxBusyTries: 6 }, rimrafCallback);
+ }
+ return promise;
+ }
+ function cleanupDirsSync() {
+ if (!tracking) {
+ return false;
+ }
+ var count = 0;
+ var toDelete;
+ while ((toDelete = dirsToDelete.shift()) !== void 0) {
+ rimrafSync(toDelete, { maxBusyTries: 6 });
+ count++;
+ }
+ return count;
+ }
+ function cleanupDirs(callback) {
+ var p = promisify(callback);
+ var promise = p[0];
+ callback = p[1];
+ if (!tracking) {
+ callback(new Error("not tracking"));
+ return promise;
+ }
+ var count = 0;
+ var left = dirsToDelete.length;
+ if (!left) {
+ callback(null, count);
+ return promise;
+ }
+ var toDelete;
+ var rimrafCallback = function(err) {
+ if (!left) {
+ return;
+ }
+ if (err) {
+ callback(err, count);
+ left = 0;
+ return;
+ } else {
+ count++;
+ }
+ left--;
+ if (!left) {
+ callback(null, count);
+ }
+ };
+ while ((toDelete = dirsToDelete.shift()) !== void 0) {
+ rimraf(toDelete, { maxBusyTries: 6 }, rimrafCallback);
+ }
+ return promise;
+ }
+ function cleanupSync() {
+ if (!tracking) {
+ return false;
+ }
+ var fileCount = cleanupFilesSync();
+ var dirCount = cleanupDirsSync();
+ return { files: fileCount, dirs: dirCount };
+ }
+ function cleanup(callback) {
+ var p = promisify(callback);
+ var promise = p[0];
+ callback = p[1];
+ if (!tracking) {
+ callback(new Error("not tracking"));
+ return promise;
+ }
+ cleanupFiles(function(fileErr, fileCount) {
+ if (fileErr) {
+ callback(fileErr, { files: fileCount });
+ } else {
+ cleanupDirs(function(dirErr, dirCount) {
+ callback(dirErr, { files: fileCount, dirs: dirCount });
+ });
+ }
+ });
+ return promise;
+ }
+ var mkdir = (affixes, callback) => {
+ const p = promisify(callback);
+ const promise = p[0];
+ callback = p[1];
+ let dirPath = generateName(affixes, "d-");
+ mkdirp(dirPath, 448, (err) => {
+ if (!err) {
+ deleteDirOnExit(dirPath);
+ }
+ callback(err, dirPath);
+ });
+ return promise;
+ };
+ var mkdirSync = (affixes) => {
+ let dirPath = generateName(affixes, "d-");
+ mkdirp.sync(dirPath, 448);
+ deleteDirOnExit(dirPath);
+ return dirPath;
+ };
+ var open = (affixes, callback) => {
+ const p = promisify(callback);
+ const promise = p[0];
+ callback = p[1];
+ const path6 = generateName(affixes, "f-");
+ fs5.open(path6, RDWR_EXCL, 384, (err, fd) => {
+ if (!err) {
+ deleteFileOnExit(path6);
+ }
+ callback(err, { path: path6, fd });
+ });
+ return promise;
+ };
+ var openSync = (affixes) => {
+ const path6 = generateName(affixes, "f-");
+ let fd = fs5.openSync(path6, RDWR_EXCL, 384);
+ deleteFileOnExit(path6);
+ return { path: path6, fd };
+ };
+ var createWriteStream = (affixes) => {
+ const path6 = generateName(affixes, "s-");
+ let stream = fs5.createWriteStream(path6, { flags: RDWR_EXCL, mode: 384 });
+ deleteFileOnExit(path6);
+ return stream;
+ };
+ exports.dir = dir;
+ exports.track = track;
+ exports.mkdir = mkdir;
+ exports.mkdirSync = mkdirSync;
+ exports.open = open;
+ exports.openSync = openSync;
+ exports.path = generateName;
+ exports.cleanup = cleanup;
+ exports.cleanupSync = cleanupSync;
+ exports.createWriteStream = createWriteStream;
+ }
+});
+
+// main.ts
+__export(exports, {
+ default: () => PandocPlugin
+});
+var fs4 = __toModule(require("fs"));
+var path3 = __toModule(require("path"));
+var import_obsidian3 = __toModule(require("obsidian"));
+var import_lookpath2 = __toModule(require_lib());
+
+// pandoc.ts
+var import_fs = __toModule(require("fs"));
+var import_child_process = __toModule(require("child_process"));
+var path = __toModule(require("path"));
+var fs = __toModule(require("fs"));
+var import_lookpath = __toModule(require_lib());
+var inputExtensions = ["md", "docx", "csv", "html", "tex", "odt"];
+var outputFormats = [
+ ["AsciiDoc (adoc)", "asciidoc", "adoc", "AsciiDoc"],
+ ["Word Document (docx)", "docx", "docx", "Word"],
+ ["Pandoc Markdown", "markdown", "pandoc.md", "markdown"],
+ ["HTML (without Pandoc)", "html", "html", "HTML"],
+ ["LaTeX", "latex", "tex", "LaTeX"],
+ ["OpenDocument (odt)", "odt", "odt", "OpenDocument"],
+ ["PowerPoint (pptx)", "pptx", "pptx", "PowerPoint"],
+ ["ePub", "epub", "epub", "ePub"],
+ ["PDF (via LaTeX)", "pdf", "pdf", "PDF"],
+ ["Reveal.js Slides", "revealjs", "reveal.html", "Reveal.js"],
+ ["Beamer Slides", "beamer", "beamer.tex", "Beamer"],
+ ["reStructured Text (RST)", "rst", "rst", "RST"],
+ ["DokuWiki", "dokuwiki", "txt", "DokuWiki"],
+ ["MediaWiki", "mediawiki", "mediawiki", "MediaWiki"]
+];
+function needsLaTeX(format) {
+ return format === "pdf";
+}
+function needsPandoc(format) {
+ return format !== "html";
+}
+function needsStandaloneFlag(output) {
+ return output.file.endsWith("html") || output.format === "html" || output.format === "revealjs" || output.format === "latex" || output.format === "beamer";
+}
+var pandoc = (input, output, extraParams) => __async(void 0, null, function* () {
+ return new Promise((resolve, reject) => __async(void 0, null, function* () {
+ const stdin = input.file === "STDIN";
+ const stdout = output.file === "STDOUT";
+ let pandoc2;
+ let result = "";
+ let error = "";
+ const fileBaseName2 = (file) => path.basename(file, path.extname(file));
+ let args = [];
+ if (input.format) {
+ args.push("--from");
+ args.push(input.format);
+ }
+ if (output.format) {
+ args.push("--to");
+ args.push(output.format);
+ }
+ if (needsStandaloneFlag(output))
+ args.push("-s");
+ if (!stdout) {
+ args.push("-o");
+ args.push(output.file);
+ } else {
+ args.push("-o");
+ args.push("-");
+ }
+ if (output.format === "pdf" && (yield (0, import_lookpath.lookpath)("xelatex")))
+ args.push("--pdf-engine=xelatex");
+ if (!stdin) {
+ args.push(input.file);
+ }
+ if (input.metadataFile)
+ args.push("--metadata-file", input.metadataFile);
+ if (extraParams) {
+ extraParams = extraParams.flatMap((x) => x.split(" ")).filter((x) => x.length);
+ args.push(...extraParams);
+ }
+ function start() {
+ if (input.pdflatex) {
+ if (process.platform === "win32")
+ process.env.PATH += ";";
+ else
+ process.env.PATH += ":";
+ process.env.PATH += path.dirname(input.pdflatex);
+ }
+ pandoc2 = (0, import_child_process.spawn)(input.pandoc || "pandoc", args, { env: process.env, cwd: input.directory });
+ if (stdin) {
+ const contents = input.contents.replace(/[\u21a9\ufe0e]/g, "");
+ pandoc2.stdin.write(contents);
+ pandoc2.stdin.end();
+ }
+ pandoc2.stdout.on("data", (data) => {
+ result += data;
+ });
+ pandoc2.stderr.on("data", (err) => {
+ error += err;
+ });
+ pandoc2.stdout.on("end", () => {
+ const value = {
+ result,
+ error,
+ command: "pandoc " + args.join(" ")
+ };
+ if (output.file !== "STDOUT") {
+ fs.stat(output.file, (err, stats) => {
+ if (stats && stats.isFile()) {
+ resolve(value);
+ } else {
+ reject(error);
+ }
+ });
+ } else {
+ (result.length ? resolve : reject)(value);
+ if (result.length) {
+ resolve(value);
+ } else {
+ reject(error);
+ }
+ }
+ });
+ }
+ if (input.file === "STDIN") {
+ start();
+ } else {
+ (0, import_fs.stat)(input.file, (err, stats) => {
+ if (stats.isFile())
+ start();
+ else
+ reject(new Error("Input file does not exist"));
+ });
+ }
+ }));
+});
+
+// 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, path5) {
+ const ctrl = callVisitor(key, node, visitor, path5);
+ if (isNode(ctrl) || isPair(ctrl)) {
+ replaceNode(key, path5, ctrl);
+ return visit_(key, ctrl, visitor, path5);
+ }
+ if (typeof ctrl !== "symbol") {
+ if (isCollection(node)) {
+ path5 = Object.freeze(path5.concat(node));
+ for (let i = 0; i < node.items.length; ++i) {
+ const ci = visit_(i, node.items[i], visitor, path5);
+ 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)) {
+ path5 = Object.freeze(path5.concat(node));
+ const ck = visit_("key", node.key, visitor, path5);
+ if (ck === BREAK)
+ return BREAK;
+ else if (ck === REMOVE)
+ node.key = null;
+ const cv = visit_("value", node.value, visitor, path5);
+ 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, path5) {
+ return __async(this, null, function* () {
+ const ctrl = yield callVisitor(key, node, visitor, path5);
+ if (isNode(ctrl) || isPair(ctrl)) {
+ replaceNode(key, path5, ctrl);
+ return visitAsync_(key, ctrl, visitor, path5);
+ }
+ if (typeof ctrl !== "symbol") {
+ if (isCollection(node)) {
+ path5 = Object.freeze(path5.concat(node));
+ for (let i = 0; i < node.items.length; ++i) {
+ const ci = yield visitAsync_(i, node.items[i], visitor, path5);
+ 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)) {
+ path5 = Object.freeze(path5.concat(node));
+ const ck = yield visitAsync_("key", node.key, visitor, path5);
+ if (ck === BREAK)
+ return BREAK;
+ else if (ck === REMOVE)
+ node.key = null;
+ const cv = yield visitAsync_("value", node.value, visitor, path5);
+ 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, path5) {
+ var _a, _b, _c, _d, _e;
+ if (typeof visitor === "function")
+ return visitor(key, node, path5);
+ if (isMap(node))
+ return (_a = visitor.Map) == null ? void 0 : _a.call(visitor, key, node, path5);
+ if (isSeq(node))
+ return (_b = visitor.Seq) == null ? void 0 : _b.call(visitor, key, node, path5);
+ if (isPair(node))
+ return (_c = visitor.Pair) == null ? void 0 : _c.call(visitor, key, node, path5);
+ if (isScalar(node))
+ return (_d = visitor.Scalar) == null ? void 0 : _d.call(visitor, key, node, path5);
+ if (isAlias(node))
+ return (_e = visitor.Alias) == null ? void 0 : _e.call(visitor, key, node, path5);
+ return void 0;
+}
+function replaceNode(key, path5, node) {
+ const parent = path5[path5.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(yaml, tags) {
+ this.docStart = null;
+ this.docEnd = false;
+ this.yaml = Object.assign({}, Directives.defaultYaml, yaml);
+ 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 [version2] = parts;
+ if (version2 === "1.1" || version2 === "1.2") {
+ this.yaml.version = version2;
+ return true;
+ } else {
+ const isValid2 = /^\d+\.\d+$/.test(version2);
+ onError(6, `Unsupported YAML version ${version2}`, isValid2);
+ 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, path5, value) {
+ let v = value;
+ for (let i = path5.length - 1; i >= 0; --i) {
+ const k = path5[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 = (path5) => path5 == null || typeof path5 === "object" && !!path5[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(path5, value) {
+ if (isEmptyPath(path5))
+ this.add(value);
+ else {
+ const [key, ...rest] = path5;
+ 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(path5) {
+ const [key, ...rest] = path5;
+ 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(path5, keepScalar) {
+ const [key, ...rest] = path5;
+ 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(path5) {
+ const [key, ...rest] = path5;
+ if (rest.length === 0)
+ return this.has(key);
+ const node = this.get(key, true);
+ return isCollection(node) ? node.hasIn(rest) : false;
+ }
+ setIn(path5, value) {
+ const [key, ...rest] = path5;
+ 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 body2 = foldFlowLines(`${start}${value}${end}`, indent, FOLD_BLOCK, getFoldOptions(ctx));
+ return `${header}
+${indent}${body2}`;
+}
+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 body2 = stringify(doc.contents, ctx, () => contentComment = null, onChompKeep);
+ if (contentComment)
+ body2 += lineComment(body2, "", commentString(contentComment));
+ if ((body2[0] === "|" || body2[0] === ">") && lines[lines.length - 1] === "---") {
+ lines[lines.length - 1] = `--- ${body2}`;
+ } else
+ lines.push(body2);
+ } 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: version2 } = opt;
+ if (options == null ? void 0 : options._directives) {
+ this.directives = options._directives.atDocument();
+ if (this.directives.yaml.explicit)
+ version2 = this.directives.yaml.version;
+ } else
+ this.directives = new Directives({ version: version2 });
+ this.setSchema(version2, 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(path5, value) {
+ if (assertCollection(this.contents))
+ this.contents.addIn(path5, 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(path5) {
+ if (isEmptyPath(path5)) {
+ if (this.contents == null)
+ return false;
+ this.contents = null;
+ return true;
+ }
+ return assertCollection(this.contents) ? this.contents.deleteIn(path5) : false;
+ }
+ get(key, keepScalar) {
+ return isCollection(this.contents) ? this.contents.get(key, keepScalar) : void 0;
+ }
+ getIn(path5, keepScalar) {
+ if (isEmptyPath(path5))
+ return !keepScalar && isScalar(this.contents) ? this.contents.value : this.contents;
+ return isCollection(this.contents) ? this.contents.getIn(path5, keepScalar) : void 0;
+ }
+ has(key) {
+ return isCollection(this.contents) ? this.contents.has(key) : false;
+ }
+ hasIn(path5) {
+ if (isEmptyPath(path5))
+ return this.contents !== void 0;
+ return isCollection(this.contents) ? this.contents.hasIn(path5) : 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(path5, value) {
+ if (isEmptyPath(path5))
+ this.contents = value;
+ else if (this.contents == null) {
+ this.contents = collectionFromPath(this.schema, Array.from(path5), value);
+ } else if (assertCollection(this.contents)) {
+ this.contents.setIn(path5, value);
+ }
+ }
+ setSchema(version2, options = {}) {
+ if (typeof version2 === "number")
+ version2 = String(version2);
+ let opt;
+ switch (version2) {
+ 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 = version2;
+ else
+ this.directives = new Directives({ version: version2 });
+ opt = { merge: false, resolveKnownTags: true, schema: "core" };
+ break;
+ case null:
+ if (this.directives)
+ delete this.directives;
+ opt = null;
+ break;
+ default: {
+ const sv = JSON.stringify(version2);
+ 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/errors.js
+var YAMLError = class extends Error {
+ constructor(name, pos, code, message) {
+ super();
+ this.name = name;
+ this.code = code;
+ this.message = message;
+ this.pos = pos;
+ }
+};
+var YAMLParseError = class extends YAMLError {
+ constructor(pos, code, message) {
+ super("YAMLParseError", pos, code, message);
+ }
+};
+var YAMLWarning = class extends YAMLError {
+ constructor(pos, code, message) {
+ super("YAMLWarning", pos, code, message);
+ }
+};
+var prettifyError = (src, lc) => (error) => {
+ if (error.pos[0] === -1)
+ return;
+ error.linePos = error.pos.map((pos) => lc.linePos(pos));
+ const { line, col } = error.linePos[0];
+ error.message += ` at line ${line}, column ${col}`;
+ let ci = col - 1;
+ let lineStr = src.substring(lc.lineStarts[line - 1], lc.lineStarts[line]).replace(/[\n\r]+$/, "");
+ if (ci >= 60 && lineStr.length > 80) {
+ const trimStart = Math.min(ci - 39, lineStr.length - 79);
+ lineStr = "\u2026" + lineStr.substring(trimStart);
+ ci -= trimStart - 1;
+ }
+ if (lineStr.length > 80)
+ lineStr = lineStr.substring(0, 79) + "\u2026";
+ if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {
+ let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);
+ if (prev.length > 80)
+ prev = prev.substring(0, 79) + "\u2026\n";
+ lineStr = prev + lineStr;
+ }
+ if (/[^ ]/.test(lineStr)) {
+ let count = 1;
+ const end = error.linePos[1];
+ if (end && end.line === line && end.col > col) {
+ count = Math.min(end.col - col, 80 - ci);
+ }
+ const pointer = " ".repeat(ci) + "^".repeat(count);
+ error.message += `:
+
+${lineStr}
+${pointer}
+`;
+ }
+};
+
+// node_modules/yaml/browser/dist/compose/resolve-props.js
+function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnNewline }) {
+ let spaceBefore = false;
+ let atNewline = startOnNewline;
+ let hasSpace = startOnNewline;
+ let comment = "";
+ let commentSep = "";
+ let hasNewline = false;
+ let hasNewlineAfterProp = false;
+ let reqSpace = false;
+ let anchor = null;
+ let tag = null;
+ let comma = null;
+ let found = null;
+ let start = null;
+ for (const token of tokens) {
+ if (reqSpace) {
+ if (token.type !== "space" && token.type !== "newline" && token.type !== "comma")
+ onError(token.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space");
+ reqSpace = false;
+ }
+ switch (token.type) {
+ case "space":
+ if (!flow && atNewline && indicator !== "doc-start" && token.source[0] === " ")
+ onError(token, "TAB_AS_INDENT", "Tabs are not allowed as indentation");
+ hasSpace = true;
+ break;
+ case "comment": {
+ if (!hasSpace)
+ onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
+ const cb = token.source.substring(1) || " ";
+ if (!comment)
+ comment = cb;
+ else
+ comment += commentSep + cb;
+ commentSep = "";
+ atNewline = false;
+ break;
+ }
+ case "newline":
+ if (atNewline) {
+ if (comment)
+ comment += token.source;
+ else
+ spaceBefore = true;
+ } else
+ commentSep += token.source;
+ atNewline = true;
+ hasNewline = true;
+ if (anchor || tag)
+ hasNewlineAfterProp = true;
+ hasSpace = true;
+ break;
+ case "anchor":
+ if (anchor)
+ onError(token, "MULTIPLE_ANCHORS", "A node can have at most one anchor");
+ if (token.source.endsWith(":"))
+ onError(token.offset + token.source.length - 1, "BAD_ALIAS", "Anchor ending in : is ambiguous", true);
+ anchor = token;
+ if (start === null)
+ start = token.offset;
+ atNewline = false;
+ hasSpace = false;
+ reqSpace = true;
+ break;
+ case "tag": {
+ if (tag)
+ onError(token, "MULTIPLE_TAGS", "A node can have at most one tag");
+ tag = token;
+ if (start === null)
+ start = token.offset;
+ atNewline = false;
+ hasSpace = false;
+ reqSpace = true;
+ break;
+ }
+ case indicator:
+ if (anchor || tag)
+ onError(token, "BAD_PROP_ORDER", `Anchors and tags must be after the ${token.source} indicator`);
+ if (found)
+ onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.source} in ${flow != null ? flow : "collection"}`);
+ found = token;
+ atNewline = false;
+ hasSpace = false;
+ break;
+ case "comma":
+ if (flow) {
+ if (comma)
+ onError(token, "UNEXPECTED_TOKEN", `Unexpected , in ${flow}`);
+ comma = token;
+ atNewline = false;
+ hasSpace = false;
+ break;
+ }
+ default:
+ onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.type} token`);
+ atNewline = false;
+ hasSpace = false;
+ }
+ }
+ const last = tokens[tokens.length - 1];
+ const end = last ? last.offset + last.source.length : offset;
+ if (reqSpace && next && next.type !== "space" && next.type !== "newline" && next.type !== "comma" && (next.type !== "scalar" || next.source !== ""))
+ onError(next.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space");
+ return {
+ comma,
+ found,
+ spaceBefore,
+ comment,
+ hasNewline,
+ hasNewlineAfterProp,
+ anchor,
+ tag,
+ end,
+ start: start != null ? start : end
+ };
+}
+
+// node_modules/yaml/browser/dist/compose/util-contains-newline.js
+function containsNewline(key) {
+ if (!key)
+ return null;
+ switch (key.type) {
+ case "alias":
+ case "scalar":
+ case "double-quoted-scalar":
+ case "single-quoted-scalar":
+ if (key.source.includes("\n"))
+ return true;
+ if (key.end) {
+ for (const st of key.end)
+ if (st.type === "newline")
+ return true;
+ }
+ return false;
+ case "flow-collection":
+ for (const it of key.items) {
+ for (const st of it.start)
+ if (st.type === "newline")
+ return true;
+ if (it.sep) {
+ for (const st of it.sep)
+ if (st.type === "newline")
+ return true;
+ }
+ if (containsNewline(it.key) || containsNewline(it.value))
+ return true;
+ }
+ return false;
+ default:
+ return true;
+ }
+}
+
+// node_modules/yaml/browser/dist/compose/util-flow-indent-check.js
+function flowIndentCheck(indent, fc, onError) {
+ if ((fc == null ? void 0 : fc.type) === "flow-collection") {
+ const end = fc.end[0];
+ if (end.indent === indent && (end.source === "]" || end.source === "}") && containsNewline(fc)) {
+ const msg = "Flow end indicator should be more indented than parent";
+ onError(end, "BAD_INDENT", msg, true);
+ }
+ }
+}
+
+// node_modules/yaml/browser/dist/compose/util-map-includes.js
+function mapIncludes(ctx, items, search) {
+ const { uniqueKeys } = ctx.options;
+ if (uniqueKeys === false)
+ return false;
+ const isEqual = typeof uniqueKeys === "function" ? uniqueKeys : (a, b) => a === b || isScalar(a) && isScalar(b) && a.value === b.value && !(a.value === "<<" && ctx.schema.merge);
+ return items.some((pair) => isEqual(pair.key, search));
+}
+
+// node_modules/yaml/browser/dist/compose/resolve-block-map.js
+var startColMsg = "All mapping items must start at the same column";
+function resolveBlockMap({ composeNode: composeNode2, composeEmptyNode: composeEmptyNode2 }, ctx, bm, onError) {
+ var _a;
+ const map2 = new YAMLMap(ctx.schema);
+ if (ctx.atRoot)
+ ctx.atRoot = false;
+ let offset = bm.offset;
+ for (const collItem of bm.items) {
+ const { start, key, sep, value } = collItem;
+ const keyProps = resolveProps(start, {
+ indicator: "explicit-key-ind",
+ next: key != null ? key : sep == null ? void 0 : sep[0],
+ offset,
+ onError,
+ startOnNewline: true
+ });
+ const implicitKey = !keyProps.found;
+ if (implicitKey) {
+ if (key) {
+ if (key.type === "block-seq")
+ onError(offset, "BLOCK_AS_IMPLICIT_KEY", "A block sequence may not be used as an implicit map key");
+ else if ("indent" in key && key.indent !== bm.indent)
+ onError(offset, "BAD_INDENT", startColMsg);
+ }
+ if (!keyProps.anchor && !keyProps.tag && !sep) {
+ if (keyProps.comment) {
+ if (map2.comment)
+ map2.comment += "\n" + keyProps.comment;
+ else
+ map2.comment = keyProps.comment;
+ }
+ continue;
+ }
+ if (keyProps.hasNewlineAfterProp || containsNewline(key)) {
+ onError(key != null ? key : start[start.length - 1], "MULTILINE_IMPLICIT_KEY", "Implicit keys need to be on a single line");
+ }
+ } else if (((_a = keyProps.found) == null ? void 0 : _a.indent) !== bm.indent) {
+ onError(offset, "BAD_INDENT", startColMsg);
+ }
+ const keyStart = keyProps.end;
+ const keyNode = key ? composeNode2(ctx, key, keyProps, onError) : composeEmptyNode2(ctx, keyStart, start, null, keyProps, onError);
+ if (ctx.schema.compat)
+ flowIndentCheck(bm.indent, key, onError);
+ if (mapIncludes(ctx, map2.items, keyNode))
+ onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
+ const valueProps = resolveProps(sep != null ? sep : [], {
+ indicator: "map-value-ind",
+ next: value,
+ offset: keyNode.range[2],
+ onError,
+ startOnNewline: !key || key.type === "block-scalar"
+ });
+ offset = valueProps.end;
+ if (valueProps.found) {
+ if (implicitKey) {
+ if ((value == null ? void 0 : value.type) === "block-map" && !valueProps.hasNewline)
+ onError(offset, "BLOCK_AS_IMPLICIT_KEY", "Nested mappings are not allowed in compact mappings");
+ if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
+ onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
+ }
+ const valueNode = value ? composeNode2(ctx, value, valueProps, onError) : composeEmptyNode2(ctx, offset, sep, null, valueProps, onError);
+ if (ctx.schema.compat)
+ flowIndentCheck(bm.indent, value, onError);
+ offset = valueNode.range[2];
+ const pair = new Pair(keyNode, valueNode);
+ if (ctx.options.keepSourceTokens)
+ pair.srcToken = collItem;
+ map2.items.push(pair);
+ } else {
+ if (implicitKey)
+ onError(keyNode.range, "MISSING_CHAR", "Implicit map keys need to be followed by map values");
+ if (valueProps.comment) {
+ if (keyNode.comment)
+ keyNode.comment += "\n" + valueProps.comment;
+ else
+ keyNode.comment = valueProps.comment;
+ }
+ const pair = new Pair(keyNode);
+ if (ctx.options.keepSourceTokens)
+ pair.srcToken = collItem;
+ map2.items.push(pair);
+ }
+ }
+ map2.range = [bm.offset, offset, offset];
+ return map2;
+}
+
+// node_modules/yaml/browser/dist/compose/resolve-block-seq.js
+function resolveBlockSeq({ composeNode: composeNode2, composeEmptyNode: composeEmptyNode2 }, ctx, bs, onError) {
+ const seq2 = new YAMLSeq(ctx.schema);
+ if (ctx.atRoot)
+ ctx.atRoot = false;
+ let offset = bs.offset;
+ for (const { start, value } of bs.items) {
+ const props = resolveProps(start, {
+ indicator: "seq-item-ind",
+ next: value,
+ offset,
+ onError,
+ startOnNewline: true
+ });
+ offset = props.end;
+ if (!props.found) {
+ if (props.anchor || props.tag || value) {
+ if (value && value.type === "block-seq")
+ onError(offset, "BAD_INDENT", "All sequence items must start at the same column");
+ else
+ onError(offset, "MISSING_CHAR", "Sequence item without - indicator");
+ } else {
+ if (props.comment)
+ seq2.comment = props.comment;
+ continue;
+ }
+ }
+ const node = value ? composeNode2(ctx, value, props, onError) : composeEmptyNode2(ctx, offset, start, null, props, onError);
+ if (ctx.schema.compat)
+ flowIndentCheck(bs.indent, value, onError);
+ offset = node.range[2];
+ seq2.items.push(node);
+ }
+ seq2.range = [bs.offset, offset, offset];
+ return seq2;
+}
+
+// node_modules/yaml/browser/dist/compose/resolve-end.js
+function resolveEnd(end, offset, reqSpace, onError) {
+ let comment = "";
+ if (end) {
+ let hasSpace = false;
+ let sep = "";
+ for (const token of end) {
+ const { source, type } = token;
+ switch (type) {
+ case "space":
+ hasSpace = true;
+ break;
+ case "comment": {
+ if (reqSpace && !hasSpace)
+ onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
+ const cb = source.substring(1) || " ";
+ if (!comment)
+ comment = cb;
+ else
+ comment += sep + cb;
+ sep = "";
+ break;
+ }
+ case "newline":
+ if (comment)
+ sep += source;
+ hasSpace = true;
+ break;
+ default:
+ onError(token, "UNEXPECTED_TOKEN", `Unexpected ${type} at node end`);
+ }
+ offset += source.length;
+ }
+ }
+ return { comment, offset };
+}
+
+// node_modules/yaml/browser/dist/compose/resolve-flow-collection.js
+var blockMsg = "Block collections are not allowed within flow collections";
+var isBlock = (token) => token && (token.type === "block-map" || token.type === "block-seq");
+function resolveFlowCollection({ composeNode: composeNode2, composeEmptyNode: composeEmptyNode2 }, ctx, fc, onError) {
+ var _a;
+ const isMap2 = fc.start.source === "{";
+ const fcName = isMap2 ? "flow map" : "flow sequence";
+ const coll = isMap2 ? new YAMLMap(ctx.schema) : new YAMLSeq(ctx.schema);
+ coll.flow = true;
+ const atRoot = ctx.atRoot;
+ if (atRoot)
+ ctx.atRoot = false;
+ let offset = fc.offset + fc.start.source.length;
+ for (let i = 0; i < fc.items.length; ++i) {
+ const collItem = fc.items[i];
+ const { start, key, sep, value } = collItem;
+ const props = resolveProps(start, {
+ flow: fcName,
+ indicator: "explicit-key-ind",
+ next: key != null ? key : sep == null ? void 0 : sep[0],
+ offset,
+ onError,
+ startOnNewline: false
+ });
+ if (!props.found) {
+ if (!props.anchor && !props.tag && !sep && !value) {
+ if (i === 0 && props.comma)
+ onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
+ else if (i < fc.items.length - 1)
+ onError(props.start, "UNEXPECTED_TOKEN", `Unexpected empty item in ${fcName}`);
+ if (props.comment) {
+ if (coll.comment)
+ coll.comment += "\n" + props.comment;
+ else
+ coll.comment = props.comment;
+ }
+ offset = props.end;
+ continue;
+ }
+ if (!isMap2 && ctx.options.strict && containsNewline(key))
+ onError(key, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
+ }
+ if (i === 0) {
+ if (props.comma)
+ onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
+ } else {
+ if (!props.comma)
+ onError(props.start, "MISSING_CHAR", `Missing , between ${fcName} items`);
+ if (props.comment) {
+ let prevItemComment = "";
+ loop:
+ for (const st of start) {
+ switch (st.type) {
+ case "comma":
+ case "space":
+ break;
+ case "comment":
+ prevItemComment = st.source.substring(1);
+ break loop;
+ default:
+ break loop;
+ }
+ }
+ if (prevItemComment) {
+ let prev = coll.items[coll.items.length - 1];
+ if (isPair(prev))
+ prev = (_a = prev.value) != null ? _a : prev.key;
+ if (prev.comment)
+ prev.comment += "\n" + prevItemComment;
+ else
+ prev.comment = prevItemComment;
+ props.comment = props.comment.substring(prevItemComment.length + 1);
+ }
+ }
+ }
+ if (!isMap2 && !sep && !props.found) {
+ const valueNode = value ? composeNode2(ctx, value, props, onError) : composeEmptyNode2(ctx, props.end, sep, null, props, onError);
+ coll.items.push(valueNode);
+ offset = valueNode.range[2];
+ if (isBlock(value))
+ onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
+ } else {
+ const keyStart = props.end;
+ const keyNode = key ? composeNode2(ctx, key, props, onError) : composeEmptyNode2(ctx, keyStart, start, null, props, onError);
+ if (isBlock(key))
+ onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
+ const valueProps = resolveProps(sep != null ? sep : [], {
+ flow: fcName,
+ indicator: "map-value-ind",
+ next: value,
+ offset: keyNode.range[2],
+ onError,
+ startOnNewline: false
+ });
+ if (valueProps.found) {
+ if (!isMap2 && !props.found && ctx.options.strict) {
+ if (sep)
+ for (const st of sep) {
+ if (st === valueProps.found)
+ break;
+ if (st.type === "newline") {
+ onError(st, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
+ break;
+ }
+ }
+ if (props.start < valueProps.found.offset - 1024)
+ onError(valueProps.found, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit flow sequence key");
+ }
+ } else if (value) {
+ if ("source" in value && value.source && value.source[0] === ":")
+ onError(value, "MISSING_CHAR", `Missing space after : in ${fcName}`);
+ else
+ onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
+ }
+ const valueNode = value ? composeNode2(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode2(ctx, valueProps.end, sep, null, valueProps, onError) : null;
+ if (valueNode) {
+ if (isBlock(value))
+ onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
+ } else if (valueProps.comment) {
+ if (keyNode.comment)
+ keyNode.comment += "\n" + valueProps.comment;
+ else
+ keyNode.comment = valueProps.comment;
+ }
+ const pair = new Pair(keyNode, valueNode);
+ if (ctx.options.keepSourceTokens)
+ pair.srcToken = collItem;
+ if (isMap2) {
+ const map2 = coll;
+ if (mapIncludes(ctx, map2.items, keyNode))
+ onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
+ map2.items.push(pair);
+ } else {
+ const map2 = new YAMLMap(ctx.schema);
+ map2.flow = true;
+ map2.items.push(pair);
+ coll.items.push(map2);
+ }
+ offset = valueNode ? valueNode.range[2] : valueProps.end;
+ }
+ }
+ const expectedEnd = isMap2 ? "}" : "]";
+ const [ce, ...ee] = fc.end;
+ let cePos = offset;
+ if (ce && ce.source === expectedEnd)
+ cePos = ce.offset + ce.source.length;
+ else {
+ const name = fcName[0].toUpperCase() + fcName.substring(1);
+ const msg = atRoot ? `${name} must end with a ${expectedEnd}` : `${name} in block collection must be sufficiently indented and end with a ${expectedEnd}`;
+ onError(offset, atRoot ? "MISSING_CHAR" : "BAD_INDENT", msg);
+ if (ce && ce.source.length !== 1)
+ ee.unshift(ce);
+ }
+ if (ee.length > 0) {
+ const end = resolveEnd(ee, cePos, ctx.options.strict, onError);
+ if (end.comment) {
+ if (coll.comment)
+ coll.comment += "\n" + end.comment;
+ else
+ coll.comment = end.comment;
+ }
+ coll.range = [fc.offset, cePos, end.offset];
+ } else {
+ coll.range = [fc.offset, cePos, cePos];
+ }
+ return coll;
+}
+
+// node_modules/yaml/browser/dist/compose/compose-collection.js
+function composeCollection(CN2, ctx, token, tagToken, onError) {
+ let coll;
+ switch (token.type) {
+ case "block-map": {
+ coll = resolveBlockMap(CN2, ctx, token, onError);
+ break;
+ }
+ case "block-seq": {
+ coll = resolveBlockSeq(CN2, ctx, token, onError);
+ break;
+ }
+ case "flow-collection": {
+ coll = resolveFlowCollection(CN2, ctx, token, onError);
+ break;
+ }
+ }
+ if (!tagToken)
+ return coll;
+ const tagName = ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg));
+ if (!tagName)
+ return coll;
+ const Coll = coll.constructor;
+ if (tagName === "!" || tagName === Coll.tagName) {
+ coll.tag = Coll.tagName;
+ return coll;
+ }
+ const expType = isMap(coll) ? "map" : "seq";
+ let tag = ctx.schema.tags.find((t) => t.collection === expType && t.tag === tagName);
+ if (!tag) {
+ const kt = ctx.schema.knownTags[tagName];
+ if (kt && kt.collection === expType) {
+ ctx.schema.tags.push(Object.assign({}, kt, { default: false }));
+ tag = kt;
+ } else {
+ onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, true);
+ coll.tag = tagName;
+ return coll;
+ }
+ }
+ const res = tag.resolve(coll, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg), ctx.options);
+ const node = isNode(res) ? res : new Scalar(res);
+ node.range = coll.range;
+ node.tag = tagName;
+ if (tag == null ? void 0 : tag.format)
+ node.format = tag.format;
+ return node;
+}
+
+// node_modules/yaml/browser/dist/compose/resolve-block-scalar.js
+function resolveBlockScalar(scalar, strict, onError) {
+ const start = scalar.offset;
+ const header = parseBlockScalarHeader(scalar, strict, onError);
+ if (!header)
+ return { value: "", type: null, comment: "", range: [start, start, start] };
+ const type = header.mode === ">" ? Scalar.BLOCK_FOLDED : Scalar.BLOCK_LITERAL;
+ const lines = scalar.source ? splitLines(scalar.source) : [];
+ let chompStart = lines.length;
+ for (let i = lines.length - 1; i >= 0; --i) {
+ const content = lines[i][1];
+ if (content === "" || content === "\r")
+ chompStart = i;
+ else
+ break;
+ }
+ if (chompStart === 0) {
+ const value2 = header.chomp === "+" && lines.length > 0 ? "\n".repeat(Math.max(1, lines.length - 1)) : "";
+ let end2 = start + header.length;
+ if (scalar.source)
+ end2 += scalar.source.length;
+ return { value: value2, type, comment: header.comment, range: [start, end2, end2] };
+ }
+ let trimIndent = scalar.indent + header.indent;
+ let offset = scalar.offset + header.length;
+ let contentStart = 0;
+ for (let i = 0; i < chompStart; ++i) {
+ const [indent, content] = lines[i];
+ if (content === "" || content === "\r") {
+ if (header.indent === 0 && indent.length > trimIndent)
+ trimIndent = indent.length;
+ } else {
+ if (indent.length < trimIndent) {
+ const message = "Block scalars with more-indented leading empty lines must use an explicit indentation indicator";
+ onError(offset + indent.length, "MISSING_CHAR", message);
+ }
+ if (header.indent === 0)
+ trimIndent = indent.length;
+ contentStart = i;
+ break;
+ }
+ offset += indent.length + content.length + 1;
+ }
+ for (let i = lines.length - 1; i >= chompStart; --i) {
+ if (lines[i][0].length > trimIndent)
+ chompStart = i + 1;
+ }
+ let value = "";
+ let sep = "";
+ let prevMoreIndented = false;
+ for (let i = 0; i < contentStart; ++i)
+ value += lines[i][0].slice(trimIndent) + "\n";
+ for (let i = contentStart; i < chompStart; ++i) {
+ let [indent, content] = lines[i];
+ offset += indent.length + content.length + 1;
+ const crlf = content[content.length - 1] === "\r";
+ if (crlf)
+ content = content.slice(0, -1);
+ if (content && indent.length < trimIndent) {
+ const src = header.indent ? "explicit indentation indicator" : "first line";
+ const message = `Block scalar lines must not be less indented than their ${src}`;
+ onError(offset - content.length - (crlf ? 2 : 1), "BAD_INDENT", message);
+ indent = "";
+ }
+ if (type === Scalar.BLOCK_LITERAL) {
+ value += sep + indent.slice(trimIndent) + content;
+ sep = "\n";
+ } else if (indent.length > trimIndent || content[0] === " ") {
+ if (sep === " ")
+ sep = "\n";
+ else if (!prevMoreIndented && sep === "\n")
+ sep = "\n\n";
+ value += sep + indent.slice(trimIndent) + content;
+ sep = "\n";
+ prevMoreIndented = true;
+ } else if (content === "") {
+ if (sep === "\n")
+ value += "\n";
+ else
+ sep = "\n";
+ } else {
+ value += sep + content;
+ sep = " ";
+ prevMoreIndented = false;
+ }
+ }
+ switch (header.chomp) {
+ case "-":
+ break;
+ case "+":
+ for (let i = chompStart; i < lines.length; ++i)
+ value += "\n" + lines[i][0].slice(trimIndent);
+ if (value[value.length - 1] !== "\n")
+ value += "\n";
+ break;
+ default:
+ value += "\n";
+ }
+ const end = start + header.length + scalar.source.length;
+ return { value, type, comment: header.comment, range: [start, end, end] };
+}
+function parseBlockScalarHeader({ offset, props }, strict, onError) {
+ if (props[0].type !== "block-scalar-header") {
+ onError(props[0], "IMPOSSIBLE", "Block scalar header not found");
+ return null;
+ }
+ const { source } = props[0];
+ const mode = source[0];
+ let indent = 0;
+ let chomp = "";
+ let error = -1;
+ for (let i = 1; i < source.length; ++i) {
+ const ch = source[i];
+ if (!chomp && (ch === "-" || ch === "+"))
+ chomp = ch;
+ else {
+ const n = Number(ch);
+ if (!indent && n)
+ indent = n;
+ else if (error === -1)
+ error = offset + i;
+ }
+ }
+ if (error !== -1)
+ onError(error, "UNEXPECTED_TOKEN", `Block scalar header includes extra characters: ${source}`);
+ let hasSpace = false;
+ let comment = "";
+ let length = source.length;
+ for (let i = 1; i < props.length; ++i) {
+ const token = props[i];
+ switch (token.type) {
+ case "space":
+ hasSpace = true;
+ case "newline":
+ length += token.source.length;
+ break;
+ case "comment":
+ if (strict && !hasSpace) {
+ const message = "Comments must be separated from other tokens by white space characters";
+ onError(token, "MISSING_CHAR", message);
+ }
+ length += token.source.length;
+ comment = token.source.substring(1);
+ break;
+ case "error":
+ onError(token, "UNEXPECTED_TOKEN", token.message);
+ length += token.source.length;
+ break;
+ default: {
+ const message = `Unexpected token in block scalar header: ${token.type}`;
+ onError(token, "UNEXPECTED_TOKEN", message);
+ const ts = token.source;
+ if (ts && typeof ts === "string")
+ length += ts.length;
+ }
+ }
+ }
+ return { mode, indent, chomp, comment, length };
+}
+function splitLines(source) {
+ const split = source.split(/\n( *)/);
+ const first = split[0];
+ const m = first.match(/^( *)/);
+ const line0 = (m == null ? void 0 : m[1]) ? [m[1], first.slice(m[1].length)] : ["", first];
+ const lines = [line0];
+ for (let i = 1; i < split.length; i += 2)
+ lines.push([split[i], split[i + 1]]);
+ return lines;
+}
+
+// node_modules/yaml/browser/dist/compose/resolve-flow-scalar.js
+function resolveFlowScalar(scalar, strict, onError) {
+ const { offset, type, source, end } = scalar;
+ let _type;
+ let value;
+ const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
+ switch (type) {
+ case "scalar":
+ _type = Scalar.PLAIN;
+ value = plainValue(source, _onError);
+ break;
+ case "single-quoted-scalar":
+ _type = Scalar.QUOTE_SINGLE;
+ value = singleQuotedValue(source, _onError);
+ break;
+ case "double-quoted-scalar":
+ _type = Scalar.QUOTE_DOUBLE;
+ value = doubleQuotedValue(source, _onError);
+ break;
+ default:
+ onError(scalar, "UNEXPECTED_TOKEN", `Expected a flow scalar value, but found: ${type}`);
+ return {
+ value: "",
+ type: null,
+ comment: "",
+ range: [offset, offset + source.length, offset + source.length]
+ };
+ }
+ const valueEnd = offset + source.length;
+ const re = resolveEnd(end, valueEnd, strict, onError);
+ return {
+ value,
+ type: _type,
+ comment: re.comment,
+ range: [offset, valueEnd, re.offset]
+ };
+}
+function plainValue(source, onError) {
+ let badChar = "";
+ switch (source[0]) {
+ case " ":
+ badChar = "a tab character";
+ break;
+ case ",":
+ badChar = "flow indicator character ,";
+ break;
+ case "%":
+ badChar = "directive indicator character %";
+ break;
+ case "|":
+ case ">": {
+ badChar = `block scalar indicator ${source[0]}`;
+ break;
+ }
+ case "@":
+ case "`": {
+ badChar = `reserved character ${source[0]}`;
+ break;
+ }
+ }
+ if (badChar)
+ onError(0, "BAD_SCALAR_START", `Plain value cannot start with ${badChar}`);
+ return foldLines(source);
+}
+function singleQuotedValue(source, onError) {
+ if (source[source.length - 1] !== "'" || source.length === 1)
+ onError(source.length, "MISSING_CHAR", "Missing closing 'quote");
+ return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+}
+function foldLines(source) {
+ var _a;
+ let first, line;
+ try {
+ first = new RegExp("(.*?)(? wsStart ? source.slice(wsStart, i + 1) : ch;
+ } else {
+ res += ch;
+ }
+ }
+ if (source[source.length - 1] !== '"' || source.length === 1)
+ onError(source.length, "MISSING_CHAR", 'Missing closing "quote');
+ return res;
+}
+function foldNewline(source, offset) {
+ let fold = "";
+ let ch = source[offset + 1];
+ while (ch === " " || ch === " " || ch === "\n" || ch === "\r") {
+ if (ch === "\r" && source[offset + 2] !== "\n")
+ break;
+ if (ch === "\n")
+ fold += "\n";
+ offset += 1;
+ ch = source[offset + 1];
+ }
+ if (!fold)
+ fold = " ";
+ return { fold, offset };
+}
+var escapeCodes = {
+ "0": "\0",
+ a: "\x07",
+ b: "\b",
+ e: "",
+ f: "\f",
+ n: "\n",
+ r: "\r",
+ t: " ",
+ v: "\v",
+ N: "\x85",
+ _: "\xA0",
+ L: "\u2028",
+ P: "\u2029",
+ " ": " ",
+ '"': '"',
+ "/": "/",
+ "\\": "\\",
+ " ": " "
+};
+function parseCharCode(source, offset, length, onError) {
+ const cc = source.substr(offset, length);
+ const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
+ const code = ok ? parseInt(cc, 16) : NaN;
+ if (isNaN(code)) {
+ const raw = source.substr(offset - 2, length + 2);
+ onError(offset - 2, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
+ return raw;
+ }
+ return String.fromCodePoint(code);
+}
+
+// node_modules/yaml/browser/dist/compose/compose-scalar.js
+function composeScalar(ctx, token, tagToken, onError) {
+ const { value, type, comment, range } = token.type === "block-scalar" ? resolveBlockScalar(token, ctx.options.strict, onError) : resolveFlowScalar(token, ctx.options.strict, onError);
+ const tagName = tagToken ? ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg)) : null;
+ const tag = tagToken && tagName ? findScalarTagByName(ctx.schema, value, tagName, tagToken, onError) : token.type === "scalar" ? findScalarTagByTest(ctx, value, token, onError) : ctx.schema[SCALAR];
+ let scalar;
+ try {
+ const res = tag.resolve(value, (msg) => onError(tagToken != null ? tagToken : token, "TAG_RESOLVE_FAILED", msg), ctx.options);
+ scalar = isScalar(res) ? res : new Scalar(res);
+ } catch (error) {
+ const msg = error instanceof Error ? error.message : String(error);
+ onError(tagToken != null ? tagToken : token, "TAG_RESOLVE_FAILED", msg);
+ scalar = new Scalar(value);
+ }
+ scalar.range = range;
+ scalar.source = value;
+ if (type)
+ scalar.type = type;
+ if (tagName)
+ scalar.tag = tagName;
+ if (tag.format)
+ scalar.format = tag.format;
+ if (comment)
+ scalar.comment = comment;
+ return scalar;
+}
+function findScalarTagByName(schema4, value, tagName, tagToken, onError) {
+ var _a;
+ if (tagName === "!")
+ return schema4[SCALAR];
+ const matchWithTest = [];
+ for (const tag of schema4.tags) {
+ if (!tag.collection && tag.tag === tagName) {
+ if (tag.default && tag.test)
+ matchWithTest.push(tag);
+ else
+ return tag;
+ }
+ }
+ for (const tag of matchWithTest)
+ if ((_a = tag.test) == null ? void 0 : _a.test(value))
+ return tag;
+ const kt = schema4.knownTags[tagName];
+ if (kt && !kt.collection) {
+ schema4.tags.push(Object.assign({}, kt, { default: false, test: void 0 }));
+ return kt;
+ }
+ onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, tagName !== "tag:yaml.org,2002:str");
+ return schema4[SCALAR];
+}
+function findScalarTagByTest({ directives, schema: schema4 }, value, token, onError) {
+ var _a;
+ const tag = schema4.tags.find((tag2) => {
+ var _a2;
+ return tag2.default && ((_a2 = tag2.test) == null ? void 0 : _a2.test(value));
+ }) || schema4[SCALAR];
+ if (schema4.compat) {
+ const compat = (_a = schema4.compat.find((tag2) => {
+ var _a2;
+ return tag2.default && ((_a2 = tag2.test) == null ? void 0 : _a2.test(value));
+ })) != null ? _a : schema4[SCALAR];
+ if (tag.tag !== compat.tag) {
+ const ts = directives.tagString(tag.tag);
+ const cs = directives.tagString(compat.tag);
+ const msg = `Value may be parsed as either ${ts} or ${cs}`;
+ onError(token, "TAG_RESOLVE_FAILED", msg, true);
+ }
+ }
+ return tag;
+}
+
+// node_modules/yaml/browser/dist/compose/util-empty-scalar-position.js
+function emptyScalarPosition(offset, before, pos) {
+ if (before) {
+ if (pos === null)
+ pos = before.length;
+ for (let i = pos - 1; i >= 0; --i) {
+ let st = before[i];
+ switch (st.type) {
+ case "space":
+ case "comment":
+ case "newline":
+ offset -= st.source.length;
+ continue;
+ }
+ st = before[++i];
+ while ((st == null ? void 0 : st.type) === "space") {
+ offset += st.source.length;
+ st = before[++i];
+ }
+ break;
+ }
+ }
+ return offset;
+}
+
+// node_modules/yaml/browser/dist/compose/compose-node.js
+var CN = { composeNode, composeEmptyNode };
+function composeNode(ctx, token, props, onError) {
+ const { spaceBefore, comment, anchor, tag } = props;
+ let node;
+ let isSrcToken = true;
+ switch (token.type) {
+ case "alias":
+ node = composeAlias(ctx, token, onError);
+ if (anchor || tag)
+ onError(token, "ALIAS_PROPS", "An alias node must not specify any properties");
+ break;
+ case "scalar":
+ case "single-quoted-scalar":
+ case "double-quoted-scalar":
+ case "block-scalar":
+ node = composeScalar(ctx, token, tag, onError);
+ if (anchor)
+ node.anchor = anchor.source.substring(1);
+ break;
+ case "block-map":
+ case "block-seq":
+ case "flow-collection":
+ node = composeCollection(CN, ctx, token, tag, onError);
+ if (anchor)
+ node.anchor = anchor.source.substring(1);
+ break;
+ default: {
+ const message = token.type === "error" ? token.message : `Unsupported token (type: ${token.type})`;
+ onError(token, "UNEXPECTED_TOKEN", message);
+ node = composeEmptyNode(ctx, token.offset, void 0, null, props, onError);
+ isSrcToken = false;
+ }
+ }
+ if (anchor && node.anchor === "")
+ onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
+ if (spaceBefore)
+ node.spaceBefore = true;
+ if (comment) {
+ if (token.type === "scalar" && token.source === "")
+ node.comment = comment;
+ else
+ node.commentBefore = comment;
+ }
+ if (ctx.options.keepSourceTokens && isSrcToken)
+ node.srcToken = token;
+ return node;
+}
+function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag }, onError) {
+ const token = {
+ type: "scalar",
+ offset: emptyScalarPosition(offset, before, pos),
+ indent: -1,
+ source: ""
+ };
+ const node = composeScalar(ctx, token, tag, onError);
+ if (anchor) {
+ node.anchor = anchor.source.substring(1);
+ if (node.anchor === "")
+ onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
+ }
+ if (spaceBefore)
+ node.spaceBefore = true;
+ if (comment)
+ node.comment = comment;
+ return node;
+}
+function composeAlias({ options }, { offset, source, end }, onError) {
+ const alias = new Alias(source.substring(1));
+ if (alias.source === "")
+ onError(offset, "BAD_ALIAS", "Alias cannot be an empty string");
+ if (alias.source.endsWith(":"))
+ onError(offset + source.length - 1, "BAD_ALIAS", "Alias ending in : is ambiguous", true);
+ const valueEnd = offset + source.length;
+ const re = resolveEnd(end, valueEnd, options.strict, onError);
+ alias.range = [offset, valueEnd, re.offset];
+ if (re.comment)
+ alias.comment = re.comment;
+ return alias;
+}
+
+// node_modules/yaml/browser/dist/compose/compose-doc.js
+function composeDoc(options, directives, { offset, start, value, end }, onError) {
+ const opts = Object.assign({ _directives: directives }, options);
+ const doc = new Document(void 0, opts);
+ const ctx = {
+ atRoot: true,
+ directives: doc.directives,
+ options: doc.options,
+ schema: doc.schema
+ };
+ const props = resolveProps(start, {
+ indicator: "doc-start",
+ next: value != null ? value : end == null ? void 0 : end[0],
+ offset,
+ onError,
+ startOnNewline: true
+ });
+ if (props.found) {
+ doc.directives.docStart = true;
+ if (value && (value.type === "block-map" || value.type === "block-seq") && !props.hasNewline)
+ onError(props.end, "MISSING_CHAR", "Block collection cannot start on same line with directives-end marker");
+ }
+ doc.contents = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, start, null, props, onError);
+ const contentEnd = doc.contents.range[2];
+ const re = resolveEnd(end, contentEnd, false, onError);
+ if (re.comment)
+ doc.comment = re.comment;
+ doc.range = [offset, contentEnd, re.offset];
+ return doc;
+}
+
+// node_modules/yaml/browser/dist/compose/composer.js
+function getErrorPos(src) {
+ if (typeof src === "number")
+ return [src, src + 1];
+ if (Array.isArray(src))
+ return src.length === 2 ? src : [src[0], src[1]];
+ const { offset, source } = src;
+ return [offset, offset + (typeof source === "string" ? source.length : 1)];
+}
+function parsePrelude(prelude) {
+ var _a;
+ let comment = "";
+ let atComment = false;
+ let afterEmptyLine = false;
+ for (let i = 0; i < prelude.length; ++i) {
+ const source = prelude[i];
+ switch (source[0]) {
+ case "#":
+ comment += (comment === "" ? "" : afterEmptyLine ? "\n\n" : "\n") + (source.substring(1) || " ");
+ atComment = true;
+ afterEmptyLine = false;
+ break;
+ case "%":
+ if (((_a = prelude[i + 1]) == null ? void 0 : _a[0]) !== "#")
+ i += 1;
+ atComment = false;
+ break;
+ default:
+ if (!atComment)
+ afterEmptyLine = true;
+ atComment = false;
+ }
+ }
+ return { comment, afterEmptyLine };
+}
+var Composer = class {
+ constructor(options = {}) {
+ this.doc = null;
+ this.atDirectives = false;
+ this.prelude = [];
+ this.errors = [];
+ this.warnings = [];
+ this.onError = (source, code, message, warning) => {
+ const pos = getErrorPos(source);
+ if (warning)
+ this.warnings.push(new YAMLWarning(pos, code, message));
+ else
+ this.errors.push(new YAMLParseError(pos, code, message));
+ };
+ this.directives = new Directives({ version: options.version || "1.2" });
+ this.options = options;
+ }
+ decorate(doc, afterDoc) {
+ const { comment, afterEmptyLine } = parsePrelude(this.prelude);
+ if (comment) {
+ const dc = doc.contents;
+ if (afterDoc) {
+ doc.comment = doc.comment ? `${doc.comment}
+${comment}` : comment;
+ } else if (afterEmptyLine || doc.directives.docStart || !dc) {
+ doc.commentBefore = comment;
+ } else if (isCollection(dc) && !dc.flow && dc.items.length > 0) {
+ let it = dc.items[0];
+ if (isPair(it))
+ it = it.key;
+ const cb = it.commentBefore;
+ it.commentBefore = cb ? `${comment}
+${cb}` : comment;
+ } else {
+ const cb = dc.commentBefore;
+ dc.commentBefore = cb ? `${comment}
+${cb}` : comment;
+ }
+ }
+ if (afterDoc) {
+ Array.prototype.push.apply(doc.errors, this.errors);
+ Array.prototype.push.apply(doc.warnings, this.warnings);
+ } else {
+ doc.errors = this.errors;
+ doc.warnings = this.warnings;
+ }
+ this.prelude = [];
+ this.errors = [];
+ this.warnings = [];
+ }
+ streamInfo() {
+ return {
+ comment: parsePrelude(this.prelude).comment,
+ directives: this.directives,
+ errors: this.errors,
+ warnings: this.warnings
+ };
+ }
+ *compose(tokens, forceDoc = false, endOffset = -1) {
+ for (const token of tokens)
+ yield* this.next(token);
+ yield* this.end(forceDoc, endOffset);
+ }
+ *next(token) {
+ switch (token.type) {
+ case "directive":
+ this.directives.add(token.source, (offset, message, warning) => {
+ const pos = getErrorPos(token);
+ pos[0] += offset;
+ this.onError(pos, "BAD_DIRECTIVE", message, warning);
+ });
+ this.prelude.push(token.source);
+ this.atDirectives = true;
+ break;
+ case "document": {
+ const doc = composeDoc(this.options, this.directives, token, this.onError);
+ if (this.atDirectives && !doc.directives.docStart)
+ this.onError(token, "MISSING_CHAR", "Missing directives-end/doc-start indicator line");
+ this.decorate(doc, false);
+ if (this.doc)
+ yield this.doc;
+ this.doc = doc;
+ this.atDirectives = false;
+ break;
+ }
+ case "byte-order-mark":
+ case "space":
+ break;
+ case "comment":
+ case "newline":
+ this.prelude.push(token.source);
+ break;
+ case "error": {
+ const msg = token.source ? `${token.message}: ${JSON.stringify(token.source)}` : token.message;
+ const error = new YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg);
+ if (this.atDirectives || !this.doc)
+ this.errors.push(error);
+ else
+ this.doc.errors.push(error);
+ break;
+ }
+ case "doc-end": {
+ if (!this.doc) {
+ const msg = "Unexpected doc-end without preceding document";
+ this.errors.push(new YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg));
+ break;
+ }
+ this.doc.directives.docEnd = true;
+ const end = resolveEnd(token.end, token.offset + token.source.length, this.doc.options.strict, this.onError);
+ this.decorate(this.doc, true);
+ if (end.comment) {
+ const dc = this.doc.comment;
+ this.doc.comment = dc ? `${dc}
+${end.comment}` : end.comment;
+ }
+ this.doc.range[2] = end.offset;
+ break;
+ }
+ default:
+ this.errors.push(new YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", `Unsupported token ${token.type}`));
+ }
+ }
+ *end(forceDoc = false, endOffset = -1) {
+ if (this.doc) {
+ this.decorate(this.doc, true);
+ yield this.doc;
+ this.doc = null;
+ } else if (forceDoc) {
+ const opts = Object.assign({ _directives: this.directives }, this.options);
+ const doc = new Document(void 0, opts);
+ if (this.atDirectives)
+ this.onError(endOffset, "MISSING_CHAR", "Missing directives-end indicator line");
+ doc.range = [0, endOffset, endOffset];
+ this.decorate(doc, false);
+ yield doc;
+ }
+ }
+};
+
+// 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, path5) => {
+ let item = cst;
+ for (const [field, index] of path5) {
+ 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, path5) => {
+ const parent = visit2.itemAtPath(cst, path5.slice(0, -1));
+ const field = path5[path5.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(path5, item, visitor) {
+ let ctrl = visitor(item, path5);
+ 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(path5.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, path5);
+ }
+ }
+ return typeof ctrl === "function" ? ctrl(item, path5) : ctrl;
+}
+
+// node_modules/yaml/browser/dist/parse/cst.js
+var BOM = "\uFEFF";
+var DOCUMENT = "";
+var FLOW_END = "";
+var SCALAR2 = " ";
+function tokenType(source) {
+ switch (source) {
+ case BOM:
+ return "byte-order-mark";
+ case DOCUMENT:
+ return "doc-mode";
+ case FLOW_END:
+ return "flow-error-end";
+ case SCALAR2:
+ return "scalar";
+ case "---":
+ return "doc-start";
+ case "...":
+ return "doc-end";
+ case "":
+ case "\n":
+ case "\r\n":
+ return "newline";
+ case "-":
+ return "seq-item-ind";
+ case "?":
+ return "explicit-key-ind";
+ case ":":
+ return "map-value-ind";
+ case "{":
+ return "flow-map-start";
+ case "}":
+ return "flow-map-end";
+ case "[":
+ return "flow-seq-start";
+ case "]":
+ return "flow-seq-end";
+ case ",":
+ return "comma";
+ }
+ switch (source[0]) {
+ case " ":
+ case " ":
+ return "space";
+ case "#":
+ return "comment";
+ case "%":
+ return "directive-line";
+ case "*":
+ return "alias";
+ case "&":
+ return "anchor";
+ case "!":
+ return "tag";
+ case "'":
+ return "single-quoted-scalar";
+ case '"':
+ return "double-quoted-scalar";
+ case "|":
+ case ">":
+ return "block-scalar-header";
+ }
+ return null;
+}
+
+// node_modules/yaml/browser/dist/parse/lexer.js
+function isEmpty(ch) {
+ switch (ch) {
+ case void 0:
+ case " ":
+ case "\n":
+ case "\r":
+ case " ":
+ return true;
+ default:
+ return false;
+ }
+}
+var hexDigits = "0123456789ABCDEFabcdef".split("");
+var tagChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()".split("");
+var invalidFlowScalarChars = ",[]{}".split("");
+var invalidAnchorChars = " ,[]{}\n\r ".split("");
+var isNotAnchorChar = (ch) => !ch || invalidAnchorChars.includes(ch);
+var Lexer = class {
+ constructor() {
+ this.atEnd = false;
+ this.blockScalarIndent = -1;
+ this.blockScalarKeep = false;
+ this.buffer = "";
+ this.flowKey = false;
+ this.flowLevel = 0;
+ this.indentNext = 0;
+ this.indentValue = 0;
+ this.lineEndPos = null;
+ this.next = null;
+ this.pos = 0;
+ }
+ *lex(source, incomplete = false) {
+ var _a;
+ if (source) {
+ this.buffer = this.buffer ? this.buffer + source : source;
+ this.lineEndPos = null;
+ }
+ this.atEnd = !incomplete;
+ let next = (_a = this.next) != null ? _a : "stream";
+ while (next && (incomplete || this.hasChars(1)))
+ next = yield* this.parseNext(next);
+ }
+ atLineEnd() {
+ let i = this.pos;
+ let ch = this.buffer[i];
+ while (ch === " " || ch === " ")
+ ch = this.buffer[++i];
+ if (!ch || ch === "#" || ch === "\n")
+ return true;
+ if (ch === "\r")
+ return this.buffer[i + 1] === "\n";
+ return false;
+ }
+ charAt(n) {
+ return this.buffer[this.pos + n];
+ }
+ continueScalar(offset) {
+ let ch = this.buffer[offset];
+ if (this.indentNext > 0) {
+ let indent = 0;
+ while (ch === " ")
+ ch = this.buffer[++indent + offset];
+ if (ch === "\r") {
+ const next = this.buffer[indent + offset + 1];
+ if (next === "\n" || !next && !this.atEnd)
+ return offset + indent + 1;
+ }
+ return ch === "\n" || indent >= this.indentNext || !ch && !this.atEnd ? offset + indent : -1;
+ }
+ if (ch === "-" || ch === ".") {
+ const dt = this.buffer.substr(offset, 3);
+ if ((dt === "---" || dt === "...") && isEmpty(this.buffer[offset + 3]))
+ return -1;
+ }
+ return offset;
+ }
+ getLine() {
+ let end = this.lineEndPos;
+ if (typeof end !== "number" || end !== -1 && end < this.pos) {
+ end = this.buffer.indexOf("\n", this.pos);
+ this.lineEndPos = end;
+ }
+ if (end === -1)
+ return this.atEnd ? this.buffer.substring(this.pos) : null;
+ if (this.buffer[end - 1] === "\r")
+ end -= 1;
+ return this.buffer.substring(this.pos, end);
+ }
+ hasChars(n) {
+ return this.pos + n <= this.buffer.length;
+ }
+ setNext(state) {
+ this.buffer = this.buffer.substring(this.pos);
+ this.pos = 0;
+ this.lineEndPos = null;
+ this.next = state;
+ return null;
+ }
+ peek(n) {
+ return this.buffer.substr(this.pos, n);
+ }
+ *parseNext(next) {
+ switch (next) {
+ case "stream":
+ return yield* this.parseStream();
+ case "line-start":
+ return yield* this.parseLineStart();
+ case "block-start":
+ return yield* this.parseBlockStart();
+ case "doc":
+ return yield* this.parseDocument();
+ case "flow":
+ return yield* this.parseFlowCollection();
+ case "quoted-scalar":
+ return yield* this.parseQuotedScalar();
+ case "block-scalar":
+ return yield* this.parseBlockScalar();
+ case "plain-scalar":
+ return yield* this.parsePlainScalar();
+ }
+ }
+ *parseStream() {
+ let line = this.getLine();
+ if (line === null)
+ return this.setNext("stream");
+ if (line[0] === BOM) {
+ yield* this.pushCount(1);
+ line = line.substring(1);
+ }
+ if (line[0] === "%") {
+ let dirEnd = line.length;
+ const cs = line.indexOf("#");
+ if (cs !== -1) {
+ const ch = line[cs - 1];
+ if (ch === " " || ch === " ")
+ dirEnd = cs - 1;
+ }
+ while (true) {
+ const ch = line[dirEnd - 1];
+ if (ch === " " || ch === " ")
+ dirEnd -= 1;
+ else
+ break;
+ }
+ const n = (yield* this.pushCount(dirEnd)) + (yield* this.pushSpaces(true));
+ yield* this.pushCount(line.length - n);
+ this.pushNewline();
+ return "stream";
+ }
+ if (this.atLineEnd()) {
+ const sp = yield* this.pushSpaces(true);
+ yield* this.pushCount(line.length - sp);
+ yield* this.pushNewline();
+ return "stream";
+ }
+ yield DOCUMENT;
+ return yield* this.parseLineStart();
+ }
+ *parseLineStart() {
+ const ch = this.charAt(0);
+ if (!ch && !this.atEnd)
+ return this.setNext("line-start");
+ if (ch === "-" || ch === ".") {
+ if (!this.atEnd && !this.hasChars(4))
+ return this.setNext("line-start");
+ const s = this.peek(3);
+ if (s === "---" && isEmpty(this.charAt(3))) {
+ yield* this.pushCount(3);
+ this.indentValue = 0;
+ this.indentNext = 0;
+ return "doc";
+ } else if (s === "..." && isEmpty(this.charAt(3))) {
+ yield* this.pushCount(3);
+ return "stream";
+ }
+ }
+ this.indentValue = yield* this.pushSpaces(false);
+ if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1)))
+ this.indentNext = this.indentValue;
+ return yield* this.parseBlockStart();
+ }
+ *parseBlockStart() {
+ const [ch0, ch1] = this.peek(2);
+ if (!ch1 && !this.atEnd)
+ return this.setNext("block-start");
+ if ((ch0 === "-" || ch0 === "?" || ch0 === ":") && isEmpty(ch1)) {
+ const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));
+ this.indentNext = this.indentValue + 1;
+ this.indentValue += n;
+ return yield* this.parseBlockStart();
+ }
+ return "doc";
+ }
+ *parseDocument() {
+ yield* this.pushSpaces(true);
+ const line = this.getLine();
+ if (line === null)
+ return this.setNext("doc");
+ let n = yield* this.pushIndicators();
+ switch (line[n]) {
+ case "#":
+ yield* this.pushCount(line.length - n);
+ case void 0:
+ yield* this.pushNewline();
+ return yield* this.parseLineStart();
+ case "{":
+ case "[":
+ yield* this.pushCount(1);
+ this.flowKey = false;
+ this.flowLevel = 1;
+ return "flow";
+ case "}":
+ case "]":
+ yield* this.pushCount(1);
+ return "doc";
+ case "*":
+ yield* this.pushUntil(isNotAnchorChar);
+ return "doc";
+ case '"':
+ case "'":
+ return yield* this.parseQuotedScalar();
+ case "|":
+ case ">":
+ n += yield* this.parseBlockScalarHeader();
+ n += yield* this.pushSpaces(true);
+ yield* this.pushCount(line.length - n);
+ yield* this.pushNewline();
+ return yield* this.parseBlockScalar();
+ default:
+ return yield* this.parsePlainScalar();
+ }
+ }
+ *parseFlowCollection() {
+ let nl, sp;
+ let indent = -1;
+ do {
+ nl = yield* this.pushNewline();
+ if (nl > 0) {
+ sp = yield* this.pushSpaces(false);
+ this.indentValue = indent = sp;
+ } else {
+ sp = 0;
+ }
+ sp += yield* this.pushSpaces(true);
+ } while (nl + sp > 0);
+ const line = this.getLine();
+ if (line === null)
+ return this.setNext("flow");
+ if (indent !== -1 && indent < this.indentNext && line[0] !== "#" || indent === 0 && (line.startsWith("---") || line.startsWith("...")) && isEmpty(line[3])) {
+ const atFlowEndMarker = indent === this.indentNext - 1 && this.flowLevel === 1 && (line[0] === "]" || line[0] === "}");
+ if (!atFlowEndMarker) {
+ this.flowLevel = 0;
+ yield FLOW_END;
+ return yield* this.parseLineStart();
+ }
+ }
+ let n = 0;
+ while (line[n] === ",") {
+ n += yield* this.pushCount(1);
+ n += yield* this.pushSpaces(true);
+ this.flowKey = false;
+ }
+ n += yield* this.pushIndicators();
+ switch (line[n]) {
+ case void 0:
+ return "flow";
+ case "#":
+ yield* this.pushCount(line.length - n);
+ return "flow";
+ case "{":
+ case "[":
+ yield* this.pushCount(1);
+ this.flowKey = false;
+ this.flowLevel += 1;
+ return "flow";
+ case "}":
+ case "]":
+ yield* this.pushCount(1);
+ this.flowKey = true;
+ this.flowLevel -= 1;
+ return this.flowLevel ? "flow" : "doc";
+ case "*":
+ yield* this.pushUntil(isNotAnchorChar);
+ return "flow";
+ case '"':
+ case "'":
+ this.flowKey = true;
+ return yield* this.parseQuotedScalar();
+ case ":": {
+ const next = this.charAt(1);
+ if (this.flowKey || isEmpty(next) || next === ",") {
+ this.flowKey = false;
+ yield* this.pushCount(1);
+ yield* this.pushSpaces(true);
+ return "flow";
+ }
+ }
+ default:
+ this.flowKey = false;
+ return yield* this.parsePlainScalar();
+ }
+ }
+ *parseQuotedScalar() {
+ const quote = this.charAt(0);
+ let end = this.buffer.indexOf(quote, this.pos + 1);
+ if (quote === "'") {
+ while (end !== -1 && this.buffer[end + 1] === "'")
+ end = this.buffer.indexOf("'", end + 2);
+ } else {
+ while (end !== -1) {
+ let n = 0;
+ while (this.buffer[end - 1 - n] === "\\")
+ n += 1;
+ if (n % 2 === 0)
+ break;
+ end = this.buffer.indexOf('"', end + 1);
+ }
+ }
+ const qb = this.buffer.substring(0, end);
+ let nl = qb.indexOf("\n", this.pos);
+ if (nl !== -1) {
+ while (nl !== -1) {
+ const cs = this.continueScalar(nl + 1);
+ if (cs === -1)
+ break;
+ nl = qb.indexOf("\n", cs);
+ }
+ if (nl !== -1) {
+ end = nl - (qb[nl - 1] === "\r" ? 2 : 1);
+ }
+ }
+ if (end === -1) {
+ if (!this.atEnd)
+ return this.setNext("quoted-scalar");
+ end = this.buffer.length;
+ }
+ yield* this.pushToIndex(end + 1, false);
+ return this.flowLevel ? "flow" : "doc";
+ }
+ *parseBlockScalarHeader() {
+ this.blockScalarIndent = -1;
+ this.blockScalarKeep = false;
+ let i = this.pos;
+ while (true) {
+ const ch = this.buffer[++i];
+ if (ch === "+")
+ this.blockScalarKeep = true;
+ else if (ch > "0" && ch <= "9")
+ this.blockScalarIndent = Number(ch) - 1;
+ else if (ch !== "-")
+ break;
+ }
+ return yield* this.pushUntil((ch) => isEmpty(ch) || ch === "#");
+ }
+ *parseBlockScalar() {
+ let nl = this.pos - 1;
+ let indent = 0;
+ let ch;
+ loop:
+ for (let i = this.pos; ch = this.buffer[i]; ++i) {
+ switch (ch) {
+ case " ":
+ indent += 1;
+ break;
+ case "\n":
+ nl = i;
+ indent = 0;
+ break;
+ case "\r": {
+ const next = this.buffer[i + 1];
+ if (!next && !this.atEnd)
+ return this.setNext("block-scalar");
+ if (next === "\n")
+ break;
+ }
+ default:
+ break loop;
+ }
+ }
+ if (!ch && !this.atEnd)
+ return this.setNext("block-scalar");
+ if (indent >= this.indentNext) {
+ if (this.blockScalarIndent === -1)
+ this.indentNext = indent;
+ else
+ this.indentNext += this.blockScalarIndent;
+ do {
+ const cs = this.continueScalar(nl + 1);
+ if (cs === -1)
+ break;
+ nl = this.buffer.indexOf("\n", cs);
+ } while (nl !== -1);
+ if (nl === -1) {
+ if (!this.atEnd)
+ return this.setNext("block-scalar");
+ nl = this.buffer.length;
+ }
+ }
+ if (!this.blockScalarKeep) {
+ do {
+ let i = nl - 1;
+ let ch2 = this.buffer[i];
+ if (ch2 === "\r")
+ ch2 = this.buffer[--i];
+ const lastChar = i;
+ while (ch2 === " " || ch2 === " ")
+ ch2 = this.buffer[--i];
+ if (ch2 === "\n" && i >= this.pos && i + 1 + indent > lastChar)
+ nl = i;
+ else
+ break;
+ } while (true);
+ }
+ yield SCALAR2;
+ yield* this.pushToIndex(nl + 1, true);
+ return yield* this.parseLineStart();
+ }
+ *parsePlainScalar() {
+ const inFlow = this.flowLevel > 0;
+ let end = this.pos - 1;
+ let i = this.pos - 1;
+ let ch;
+ while (ch = this.buffer[++i]) {
+ if (ch === ":") {
+ const next = this.buffer[i + 1];
+ if (isEmpty(next) || inFlow && next === ",")
+ break;
+ end = i;
+ } else if (isEmpty(ch)) {
+ let next = this.buffer[i + 1];
+ if (ch === "\r") {
+ if (next === "\n") {
+ i += 1;
+ ch = "\n";
+ next = this.buffer[i + 1];
+ } else
+ end = i;
+ }
+ if (next === "#" || inFlow && invalidFlowScalarChars.includes(next))
+ break;
+ if (ch === "\n") {
+ const cs = this.continueScalar(i + 1);
+ if (cs === -1)
+ break;
+ i = Math.max(i, cs - 2);
+ }
+ } else {
+ if (inFlow && invalidFlowScalarChars.includes(ch))
+ break;
+ end = i;
+ }
+ }
+ if (!ch && !this.atEnd)
+ return this.setNext("plain-scalar");
+ yield SCALAR2;
+ yield* this.pushToIndex(end + 1, true);
+ return inFlow ? "flow" : "doc";
+ }
+ *pushCount(n) {
+ if (n > 0) {
+ yield this.buffer.substr(this.pos, n);
+ this.pos += n;
+ return n;
+ }
+ return 0;
+ }
+ *pushToIndex(i, allowEmpty) {
+ const s = this.buffer.slice(this.pos, i);
+ if (s) {
+ yield s;
+ this.pos += s.length;
+ return s.length;
+ } else if (allowEmpty)
+ yield "";
+ return 0;
+ }
+ *pushIndicators() {
+ switch (this.charAt(0)) {
+ case "!":
+ return (yield* this.pushTag()) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
+ case "&":
+ return (yield* this.pushUntil(isNotAnchorChar)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
+ case "-":
+ case "?":
+ case ":": {
+ const inFlow = this.flowLevel > 0;
+ const ch1 = this.charAt(1);
+ if (isEmpty(ch1) || inFlow && invalidFlowScalarChars.includes(ch1)) {
+ if (!inFlow)
+ this.indentNext = this.indentValue + 1;
+ else if (this.flowKey)
+ this.flowKey = false;
+ return (yield* this.pushCount(1)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
+ }
+ }
+ }
+ return 0;
+ }
+ *pushTag() {
+ if (this.charAt(1) === "<") {
+ let i = this.pos + 2;
+ let ch = this.buffer[i];
+ while (!isEmpty(ch) && ch !== ">")
+ ch = this.buffer[++i];
+ return yield* this.pushToIndex(ch === ">" ? i + 1 : i, false);
+ } else {
+ let i = this.pos + 1;
+ let ch = this.buffer[i];
+ while (ch) {
+ if (tagChars.includes(ch))
+ ch = this.buffer[++i];
+ else if (ch === "%" && hexDigits.includes(this.buffer[i + 1]) && hexDigits.includes(this.buffer[i + 2])) {
+ ch = this.buffer[i += 3];
+ } else
+ break;
+ }
+ return yield* this.pushToIndex(i, false);
+ }
+ }
+ *pushNewline() {
+ const ch = this.buffer[this.pos];
+ if (ch === "\n")
+ return yield* this.pushCount(1);
+ else if (ch === "\r" && this.charAt(1) === "\n")
+ return yield* this.pushCount(2);
+ else
+ return 0;
+ }
+ *pushSpaces(allowTabs) {
+ let i = this.pos - 1;
+ let ch;
+ do {
+ ch = this.buffer[++i];
+ } while (ch === " " || allowTabs && ch === " ");
+ const n = i - this.pos;
+ if (n > 0) {
+ yield this.buffer.substr(this.pos, n);
+ this.pos = i;
+ }
+ return n;
+ }
+ *pushUntil(test) {
+ let i = this.pos;
+ let ch = this.buffer[i];
+ while (!test(ch))
+ ch = this.buffer[++i];
+ return yield* this.pushToIndex(i, false);
+ }
+};
+
+// node_modules/yaml/browser/dist/parse/line-counter.js
+var LineCounter = class {
+ constructor() {
+ this.lineStarts = [];
+ this.addNewLine = (offset) => this.lineStarts.push(offset);
+ this.linePos = (offset) => {
+ let low = 0;
+ let high = this.lineStarts.length;
+ while (low < high) {
+ const mid = low + high >> 1;
+ if (this.lineStarts[mid] < offset)
+ low = mid + 1;
+ else
+ high = mid;
+ }
+ if (this.lineStarts[low] === offset)
+ return { line: low + 1, col: 1 };
+ if (low === 0)
+ return { line: 0, col: offset };
+ const start = this.lineStarts[low - 1];
+ return { line: low, col: offset - start + 1 };
+ };
+ }
+};
+
+// node_modules/yaml/browser/dist/parse/parser.js
+function includesToken(list, type) {
+ for (let i = 0; i < list.length; ++i)
+ if (list[i].type === type)
+ return true;
+ return false;
+}
+function findNonEmptyIndex(list) {
+ for (let i = 0; i < list.length; ++i) {
+ switch (list[i].type) {
+ case "space":
+ case "comment":
+ case "newline":
+ break;
+ default:
+ return i;
+ }
+ }
+ return -1;
+}
+function isFlowToken(token) {
+ switch (token == null ? void 0 : token.type) {
+ case "alias":
+ case "scalar":
+ case "single-quoted-scalar":
+ case "double-quoted-scalar":
+ case "flow-collection":
+ return true;
+ default:
+ return false;
+ }
+}
+function getPrevProps(parent) {
+ var _a;
+ switch (parent.type) {
+ case "document":
+ return parent.start;
+ case "block-map": {
+ const it = parent.items[parent.items.length - 1];
+ return (_a = it.sep) != null ? _a : it.start;
+ }
+ case "block-seq":
+ return parent.items[parent.items.length - 1].start;
+ default:
+ return [];
+ }
+}
+function getFirstKeyStartProps(prev) {
+ var _a;
+ if (prev.length === 0)
+ return [];
+ let i = prev.length;
+ loop:
+ while (--i >= 0) {
+ switch (prev[i].type) {
+ case "doc-start":
+ case "explicit-key-ind":
+ case "map-value-ind":
+ case "seq-item-ind":
+ case "newline":
+ break loop;
+ }
+ }
+ while (((_a = prev[++i]) == null ? void 0 : _a.type) === "space") {
+ }
+ return prev.splice(i, prev.length);
+}
+function fixFlowSeqItems(fc) {
+ if (fc.start.type === "flow-seq-start") {
+ for (const it of fc.items) {
+ if (it.sep && !it.value && !includesToken(it.start, "explicit-key-ind") && !includesToken(it.sep, "map-value-ind")) {
+ if (it.key)
+ it.value = it.key;
+ delete it.key;
+ if (isFlowToken(it.value)) {
+ if (it.value.end)
+ Array.prototype.push.apply(it.value.end, it.sep);
+ else
+ it.value.end = it.sep;
+ } else
+ Array.prototype.push.apply(it.start, it.sep);
+ delete it.sep;
+ }
+ }
+ }
+}
+var Parser = class {
+ constructor(onNewLine) {
+ this.atNewLine = true;
+ this.atScalar = false;
+ this.indent = 0;
+ this.offset = 0;
+ this.onKeyLine = false;
+ this.stack = [];
+ this.source = "";
+ this.type = "";
+ this.lexer = new Lexer();
+ this.onNewLine = onNewLine;
+ }
+ *parse(source, incomplete = false) {
+ if (this.onNewLine && this.offset === 0)
+ this.onNewLine(0);
+ for (const lexeme of this.lexer.lex(source, incomplete))
+ yield* this.next(lexeme);
+ if (!incomplete)
+ yield* this.end();
+ }
+ *next(source) {
+ this.source = source;
+ if (this.atScalar) {
+ this.atScalar = false;
+ yield* this.step();
+ this.offset += source.length;
+ return;
+ }
+ const type = tokenType(source);
+ if (!type) {
+ const message = `Not a YAML token: ${source}`;
+ yield* this.pop({ type: "error", offset: this.offset, message, source });
+ this.offset += source.length;
+ } else if (type === "scalar") {
+ this.atNewLine = false;
+ this.atScalar = true;
+ this.type = "scalar";
+ } else {
+ this.type = type;
+ yield* this.step();
+ switch (type) {
+ case "newline":
+ this.atNewLine = true;
+ this.indent = 0;
+ if (this.onNewLine)
+ this.onNewLine(this.offset + source.length);
+ break;
+ case "space":
+ if (this.atNewLine && source[0] === " ")
+ this.indent += source.length;
+ break;
+ case "explicit-key-ind":
+ case "map-value-ind":
+ case "seq-item-ind":
+ if (this.atNewLine)
+ this.indent += source.length;
+ break;
+ case "doc-mode":
+ case "flow-error-end":
+ return;
+ default:
+ this.atNewLine = false;
+ }
+ this.offset += source.length;
+ }
+ }
+ *end() {
+ while (this.stack.length > 0)
+ yield* this.pop();
+ }
+ get sourceToken() {
+ const st = {
+ type: this.type,
+ offset: this.offset,
+ indent: this.indent,
+ source: this.source
+ };
+ return st;
+ }
+ *step() {
+ const top = this.peek(1);
+ if (this.type === "doc-end" && (!top || top.type !== "doc-end")) {
+ while (this.stack.length > 0)
+ yield* this.pop();
+ this.stack.push({
+ type: "doc-end",
+ offset: this.offset,
+ source: this.source
+ });
+ return;
+ }
+ if (!top)
+ return yield* this.stream();
+ switch (top.type) {
+ case "document":
+ return yield* this.document(top);
+ case "alias":
+ case "scalar":
+ case "single-quoted-scalar":
+ case "double-quoted-scalar":
+ return yield* this.scalar(top);
+ case "block-scalar":
+ return yield* this.blockScalar(top);
+ case "block-map":
+ return yield* this.blockMap(top);
+ case "block-seq":
+ return yield* this.blockSequence(top);
+ case "flow-collection":
+ return yield* this.flowCollection(top);
+ case "doc-end":
+ return yield* this.documentEnd(top);
+ }
+ yield* this.pop();
+ }
+ peek(n) {
+ return this.stack[this.stack.length - n];
+ }
+ *pop(error) {
+ const token = error != null ? error : this.stack.pop();
+ if (!token) {
+ const message = "Tried to pop an empty stack";
+ yield { type: "error", offset: this.offset, source: "", message };
+ } else if (this.stack.length === 0) {
+ yield token;
+ } else {
+ const top = this.peek(1);
+ if (token.type === "block-scalar") {
+ token.indent = "indent" in top ? top.indent : 0;
+ } else if (token.type === "flow-collection" && top.type === "document") {
+ token.indent = 0;
+ }
+ if (token.type === "flow-collection")
+ fixFlowSeqItems(token);
+ switch (top.type) {
+ case "document":
+ top.value = token;
+ break;
+ case "block-scalar":
+ top.props.push(token);
+ break;
+ case "block-map": {
+ const it = top.items[top.items.length - 1];
+ if (it.value) {
+ top.items.push({ start: [], key: token, sep: [] });
+ this.onKeyLine = true;
+ return;
+ } else if (it.sep) {
+ it.value = token;
+ } else {
+ Object.assign(it, { key: token, sep: [] });
+ this.onKeyLine = !includesToken(it.start, "explicit-key-ind");
+ return;
+ }
+ break;
+ }
+ case "block-seq": {
+ const it = top.items[top.items.length - 1];
+ if (it.value)
+ top.items.push({ start: [], value: token });
+ else
+ it.value = token;
+ break;
+ }
+ case "flow-collection": {
+ const it = top.items[top.items.length - 1];
+ if (!it || it.value)
+ top.items.push({ start: [], key: token, sep: [] });
+ else if (it.sep)
+ it.value = token;
+ else
+ Object.assign(it, { key: token, sep: [] });
+ return;
+ }
+ default:
+ yield* this.pop();
+ yield* this.pop(token);
+ }
+ if ((top.type === "document" || top.type === "block-map" || top.type === "block-seq") && (token.type === "block-map" || token.type === "block-seq")) {
+ const last = token.items[token.items.length - 1];
+ if (last && !last.sep && !last.value && last.start.length > 0 && findNonEmptyIndex(last.start) === -1 && (token.indent === 0 || last.start.every((st) => st.type !== "comment" || st.indent < token.indent))) {
+ if (top.type === "document")
+ top.end = last.start;
+ else
+ top.items.push({ start: last.start });
+ token.items.splice(-1, 1);
+ }
+ }
+ }
+ }
+ *stream() {
+ switch (this.type) {
+ case "directive-line":
+ yield { type: "directive", offset: this.offset, source: this.source };
+ return;
+ case "byte-order-mark":
+ case "space":
+ case "comment":
+ case "newline":
+ yield this.sourceToken;
+ return;
+ case "doc-mode":
+ case "doc-start": {
+ const doc = {
+ type: "document",
+ offset: this.offset,
+ start: []
+ };
+ if (this.type === "doc-start")
+ doc.start.push(this.sourceToken);
+ this.stack.push(doc);
+ return;
+ }
+ }
+ yield {
+ type: "error",
+ offset: this.offset,
+ message: `Unexpected ${this.type} token in YAML stream`,
+ source: this.source
+ };
+ }
+ *document(doc) {
+ if (doc.value)
+ return yield* this.lineEnd(doc);
+ switch (this.type) {
+ case "doc-start": {
+ if (findNonEmptyIndex(doc.start) !== -1) {
+ yield* this.pop();
+ yield* this.step();
+ } else
+ doc.start.push(this.sourceToken);
+ return;
+ }
+ case "anchor":
+ case "tag":
+ case "space":
+ case "comment":
+ case "newline":
+ doc.start.push(this.sourceToken);
+ return;
+ }
+ const bv = this.startBlockValue(doc);
+ if (bv)
+ this.stack.push(bv);
+ else {
+ yield {
+ type: "error",
+ offset: this.offset,
+ message: `Unexpected ${this.type} token in YAML document`,
+ source: this.source
+ };
+ }
+ }
+ *scalar(scalar) {
+ if (this.type === "map-value-ind") {
+ const prev = getPrevProps(this.peek(2));
+ const start = getFirstKeyStartProps(prev);
+ let sep;
+ if (scalar.end) {
+ sep = scalar.end;
+ sep.push(this.sourceToken);
+ delete scalar.end;
+ } else
+ sep = [this.sourceToken];
+ const map2 = {
+ type: "block-map",
+ offset: scalar.offset,
+ indent: scalar.indent,
+ items: [{ start, key: scalar, sep }]
+ };
+ this.onKeyLine = true;
+ this.stack[this.stack.length - 1] = map2;
+ } else
+ yield* this.lineEnd(scalar);
+ }
+ *blockScalar(scalar) {
+ switch (this.type) {
+ case "space":
+ case "comment":
+ case "newline":
+ scalar.props.push(this.sourceToken);
+ return;
+ case "scalar":
+ scalar.source = this.source;
+ this.atNewLine = true;
+ this.indent = 0;
+ if (this.onNewLine) {
+ let nl = this.source.indexOf("\n") + 1;
+ while (nl !== 0) {
+ this.onNewLine(this.offset + nl);
+ nl = this.source.indexOf("\n", nl) + 1;
+ }
+ }
+ yield* this.pop();
+ break;
+ default:
+ yield* this.pop();
+ yield* this.step();
+ }
+ }
+ *blockMap(map2) {
+ var _a;
+ const it = map2.items[map2.items.length - 1];
+ switch (this.type) {
+ case "newline":
+ this.onKeyLine = false;
+ if (it.value) {
+ const end = "end" in it.value ? it.value.end : void 0;
+ const last = Array.isArray(end) ? end[end.length - 1] : void 0;
+ if ((last == null ? void 0 : last.type) === "comment")
+ end == null ? void 0 : end.push(this.sourceToken);
+ else
+ map2.items.push({ start: [this.sourceToken] });
+ } else if (it.sep) {
+ it.sep.push(this.sourceToken);
+ } else {
+ it.start.push(this.sourceToken);
+ }
+ return;
+ case "space":
+ case "comment":
+ if (it.value) {
+ map2.items.push({ start: [this.sourceToken] });
+ } else if (it.sep) {
+ it.sep.push(this.sourceToken);
+ } else {
+ if (this.atIndentedComment(it.start, map2.indent)) {
+ const prev = map2.items[map2.items.length - 2];
+ const end = (_a = prev == null ? void 0 : prev.value) == null ? void 0 : _a.end;
+ if (Array.isArray(end)) {
+ Array.prototype.push.apply(end, it.start);
+ end.push(this.sourceToken);
+ map2.items.pop();
+ return;
+ }
+ }
+ it.start.push(this.sourceToken);
+ }
+ return;
+ }
+ if (this.indent >= map2.indent) {
+ const atNextItem = !this.onKeyLine && this.indent === map2.indent && it.sep;
+ let start = [];
+ if (atNextItem && it.sep && !it.value) {
+ const nl = [];
+ for (let i = 0; i < it.sep.length; ++i) {
+ const st = it.sep[i];
+ switch (st.type) {
+ case "newline":
+ nl.push(i);
+ break;
+ case "space":
+ break;
+ case "comment":
+ if (st.indent > map2.indent)
+ nl.length = 0;
+ break;
+ default:
+ nl.length = 0;
+ }
+ }
+ if (nl.length >= 2)
+ start = it.sep.splice(nl[1]);
+ }
+ switch (this.type) {
+ case "anchor":
+ case "tag":
+ if (atNextItem || it.value) {
+ start.push(this.sourceToken);
+ map2.items.push({ start });
+ this.onKeyLine = true;
+ } else if (it.sep) {
+ it.sep.push(this.sourceToken);
+ } else {
+ it.start.push(this.sourceToken);
+ }
+ return;
+ case "explicit-key-ind":
+ if (!it.sep && !includesToken(it.start, "explicit-key-ind")) {
+ it.start.push(this.sourceToken);
+ } else if (atNextItem || it.value) {
+ start.push(this.sourceToken);
+ map2.items.push({ start });
+ } else {
+ this.stack.push({
+ type: "block-map",
+ offset: this.offset,
+ indent: this.indent,
+ items: [{ start: [this.sourceToken] }]
+ });
+ }
+ this.onKeyLine = true;
+ return;
+ case "map-value-ind":
+ if (includesToken(it.start, "explicit-key-ind")) {
+ if (!it.sep) {
+ if (includesToken(it.start, "newline")) {
+ Object.assign(it, { key: null, sep: [this.sourceToken] });
+ } else {
+ const start2 = getFirstKeyStartProps(it.start);
+ this.stack.push({
+ type: "block-map",
+ offset: this.offset,
+ indent: this.indent,
+ items: [{ start: start2, key: null, sep: [this.sourceToken] }]
+ });
+ }
+ } else if (it.value) {
+ map2.items.push({ start: [], key: null, sep: [this.sourceToken] });
+ } else if (includesToken(it.sep, "map-value-ind")) {
+ this.stack.push({
+ type: "block-map",
+ offset: this.offset,
+ indent: this.indent,
+ items: [{ start, key: null, sep: [this.sourceToken] }]
+ });
+ } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
+ const start2 = getFirstKeyStartProps(it.start);
+ const key = it.key;
+ const sep = it.sep;
+ sep.push(this.sourceToken);
+ delete it.key, delete it.sep;
+ this.stack.push({
+ type: "block-map",
+ offset: this.offset,
+ indent: this.indent,
+ items: [{ start: start2, key, sep }]
+ });
+ } else if (start.length > 0) {
+ it.sep = it.sep.concat(start, this.sourceToken);
+ } else {
+ it.sep.push(this.sourceToken);
+ }
+ } else {
+ if (!it.sep) {
+ Object.assign(it, { key: null, sep: [this.sourceToken] });
+ } else if (it.value || atNextItem) {
+ map2.items.push({ start, key: null, sep: [this.sourceToken] });
+ } else if (includesToken(it.sep, "map-value-ind")) {
+ this.stack.push({
+ type: "block-map",
+ offset: this.offset,
+ indent: this.indent,
+ items: [{ start: [], key: null, sep: [this.sourceToken] }]
+ });
+ } else {
+ it.sep.push(this.sourceToken);
+ }
+ }
+ this.onKeyLine = true;
+ return;
+ case "alias":
+ case "scalar":
+ case "single-quoted-scalar":
+ case "double-quoted-scalar": {
+ const fs5 = this.flowScalar(this.type);
+ if (atNextItem || it.value) {
+ map2.items.push({ start, key: fs5, sep: [] });
+ this.onKeyLine = true;
+ } else if (it.sep) {
+ this.stack.push(fs5);
+ } else {
+ Object.assign(it, { key: fs5, sep: [] });
+ this.onKeyLine = true;
+ }
+ return;
+ }
+ default: {
+ const bv = this.startBlockValue(map2);
+ if (bv) {
+ if (atNextItem && bv.type !== "block-seq" && includesToken(it.start, "explicit-key-ind")) {
+ map2.items.push({ start });
+ }
+ this.stack.push(bv);
+ return;
+ }
+ }
+ }
+ }
+ yield* this.pop();
+ yield* this.step();
+ }
+ *blockSequence(seq2) {
+ var _a;
+ const it = seq2.items[seq2.items.length - 1];
+ switch (this.type) {
+ case "newline":
+ if (it.value) {
+ const end = "end" in it.value ? it.value.end : void 0;
+ const last = Array.isArray(end) ? end[end.length - 1] : void 0;
+ if ((last == null ? void 0 : last.type) === "comment")
+ end == null ? void 0 : end.push(this.sourceToken);
+ else
+ seq2.items.push({ start: [this.sourceToken] });
+ } else
+ it.start.push(this.sourceToken);
+ return;
+ case "space":
+ case "comment":
+ if (it.value)
+ seq2.items.push({ start: [this.sourceToken] });
+ else {
+ if (this.atIndentedComment(it.start, seq2.indent)) {
+ const prev = seq2.items[seq2.items.length - 2];
+ const end = (_a = prev == null ? void 0 : prev.value) == null ? void 0 : _a.end;
+ if (Array.isArray(end)) {
+ Array.prototype.push.apply(end, it.start);
+ end.push(this.sourceToken);
+ seq2.items.pop();
+ return;
+ }
+ }
+ it.start.push(this.sourceToken);
+ }
+ return;
+ case "anchor":
+ case "tag":
+ if (it.value || this.indent <= seq2.indent)
+ break;
+ it.start.push(this.sourceToken);
+ return;
+ case "seq-item-ind":
+ if (this.indent !== seq2.indent)
+ break;
+ if (it.value || includesToken(it.start, "seq-item-ind"))
+ seq2.items.push({ start: [this.sourceToken] });
+ else
+ it.start.push(this.sourceToken);
+ return;
+ }
+ if (this.indent > seq2.indent) {
+ const bv = this.startBlockValue(seq2);
+ if (bv) {
+ this.stack.push(bv);
+ return;
+ }
+ }
+ yield* this.pop();
+ yield* this.step();
+ }
+ *flowCollection(fc) {
+ const it = fc.items[fc.items.length - 1];
+ if (this.type === "flow-error-end") {
+ let top;
+ do {
+ yield* this.pop();
+ top = this.peek(1);
+ } while (top && top.type === "flow-collection");
+ } else if (fc.end.length === 0) {
+ switch (this.type) {
+ case "comma":
+ case "explicit-key-ind":
+ if (!it || it.sep)
+ fc.items.push({ start: [this.sourceToken] });
+ else
+ it.start.push(this.sourceToken);
+ return;
+ case "map-value-ind":
+ if (!it || it.value)
+ fc.items.push({ start: [], key: null, sep: [this.sourceToken] });
+ else if (it.sep)
+ it.sep.push(this.sourceToken);
+ else
+ Object.assign(it, { key: null, sep: [this.sourceToken] });
+ return;
+ case "space":
+ case "comment":
+ case "newline":
+ case "anchor":
+ case "tag":
+ if (!it || it.value)
+ fc.items.push({ start: [this.sourceToken] });
+ else if (it.sep)
+ it.sep.push(this.sourceToken);
+ else
+ it.start.push(this.sourceToken);
+ return;
+ case "alias":
+ case "scalar":
+ case "single-quoted-scalar":
+ case "double-quoted-scalar": {
+ const fs5 = this.flowScalar(this.type);
+ if (!it || it.value)
+ fc.items.push({ start: [], key: fs5, sep: [] });
+ else if (it.sep)
+ this.stack.push(fs5);
+ else
+ Object.assign(it, { key: fs5, sep: [] });
+ return;
+ }
+ case "flow-map-end":
+ case "flow-seq-end":
+ fc.end.push(this.sourceToken);
+ return;
+ }
+ const bv = this.startBlockValue(fc);
+ if (bv)
+ this.stack.push(bv);
+ else {
+ yield* this.pop();
+ yield* this.step();
+ }
+ } else {
+ const parent = this.peek(2);
+ if (parent.type === "block-map" && (this.type === "map-value-ind" && parent.indent === fc.indent || this.type === "newline" && !parent.items[parent.items.length - 1].sep)) {
+ yield* this.pop();
+ yield* this.step();
+ } else if (this.type === "map-value-ind" && parent.type !== "flow-collection") {
+ const prev = getPrevProps(parent);
+ const start = getFirstKeyStartProps(prev);
+ fixFlowSeqItems(fc);
+ const sep = fc.end.splice(1, fc.end.length);
+ sep.push(this.sourceToken);
+ const map2 = {
+ type: "block-map",
+ offset: fc.offset,
+ indent: fc.indent,
+ items: [{ start, key: fc, sep }]
+ };
+ this.onKeyLine = true;
+ this.stack[this.stack.length - 1] = map2;
+ } else {
+ yield* this.lineEnd(fc);
+ }
+ }
+ }
+ flowScalar(type) {
+ if (this.onNewLine) {
+ let nl = this.source.indexOf("\n") + 1;
+ while (nl !== 0) {
+ this.onNewLine(this.offset + nl);
+ nl = this.source.indexOf("\n", nl) + 1;
+ }
+ }
+ return {
+ type,
+ offset: this.offset,
+ indent: this.indent,
+ source: this.source
+ };
+ }
+ startBlockValue(parent) {
+ switch (this.type) {
+ case "alias":
+ case "scalar":
+ case "single-quoted-scalar":
+ case "double-quoted-scalar":
+ return this.flowScalar(this.type);
+ case "block-scalar-header":
+ return {
+ type: "block-scalar",
+ offset: this.offset,
+ indent: this.indent,
+ props: [this.sourceToken],
+ source: ""
+ };
+ case "flow-map-start":
+ case "flow-seq-start":
+ return {
+ type: "flow-collection",
+ offset: this.offset,
+ indent: this.indent,
+ start: this.sourceToken,
+ items: [],
+ end: []
+ };
+ case "seq-item-ind":
+ return {
+ type: "block-seq",
+ offset: this.offset,
+ indent: this.indent,
+ items: [{ start: [this.sourceToken] }]
+ };
+ case "explicit-key-ind": {
+ this.onKeyLine = true;
+ const prev = getPrevProps(parent);
+ const start = getFirstKeyStartProps(prev);
+ start.push(this.sourceToken);
+ return {
+ type: "block-map",
+ offset: this.offset,
+ indent: this.indent,
+ items: [{ start }]
+ };
+ }
+ case "map-value-ind": {
+ this.onKeyLine = true;
+ const prev = getPrevProps(parent);
+ const start = getFirstKeyStartProps(prev);
+ return {
+ type: "block-map",
+ offset: this.offset,
+ indent: this.indent,
+ items: [{ start, key: null, sep: [this.sourceToken] }]
+ };
+ }
+ }
+ return null;
+ }
+ atIndentedComment(start, indent) {
+ if (this.type !== "comment")
+ return false;
+ if (this.indent <= indent)
+ return false;
+ return start.every((st) => st.type === "newline" || st.type === "space");
+ }
+ *documentEnd(docEnd) {
+ if (this.type !== "doc-mode") {
+ if (docEnd.end)
+ docEnd.end.push(this.sourceToken);
+ else
+ docEnd.end = [this.sourceToken];
+ if (this.type === "newline")
+ yield* this.pop();
+ }
+ }
+ *lineEnd(token) {
+ switch (this.type) {
+ case "comma":
+ case "doc-start":
+ case "doc-end":
+ case "flow-seq-end":
+ case "flow-map-end":
+ case "map-value-ind":
+ yield* this.pop();
+ yield* this.step();
+ break;
+ case "newline":
+ this.onKeyLine = false;
+ case "space":
+ case "comment":
+ default:
+ if (token.end)
+ token.end.push(this.sourceToken);
+ else
+ token.end = [this.sourceToken];
+ if (this.type === "newline")
+ yield* this.pop();
+ }
+ }
+};
+
+// node_modules/yaml/browser/dist/public-api.js
+function parseOptions(options) {
+ const prettyErrors = options.prettyErrors !== false;
+ const lineCounter = options.lineCounter || prettyErrors && new LineCounter() || null;
+ return { lineCounter, prettyErrors };
+}
+function parseDocument(source, options = {}) {
+ const { lineCounter, prettyErrors } = parseOptions(options);
+ const parser = new Parser(lineCounter == null ? void 0 : lineCounter.addNewLine);
+ const composer = new Composer(options);
+ let doc = null;
+ for (const _doc of composer.compose(parser.parse(source), true, source.length)) {
+ if (!doc)
+ doc = _doc;
+ else if (doc.options.logLevel !== "silent") {
+ doc.errors.push(new YAMLParseError(_doc.range.slice(0, 2), "MULTIPLE_DOCS", "Source contains multiple documents; please use YAML.parseAllDocuments()"));
+ break;
+ }
+ }
+ if (prettyErrors && lineCounter) {
+ doc.errors.forEach(prettifyError(source, lineCounter));
+ doc.warnings.forEach(prettifyError(source, lineCounter));
+ }
+ return doc;
+}
+function parse(src, reviver, options) {
+ let _reviver = void 0;
+ if (typeof reviver === "function") {
+ _reviver = reviver;
+ } else if (options === void 0 && reviver && typeof reviver === "object") {
+ options = reviver;
+ }
+ const doc = parseDocument(src, options);
+ if (!doc)
+ return null;
+ doc.warnings.forEach((warning) => warn(doc.options.logLevel, warning));
+ if (doc.errors.length > 0) {
+ if (doc.options.logLevel !== "silent")
+ throw doc.errors[0];
+ else
+ doc.errors = [];
+ }
+ return doc.toJS(Object.assign({ reviver: _reviver }, options));
+}
+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);
+}
+
+// main.ts
+var temp = __toModule(require_temp());
+
+// renderer.ts
+var path2 = __toModule(require("path"));
+var fs2 = __toModule(require("fs"));
+
+// node_modules/js-base64/base64.mjs
+var version = "3.7.2";
+var VERSION = version;
+var _hasatob = typeof atob === "function";
+var _hasbtoa = typeof btoa === "function";
+var _hasBuffer = typeof Buffer === "function";
+var _TD = typeof TextDecoder === "function" ? new TextDecoder() : void 0;
+var _TE = typeof TextEncoder === "function" ? new TextEncoder() : void 0;
+var b64ch = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+var b64chs = Array.prototype.slice.call(b64ch);
+var b64tab = ((a) => {
+ let tab = {};
+ a.forEach((c, i) => tab[c] = i);
+ return tab;
+})(b64chs);
+var b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
+var _fromCC = String.fromCharCode.bind(String);
+var _U8Afrom = typeof Uint8Array.from === "function" ? Uint8Array.from.bind(Uint8Array) : (it, fn = (x) => x) => new Uint8Array(Array.prototype.slice.call(it, 0).map(fn));
+var _mkUriSafe = (src) => src.replace(/=/g, "").replace(/[+\/]/g, (m0) => m0 == "+" ? "-" : "_");
+var _tidyB64 = (s) => s.replace(/[^A-Za-z0-9\+\/]/g, "");
+var btoaPolyfill = (bin) => {
+ let u32, c0, c1, c2, asc = "";
+ const pad = bin.length % 3;
+ for (let i = 0; i < bin.length; ) {
+ if ((c0 = bin.charCodeAt(i++)) > 255 || (c1 = bin.charCodeAt(i++)) > 255 || (c2 = bin.charCodeAt(i++)) > 255)
+ throw new TypeError("invalid character found");
+ u32 = c0 << 16 | c1 << 8 | c2;
+ asc += b64chs[u32 >> 18 & 63] + b64chs[u32 >> 12 & 63] + b64chs[u32 >> 6 & 63] + b64chs[u32 & 63];
+ }
+ return pad ? asc.slice(0, pad - 3) + "===".substring(pad) : asc;
+};
+var _btoa = _hasbtoa ? (bin) => btoa(bin) : _hasBuffer ? (bin) => Buffer.from(bin, "binary").toString("base64") : btoaPolyfill;
+var _fromUint8Array = _hasBuffer ? (u8a) => Buffer.from(u8a).toString("base64") : (u8a) => {
+ const maxargs = 4096;
+ let strs = [];
+ for (let i = 0, l = u8a.length; i < l; i += maxargs) {
+ strs.push(_fromCC.apply(null, u8a.subarray(i, i + maxargs)));
+ }
+ return _btoa(strs.join(""));
+};
+var fromUint8Array = (u8a, urlsafe = false) => urlsafe ? _mkUriSafe(_fromUint8Array(u8a)) : _fromUint8Array(u8a);
+var cb_utob = (c) => {
+ if (c.length < 2) {
+ var cc = c.charCodeAt(0);
+ return cc < 128 ? c : cc < 2048 ? _fromCC(192 | cc >>> 6) + _fromCC(128 | cc & 63) : _fromCC(224 | cc >>> 12 & 15) + _fromCC(128 | cc >>> 6 & 63) + _fromCC(128 | cc & 63);
+ } else {
+ var cc = 65536 + (c.charCodeAt(0) - 55296) * 1024 + (c.charCodeAt(1) - 56320);
+ return _fromCC(240 | cc >>> 18 & 7) + _fromCC(128 | cc >>> 12 & 63) + _fromCC(128 | cc >>> 6 & 63) + _fromCC(128 | cc & 63);
+ }
+};
+var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
+var utob = (u) => u.replace(re_utob, cb_utob);
+var _encode = _hasBuffer ? (s) => Buffer.from(s, "utf8").toString("base64") : _TE ? (s) => _fromUint8Array(_TE.encode(s)) : (s) => _btoa(utob(s));
+var encode = (src, urlsafe = false) => urlsafe ? _mkUriSafe(_encode(src)) : _encode(src);
+var encodeURI = (src) => encode(src, true);
+var re_btou = /[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g;
+var cb_btou = (cccc) => {
+ switch (cccc.length) {
+ case 4:
+ var cp = (7 & cccc.charCodeAt(0)) << 18 | (63 & cccc.charCodeAt(1)) << 12 | (63 & cccc.charCodeAt(2)) << 6 | 63 & cccc.charCodeAt(3), offset = cp - 65536;
+ return _fromCC((offset >>> 10) + 55296) + _fromCC((offset & 1023) + 56320);
+ case 3:
+ return _fromCC((15 & cccc.charCodeAt(0)) << 12 | (63 & cccc.charCodeAt(1)) << 6 | 63 & cccc.charCodeAt(2));
+ default:
+ return _fromCC((31 & cccc.charCodeAt(0)) << 6 | 63 & cccc.charCodeAt(1));
+ }
+};
+var btou = (b) => b.replace(re_btou, cb_btou);
+var atobPolyfill = (asc) => {
+ asc = asc.replace(/\s+/g, "");
+ if (!b64re.test(asc))
+ throw new TypeError("malformed base64.");
+ asc += "==".slice(2 - (asc.length & 3));
+ let u24, bin = "", r1, r2;
+ for (let i = 0; i < asc.length; ) {
+ u24 = b64tab[asc.charAt(i++)] << 18 | b64tab[asc.charAt(i++)] << 12 | (r1 = b64tab[asc.charAt(i++)]) << 6 | (r2 = b64tab[asc.charAt(i++)]);
+ bin += r1 === 64 ? _fromCC(u24 >> 16 & 255) : r2 === 64 ? _fromCC(u24 >> 16 & 255, u24 >> 8 & 255) : _fromCC(u24 >> 16 & 255, u24 >> 8 & 255, u24 & 255);
+ }
+ return bin;
+};
+var _atob = _hasatob ? (asc) => atob(_tidyB64(asc)) : _hasBuffer ? (asc) => Buffer.from(asc, "base64").toString("binary") : atobPolyfill;
+var _toUint8Array = _hasBuffer ? (a) => _U8Afrom(Buffer.from(a, "base64")) : (a) => _U8Afrom(_atob(a), (c) => c.charCodeAt(0));
+var toUint8Array = (a) => _toUint8Array(_unURI(a));
+var _decode = _hasBuffer ? (a) => Buffer.from(a, "base64").toString("utf8") : _TD ? (a) => _TD.decode(_toUint8Array(a)) : (a) => btou(_atob(a));
+var _unURI = (a) => _tidyB64(a.replace(/[-_]/g, (m0) => m0 == "-" ? "+" : "/"));
+var decode = (src) => _decode(_unURI(src));
+var isValid = (src) => {
+ if (typeof src !== "string")
+ return false;
+ const s = src.replace(/\s+/g, "").replace(/={0,2}$/, "");
+ return !/[^\s0-9a-zA-Z\+/]/.test(s) || !/[^\s0-9a-zA-Z\-_]/.test(s);
+};
+var _noEnum = (v) => {
+ return {
+ value: v,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ };
+};
+var extendString = function() {
+ const _add = (name, body2) => Object.defineProperty(String.prototype, name, _noEnum(body2));
+ _add("fromBase64", function() {
+ return decode(this);
+ });
+ _add("toBase64", function(urlsafe) {
+ return encode(this, urlsafe);
+ });
+ _add("toBase64URI", function() {
+ return encode(this, true);
+ });
+ _add("toBase64URL", function() {
+ return encode(this, true);
+ });
+ _add("toUint8Array", function() {
+ return toUint8Array(this);
+ });
+};
+var extendUint8Array = function() {
+ const _add = (name, body2) => Object.defineProperty(Uint8Array.prototype, name, _noEnum(body2));
+ _add("toBase64", function(urlsafe) {
+ return fromUint8Array(this, urlsafe);
+ });
+ _add("toBase64URI", function() {
+ return fromUint8Array(this, true);
+ });
+ _add("toBase64URL", function() {
+ return fromUint8Array(this, true);
+ });
+};
+var extendBuiltins = () => {
+ extendString();
+ extendUint8Array();
+};
+var gBase64 = {
+ version,
+ VERSION,
+ atob: _atob,
+ atobPolyfill,
+ btoa: _btoa,
+ btoaPolyfill,
+ fromBase64: decode,
+ toBase64: encode,
+ encode,
+ encodeURI,
+ encodeURL: encodeURI,
+ utob,
+ btou,
+ decode,
+ isValid,
+ fromUint8Array,
+ toUint8Array,
+ extendString,
+ extendUint8Array,
+ extendBuiltins
+};
+
+// renderer.ts
+var import_obsidian = __toModule(require("obsidian"));
+
+// styles/mathjax-css.ts
+var mathjax_css_default = `
+@font-face /* 0 */ {
+ font-family: MJXZERO;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Zero.woff") format("woff");
+}
+
+@font-face /* 1 */ {
+ font-family: MJXTEX;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Main-Regular.woff") format("woff");
+}
+
+@font-face /* 2 */ {
+ font-family: MJXTEX-B;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Main-Bold.woff") format("woff");
+}
+
+@font-face /* 3 */ {
+ font-family: MJXTEX-I;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Math-Italic.woff") format("woff");
+}
+
+@font-face /* 4 */ {
+ font-family: MJXTEX-MI;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Main-Italic.woff") format("woff");
+}
+
+@font-face /* 5 */ {
+ font-family: MJXTEX-BI;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Math-BoldItalic.woff") format("woff");
+}
+
+@font-face /* 6 */ {
+ font-family: MJXTEX-S1;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Size1-Regular.woff") format("woff");
+}
+
+@font-face /* 7 */ {
+ font-family: MJXTEX-S2;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Size2-Regular.woff") format("woff");
+}
+
+@font-face /* 8 */ {
+ font-family: MJXTEX-S3;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Size3-Regular.woff") format("woff");
+}
+
+@font-face /* 9 */ {
+ font-family: MJXTEX-S4;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Size4-Regular.woff") format("woff");
+}
+
+@font-face /* 10 */ {
+ font-family: MJXTEX-A;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_AMS-Regular.woff") format("woff");
+}
+
+@font-face /* 11 */ {
+ font-family: MJXTEX-C;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Calligraphic-Regular.woff") format("woff");
+}
+
+@font-face /* 12 */ {
+ font-family: MJXTEX-CB;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Calligraphic-Bold.woff") format("woff");
+}
+
+@font-face /* 13 */ {
+ font-family: MJXTEX-FR;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Fraktur-Regular.woff") format("woff");
+}
+
+@font-face /* 14 */ {
+ font-family: MJXTEX-FRB;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Fraktur-Bold.woff") format("woff");
+}
+
+@font-face /* 15 */ {
+ font-family: MJXTEX-SS;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_SansSerif-Regular.woff") format("woff");
+}
+
+@font-face /* 16 */ {
+ font-family: MJXTEX-SSB;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_SansSerif-Bold.woff") format("woff");
+}
+
+@font-face /* 17 */ {
+ font-family: MJXTEX-SSI;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_SansSerif-Italic.woff") format("woff");
+}
+
+@font-face /* 18 */ {
+ font-family: MJXTEX-SC;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Script-Regular.woff") format("woff");
+}
+
+@font-face /* 19 */ {
+ font-family: MJXTEX-T;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Typewriter-Regular.woff") format("woff");
+}
+
+@font-face /* 20 */ {
+ font-family: MJXTEX-V;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Vector-Regular.woff") format("woff");
+}
+
+@font-face /* 21 */ {
+ font-family: MJXTEX-VB;
+ src: url("http://cdn.mathjax.org/mathjax/latest/fonts/HTML-CSS/TeX/woff/MathJax_Vector-Bold.woff") format("woff");
+}`;
+
+// styles/app-css.ts
+function variables(light = true) {
+ if (light)
+ return `
+:root {
+ --default-font: 'Inter', -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Microsoft YaHei Light", sans-serif;
+ --font-monospace: 'Source Code Pro', monospace;
+ --background-primary: #ffffff;
+ --background-modifier-border: #ddd;
+ --text-accent: #705dcf;
+ --text-accent-hover: #7a6ae6;
+ --text-normal: #2e3338;
+ --background-secondary: #f2f3f5;
+ --background-secondary-alt: #e3e5e8;
+ --text-muted: #888888;
+}`;
+ else
+ return `
+:root {
+ --background-primary: #202020;
+ --background-modifier-border: #333;
+ --text-accent: #7f6df2;
+ --text-accent-hover: #8875ff;
+ --text-normal: #dcddde;
+ --background-secondary: #161616;
+ --background-secondary-alt: #000000;
+ --text-muted: #999;
+}
+`;
+}
+function app_css_default(light = true) {
+ return variables(light) + body();
+}
+function body() {
+ return `
+pre, code {
+ font-family: var(--font-monospace);
+}
+h1, h2, h3, h4, h5, h6 {
+ font-weight: 800;
+}
+a {
+ color: var(--text-accent);
+ outline: none;
+}
+a:hover {
+ color: var(--text-accent-hover);
+}
+audio {
+ outline: none;
+}
+hr {
+ border: none;
+ border-top: 1px solid;
+ border-color: var(--background-modifier-border);
+ margin: 26px 0;
+}
+* {
+ box-sizing: border-box;
+}
+body {
+ text-rendering: optimizeLegibility;
+ font-family: var(--default-font);
+ line-height: 1.5em;
+ font-size: 16px;
+ background-color: var(--background-primary);
+ color: var(--text-normal);
+}
+ul ul, ol ul, ol ul, ul ol {
+ list-style-type: disc;
+}
+
+
+
+ /* PrismJS 1.20.0
+https://prismjs.com/download.html#themes=prism&languages=markup+css+clike+javascript+abap+abnf+actionscript+ada+al+antlr4+apacheconf+apl+applescript+aql+arduino+arff+asciidoc+asm6502+aspnet+autohotkey+autoit+bash+basic+batch+bbcode+bison+bnf+brainfuck+brightscript+bro+c+concurnas+csharp+cpp+cil+coffeescript+cmake+clojure+crystal+csp+css-extras+d+dart+dax+diff+django+dns-zone-file+docker+ebnf+eiffel+ejs+elixir+elm+etlua+erb+erlang+excel-formula+fsharp+factor+firestore-security-rules+flow+fortran+ftl+gcode+gdscript+gedcom+gherkin+git+glsl+gml+go+graphql+groovy+haml+handlebars+haskell+haxe+hcl+hlsl+http+hpkp+hsts+ichigojam+icon+iecst+inform7+ini+io+j+java+javadoc+javadoclike+javastacktrace+jolie+jq+jsdoc+js-extras+js-templates+json+jsonp+json5+julia+keyman+kotlin+latex+latte+less+lilypond+liquid+lisp+livescript+llvm+lolcode+lua+makefile+markdown+markup-templating+matlab+mel+mizar+monkey+moonscript+n1ql+n4js+nand2tetris-hdl+nasm+neon+nginx+nim+nix+nsis+objectivec+ocaml+opencl+oz+parigp+parser+pascal+pascaligo+pcaxis+peoplecode+perl+php+phpdoc+php-extras+plsql+powerquery+powershell+processing+prolog+properties+protobuf+pug+puppet+pure+purebasic+python+q+qml+qore+r+racket+jsx+tsx+renpy+reason+regex+rest+rip+roboconf+robotframework+ruby+rust+sas+sass+scss+scala+scheme+shell-session+smalltalk+smarty+solidity+solution-file+soy+sparql+splunk-spl+sqf+sql+stylus+swift+tap+tcl+textile+toml+tt2+turtle+twig+typescript+t4-cs+t4-vb+t4-templating+unrealscript+vala+vbnet+velocity+verilog+vhdl+vim+visual-basic+warpscript+wasm+wiki+xeora+xml-doc+xojo+xquery+yaml+zig */
+ /**
+ * prism.js default theme for JavaScript, CSS and HTML
+ * Based on dabblet (http://dabblet.com)
+ * @author Lea Verou
+ */
+ /* Code blocks */
+ /* Inline code */
+code[class*="language-"],
+pre[class*="language-"] {
+ color: black;
+ background: none;
+ text-shadow: 0 1px white;
+ font-family: var(--font-monospace);
+ text-align: left;
+ white-space: pre;
+ word-spacing: normal;
+ word-break: normal;
+ word-wrap: normal;
+ line-height: 1.5;
+ -moz-tab-size: 4;
+ -o-tab-size: 4;
+ tab-size: 4;
+ -webkit-hyphens: none;
+ -moz-hyphens: none;
+ -ms-hyphens: none;
+ hyphens: none;
+}
+pre[class*="language-"]::-moz-selection,
+pre[class*="language-"] ::-moz-selection,
+code[class*="language-"]::-moz-selection,
+code[class*="language-"] ::-moz-selection {
+ text-shadow: none;
+ background: #b3d4fc;
+}
+pre[class*="language-"]::selection,
+pre[class*="language-"] ::selection,
+code[class*="language-"]::selection,
+code[class*="language-"] ::selection {
+ text-shadow: none;
+ background: #b3d4fc;
+}
+@media print {
+ code[class*="language-"],
+ pre[class*="language-"] {
+ text-shadow: none;
+ }
+}
+pre[class*="language-"] {
+ padding: 1em;
+ margin: 0.5em 0;
+ overflow: auto;
+}
+:not(pre) > code[class*="language-"],
+pre[class*="language-"] {
+ background: #f5f2f0;
+}
+:not(pre) > code[class*="language-"] {
+ padding: 0.1em;
+ border-radius: 0.3em;
+ white-space: normal;
+}
+.token.comment,
+.token.prolog,
+.token.doctype,
+.token.cdata {
+ color: slategray;
+}
+.token.punctuation {
+ color: #999;
+}
+.token.namespace {
+ opacity: 0.7;
+}
+.token.property,
+.token.tag,
+.token.boolean,
+.token.number,
+.token.constant,
+.token.symbol,
+.token.deleted {
+ color: #905;
+}
+.token.selector,
+.token.attr-name,
+.token.string,
+.token.char,
+.token.builtin,
+.token.inserted {
+ color: #690;
+}
+.token.operator,
+.token.entity,
+.token.url,
+.language-css .token.string,
+.style .token.string {
+ color: #9a6e3a;
+ background: hsla(0, 0%, 100%, 0.5);
+}
+.token.atrule,
+.token.attr-value,
+.token.keyword {
+ color: #07a;
+}
+.token.function,
+.token.class-name {
+ color: #DD4A68;
+}
+.token.regex,
+.token.important,
+.token.variable {
+ color: #e90;
+}
+.token.important,
+.token.bold {
+ font-weight: bold;
+}
+.token.italic {
+ font-style: italic;
+}
+.token.entity {
+ cursor: help;
+}
+
+`;
+}
+
+// renderer.ts
+function render(_0, _1, _2, _3) {
+ return __async(this, arguments, function* (plugin, view, inputFile, outputFormat, parentFiles = []) {
+ var _a;
+ const markdown = view.data;
+ const wrapper = document.createElement("div");
+ wrapper.style.display = "hidden";
+ document.body.appendChild(wrapper);
+ yield import_obsidian.MarkdownRenderer.renderMarkdown(markdown, wrapper, path2.dirname(inputFile), view);
+ yield postProcessRenderedHTML(plugin, inputFile, wrapper, outputFormat, parentFiles, yield mermaidCSS(plugin.settings, plugin.vaultBasePath()));
+ let html = wrapper.innerHTML;
+ document.body.removeChild(wrapper);
+ const metadata = getYAMLMetadata(markdown);
+ (_a = metadata.title) != null ? _a : metadata.title = fileBaseName(inputFile);
+ if (parentFiles.length === 0) {
+ html = yield standaloneHTML(plugin.settings, html, metadata.title, plugin.vaultBasePath());
+ }
+ return { html, metadata };
+ });
+}
+function fileBaseName(file) {
+ return path2.basename(file, path2.extname(file));
+}
+function getYAMLMetadata(markdown) {
+ markdown = markdown.trim();
+ if (markdown.startsWith("---")) {
+ const trailing = markdown.substring(3);
+ const frontmatter = trailing.substring(0, trailing.indexOf("---")).trim();
+ return parse(frontmatter);
+ }
+ return {};
+}
+function getCustomCSS(settings, vaultBasePath) {
+ return __async(this, null, function* () {
+ if (!settings.customCSSFile)
+ return;
+ let file = settings.customCSSFile;
+ let buffer = null;
+ try {
+ let test = yield fs2.promises.readFile(file);
+ buffer = test;
+ } catch (e) {
+ }
+ try {
+ let test = yield fs2.promises.readFile(path2.join(vaultBasePath, file));
+ buffer = test;
+ } catch (e) {
+ }
+ if (!buffer) {
+ new import_obsidian.Notice("Failed to load custom Pandoc CSS file: " + settings.customCSSFile);
+ return "";
+ } else {
+ return buffer.toString();
+ }
+ });
+}
+function getAppConfig(vaultBasePath) {
+ return __async(this, null, function* () {
+ return JSON.parse((yield fs2.promises.readFile(path2.join(vaultBasePath, ".obsidian", "config"))).toString());
+ });
+}
+function currentThemeIsLight(vaultBasePath, config = null) {
+ return __async(this, null, function* () {
+ try {
+ if (!config)
+ config = yield getAppConfig(vaultBasePath);
+ return config.theme !== "obsidian";
+ } catch (e) {
+ return true;
+ }
+ });
+}
+function mermaidCSS(settings, vaultBasePath) {
+ return __async(this, null, function* () {
+ let light = true;
+ if (settings.injectAppCSS === "dark")
+ light = false;
+ if (settings.injectAppCSS === "current") {
+ light = yield currentThemeIsLight(vaultBasePath);
+ }
+ return variables(light);
+ });
+}
+function getThemeCSS(settings, vaultBasePath) {
+ return __async(this, null, function* () {
+ if (settings.injectAppCSS === "none")
+ return "";
+ try {
+ const config = yield getAppConfig(vaultBasePath);
+ let light = yield currentThemeIsLight(vaultBasePath, config);
+ if (settings.injectAppCSS === "light")
+ light = true;
+ if (settings.injectAppCSS === "dark")
+ light = false;
+ return app_css_default(light);
+ } catch (e) {
+ return "";
+ }
+ });
+}
+function getDesiredCSS(settings, html, vaultBasePath) {
+ return __async(this, null, function* () {
+ let css = yield getThemeCSS(settings, vaultBasePath);
+ if (settings.injectAppCSS !== "none") {
+ css += " " + Array.from(document.querySelectorAll("style")).map((s) => s.innerHTML).join(" ");
+ }
+ if (html.indexOf('jax="CHTML"') !== -1)
+ css += " " + mathjax_css_default;
+ css += yield getCustomCSS(settings, vaultBasePath);
+ return css;
+ });
+}
+function standaloneHTML(settings, html, title, vaultBasePath) {
+ return __async(this, null, function* () {
+ const css = yield getDesiredCSS(settings, html, vaultBasePath);
+ return `
+
+
+ ${title}
+
+
+
+
+${html}
+
+`;
+ });
+}
+function postProcessRenderedHTML(_0, _1, _2, _3) {
+ return __async(this, arguments, function* (plugin, inputFile, wrapper, outputFormat, parentFiles = [], css = "") {
+ const dirname4 = path2.dirname(inputFile);
+ const adapter = plugin.app.vault.adapter;
+ const settings = plugin.settings;
+ for (let span of Array.from(wrapper.querySelectorAll('span[src$=".png"], span[src$=".jpg"], span[src$=".gif"], span[src$=".jpeg"]'))) {
+ span.innerHTML = "";
+ span.outerHTML = span.outerHTML.replace(/span/g, "img");
+ }
+ for (let span of Array.from(wrapper.querySelectorAll("span.internal-embed"))) {
+ let src = span.getAttribute("src");
+ if (src) {
+ const subfolder = inputFile.substring(adapter.getBasePath().length);
+ const file = plugin.app.metadataCache.getFirstLinkpathDest(src, subfolder);
+ try {
+ if (parentFiles.indexOf(file.path) !== -1) {
+ span.outerHTML = `${span.innerHTML}`;
+ } else {
+ const markdown = yield adapter.read(file.path);
+ const newParentFiles = [...parentFiles];
+ newParentFiles.push(inputFile);
+ const html = yield render(plugin, { data: markdown }, file.path, outputFormat, newParentFiles);
+ span.outerHTML = html.html;
+ }
+ } catch (e) {
+ console.error("Pandoc plugin encountered an error trying to load an embedded note: " + e.toString());
+ }
+ }
+ }
+ const prefix = "app://obsidian.md/";
+ for (let a of Array.from(wrapper.querySelectorAll("a"))) {
+ if (!a.href.startsWith(prefix))
+ continue;
+ if (settings.linkStrippingBehaviour === "link" || outputFormat === "html") {
+ let href = path2.join(dirname4, a.href.substring(prefix.length));
+ if (settings.addExtensionsToInternalLinks.length && a.href.startsWith(prefix)) {
+ if (path2.extname(href) === "") {
+ const dir = path2.dirname(href);
+ const base = path2.basename(href);
+ const hashIndex = base.indexOf("#");
+ if (hashIndex !== -1) {
+ href = path2.join(dir, base.substring(0, hashIndex) + "." + settings.addExtensionsToInternalLinks + base.substring(hashIndex));
+ } else {
+ href = path2.join(dir, base + "." + settings.addExtensionsToInternalLinks);
+ }
+ }
+ }
+ a.href = href;
+ } else if (settings.linkStrippingBehaviour === "strip") {
+ a.outerHTML = "";
+ } else if (settings.linkStrippingBehaviour === "text") {
+ a.outerHTML = a.innerText;
+ } else if (settings.linkStrippingBehaviour === "unchanged") {
+ a.outerHTML = "[[" + a.outerHTML + "]]";
+ }
+ }
+ if (outputFormat !== "html") {
+ for (let img of Array.from(wrapper.querySelectorAll("img"))) {
+ if (img.src.startsWith(prefix) && img.getAttribute("data-touched") !== "true") {
+ img.src = adapter.getFullPath(img.src.substring(prefix.length));
+ img.setAttribute("data-touched", "true");
+ }
+ }
+ }
+ if (!settings.displayYAMLFrontmatter) {
+ Array.from(wrapper.querySelectorAll(".frontmatter, .frontmatter-container")).forEach((el) => wrapper.removeChild(el));
+ }
+ for (let svg of Array.from(wrapper.querySelectorAll("svg"))) {
+ let style = svg.querySelector("style") || svg.appendChild(document.createElement("style"));
+ style.innerHTML += css;
+ svg.innerHTML += `""`;
+ svg.innerHTML = svg.innerHTML.replace(/app:\/\/obsidian\.md\/index\.html#arrowhead\d*/g, "#mermaid_arrowhead");
+ if (outputFormat !== "html") {
+ const scale = settings.highDPIDiagrams ? 2 : 1;
+ const png = yield convertSVGToPNG(svg, scale);
+ svg.parentNode.replaceChild(png, svg);
+ }
+ }
+ });
+}
+function convertSVGToPNG(svg, scale = 1) {
+ const canvas = document.createElement("canvas");
+ canvas.width = Math.ceil(svg.width.baseVal.value * scale);
+ canvas.height = Math.ceil(svg.height.baseVal.value * scale);
+ const ctx = canvas.getContext("2d");
+ var svgImg = new Image();
+ svgImg.src = "data:image/svg+xml;base64," + gBase64.encode(svg.outerHTML);
+ return new Promise((resolve, reject) => {
+ svgImg.onload = () => {
+ ctx.drawImage(svgImg, 0, 0, canvas.width, canvas.height);
+ const pngData = canvas.toDataURL("png");
+ const img = document.createElement("img");
+ img.src = pngData;
+ img.width = Math.ceil(svg.width.baseVal.value);
+ img.height = Math.ceil(svg.height.baseVal.value);
+ resolve(img);
+ };
+ });
+}
+
+// settings.ts
+var import_obsidian2 = __toModule(require("obsidian"));
+var PandocPluginSettingTab = class extends import_obsidian2.PluginSettingTab {
+ constructor(app, plugin) {
+ super(app, plugin);
+ this.errorMessages = {
+ pandoc: "Pandoc is not installed or accessible on your PATH. This plugin's functionality will be limited.",
+ latex: "LaTeX is not installed or accessible on your PATH. Please install it if you want PDF exports via LaTeX."
+ };
+ this.plugin = plugin;
+ }
+ display() {
+ let { containerEl } = this;
+ containerEl.empty();
+ containerEl.createEl("h3", { text: "Pandoc Plugin" });
+ const createError = (text) => containerEl.createEl("p", { cls: "pandoc-plugin-error", text });
+ for (const binary2 in this.plugin.features) {
+ const path5 = this.plugin.features[binary2];
+ if (path5 === void 0) {
+ createError(this.errorMessages[binary2]);
+ }
+ }
+ new import_obsidian2.Setting(containerEl).setName("Custom CSS file for HTML output").setDesc("This local CSS file will be read and injected into HTML exports. Use an absolute path or a path relative to the vault.").addText((text) => text.setPlaceholder("File name").setValue(this.plugin.settings.customCSSFile).onChange((value) => __async(this, null, function* () {
+ if (!value.length)
+ this.plugin.settings.customCSSFile = null;
+ else
+ this.plugin.settings.customCSSFile = value;
+ yield this.plugin.saveSettings();
+ })));
+ new import_obsidian2.Setting(containerEl).setName("Inject app CSS (HTML output only)").setDesc("This applies app & plugin CSS to HTML exports, but the files become a little bigger.").addDropdown((dropdown) => dropdown.addOptions({
+ "current": "Current theme",
+ "none": "Neither theme",
+ "light": "Light theme",
+ "dark": "Dark theme"
+ }).setValue(this.plugin.settings.injectAppCSS).onChange((value) => __async(this, null, function* () {
+ this.plugin.settings.injectAppCSS = value;
+ yield this.plugin.saveSettings();
+ })));
+ new import_obsidian2.Setting(containerEl).setName("Internal link processing").setDesc("This controls how [[wiki-links]] are formatted. Doesn't affect HTML output.").addDropdown((dropdown) => dropdown.addOptions({
+ "text": "Turn into text",
+ "link": "Leave as links",
+ "strip": "Remove links",
+ "unchanged": "Leave unchanged"
+ }).setValue(this.plugin.settings.linkStrippingBehaviour).onChange((value) => __async(this, null, function* () {
+ this.plugin.settings.linkStrippingBehaviour = value;
+ yield this.plugin.saveSettings();
+ })));
+ new import_obsidian2.Setting(containerEl).setName("Export files from HTML or markdown?").setDesc("Export from markdown, or from the HTML visible in Obsidian? HTML supports fancy plugin features, markdown supports Pandoc features like citations.").addDropdown((dropdown) => dropdown.addOptions({
+ "html": "HTML",
+ "md": "Markdown"
+ }).setValue(this.plugin.settings.exportFrom).onChange((value) => __async(this, null, function* () {
+ this.plugin.settings.exportFrom = value;
+ yield this.plugin.saveSettings();
+ })));
+ new import_obsidian2.Setting(containerEl).setName("Export folder").setDesc("Absolute path to an export folder, like 'C:UsersExampleDocuments' or '/home/user/zettelkasten'. If left blank, files are saved next to where they were exported from.").addText((text) => text.setPlaceholder("same as target").setValue(this.plugin.settings.outputFolder).onChange((value) => __async(this, null, function* () {
+ this.plugin.settings.outputFolder = value;
+ yield this.plugin.saveSettings();
+ })));
+ new import_obsidian2.Setting(containerEl).setName("Show Pandoc command line interface commands").setDesc("Doesn't apply to HTML exports. Using the CLI will have slightly different results due to how this plugin works.").addToggle((toggle) => toggle.setValue(this.plugin.settings.showCLICommands).onChange((value) => __async(this, null, function* () {
+ this.plugin.settings.showCLICommands = value;
+ yield this.plugin.saveSettings();
+ })));
+ new import_obsidian2.Setting(containerEl).setName("Pandoc path").setDesc("Optional override for Pandoc's path if you have command not found issues. On Mac/Linux use the output of 'which pandoc' in a terminal; on Windows use the output of 'Get-Command pandoc' in powershell.").addText((text) => text.setPlaceholder("pandoc").setValue(this.plugin.settings.pandoc).onChange((value) => __async(this, null, function* () {
+ this.plugin.settings.pandoc = value;
+ yield this.plugin.saveSettings();
+ })));
+ new import_obsidian2.Setting(containerEl).setName("PDFLaTeX path").setDesc("Optional override for pdflatex's path. Same as above but with 'which pdflatex'").addText((text) => text.setPlaceholder("pdflatex").setValue(this.plugin.settings.pdflatex).onChange((value) => __async(this, null, function* () {
+ this.plugin.settings.pdflatex = value;
+ yield this.plugin.saveSettings();
+ })));
+ new import_obsidian2.Setting(containerEl).setName("Extra Pandoc arguments").setDesc("Add extra command line arguments so you can use templates or bibliographies. Newlines are turned into spaces").addTextArea((text) => text.setPlaceholder('Example: --bibliography "Zotero ExportsMy Library.json" or --template letter').setValue(this.plugin.settings.extraArguments).onChange((value) => __async(this, null, function* () {
+ this.plugin.settings.extraArguments = value;
+ yield this.plugin.saveSettings();
+ })).inputEl.style.minHeight = "150px");
+ }
+};
+
+// global.ts
+var fs3 = __toModule(require("fs"));
+var DEFAULT_SETTINGS = {
+ showCLICommands: false,
+ addExtensionsToInternalLinks: "html",
+ injectAppCSS: "light",
+ injectThemeCSS: false,
+ customCSSFile: null,
+ displayYAMLFrontmatter: false,
+ linkStrippingBehaviour: "text",
+ highDPIDiagrams: true,
+ pandoc: null,
+ pdflatex: null,
+ outputFolder: null,
+ extraArguments: "",
+ exportFrom: "html"
+};
+function replaceFileExtension(file, ext) {
+ let pos = file.lastIndexOf(".");
+ return file.substr(0, pos < 0 ? file.length : pos) + "." + ext;
+}
+
+// main.ts
+var PandocPlugin = class extends import_obsidian3.Plugin {
+ constructor() {
+ super(...arguments);
+ this.features = {};
+ }
+ onload() {
+ return __async(this, null, function* () {
+ console.log("Loading Pandoc plugin");
+ yield this.loadSettings();
+ this.createBinaryMap();
+ this.registerCommands();
+ this.addSettingTab(new PandocPluginSettingTab(this.app, this));
+ });
+ }
+ registerCommands() {
+ for (let [prettyName, pandocFormat, extension, shortName] of outputFormats) {
+ const name = "Export as " + prettyName;
+ this.addCommand({
+ id: "pandoc-export-" + pandocFormat,
+ name,
+ checkCallback: (checking) => {
+ if (!this.app.workspace.activeLeaf)
+ return false;
+ if (!this.currentFileCanBeExported(pandocFormat))
+ return false;
+ if (!checking) {
+ this.startPandocExport(this.getCurrentFile(), pandocFormat, extension, shortName);
+ }
+ return true;
+ }
+ });
+ }
+ }
+ vaultBasePath() {
+ return this.app.vault.adapter.getBasePath();
+ }
+ getCurrentFile() {
+ const fileData = this.app.workspace.getActiveFile();
+ if (!fileData)
+ return null;
+ const adapter = this.app.vault.adapter;
+ if (adapter instanceof import_obsidian3.FileSystemAdapter)
+ return adapter.getFullPath(fileData.path);
+ return null;
+ }
+ currentFileCanBeExported(format) {
+ if (needsPandoc(format) && !this.features["pandoc"])
+ return false;
+ if (needsLaTeX(format) && !this.features["pdflatex"])
+ return false;
+ const file = this.getCurrentFile();
+ if (!file)
+ return false;
+ for (const ext of inputExtensions) {
+ if (file.endsWith(ext))
+ return true;
+ }
+ return false;
+ }
+ createBinaryMap() {
+ return __async(this, null, function* () {
+ this.features["pandoc"] = this.settings.pandoc || (yield (0, import_lookpath2.lookpath)("pandoc"));
+ this.features["pdflatex"] = this.settings.pdflatex || (yield (0, import_lookpath2.lookpath)("pdflatex"));
+ });
+ }
+ startPandocExport(inputFile, format, extension, shortName) {
+ return __async(this, null, function* () {
+ new import_obsidian3.Notice(`Exporting ${inputFile} to ${shortName}`);
+ let outputFile = replaceFileExtension(inputFile, extension);
+ if (this.settings.outputFolder) {
+ outputFile = path3.join(this.settings.outputFolder, path3.basename(outputFile));
+ }
+ const view = this.app.workspace.getActiveViewOfType(import_obsidian3.MarkdownView);
+ try {
+ let error, command;
+ switch (this.settings.exportFrom) {
+ case "html": {
+ const { html, metadata } = yield render(this, view, inputFile, format);
+ if (format === "html") {
+ yield fs4.promises.writeFile(outputFile, html);
+ new import_obsidian3.Notice("Successfully exported via Pandoc to " + outputFile);
+ return;
+ } else {
+ const metadataFile = temp.path();
+ const metadataString = stringify3(metadata);
+ yield fs4.promises.writeFile(metadataFile, metadataString);
+ const result = yield pandoc({
+ file: "STDIN",
+ contents: html,
+ format: "html",
+ metadataFile,
+ pandoc: this.settings.pandoc,
+ pdflatex: this.settings.pdflatex,
+ directory: path3.dirname(inputFile)
+ }, { file: outputFile, format }, this.settings.extraArguments.split("\n"));
+ error = result.error;
+ command = result.command;
+ }
+ break;
+ }
+ case "md": {
+ const result = yield pandoc({
+ file: inputFile,
+ format: "markdown",
+ pandoc: this.settings.pandoc,
+ pdflatex: this.settings.pdflatex,
+ directory: path3.dirname(inputFile)
+ }, { file: outputFile, format }, this.settings.extraArguments.split("\n"));
+ error = result.error;
+ command = result.command;
+ break;
+ }
+ }
+ if (error.length) {
+ new import_obsidian3.Notice("Exported via Pandoc to " + outputFile + " with warnings");
+ new import_obsidian3.Notice("Pandoc warnings:" + error, 1e4);
+ } else {
+ new import_obsidian3.Notice("Successfully exported via Pandoc to " + outputFile);
+ }
+ if (this.settings.showCLICommands) {
+ new import_obsidian3.Notice("Pandoc command: " + command, 1e4);
+ console.log(command);
+ }
+ } catch (e) {
+ new import_obsidian3.Notice("Pandoc export failed: " + e.toString(), 15e3);
+ console.error(e);
+ }
+ });
+ }
+ onunload() {
+ console.log("Unloading Pandoc plugin");
+ }
+ 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);
+ });
+ }
+};
+
+/* nosourcemap */
\ No newline at end of file
diff --git a/.obsidian/plugins/obsidian-pandoc/manifest.json b/.obsidian/plugins/obsidian-pandoc/manifest.json
new file mode 100644
index 0000000..8e570d2
--- /dev/null
+++ b/.obsidian/plugins/obsidian-pandoc/manifest.json
@@ -0,0 +1,10 @@
+{
+ "id": "obsidian-pandoc",
+ "name": "Pandoc Plugin",
+ "version": "0.4.1",
+ "minAppVersion": "0.12.5",
+ "description": "This is a Pandoc export plugin for Obsidian. It provides commands to export to formats like DOCX, ePub and PDF.",
+ "author": "Oliver Balfour",
+ "authorUrl": "https://github.com/OliverBalfour/obsidian-pandoc",
+ "isDesktopOnly": true
+}
\ No newline at end of file
diff --git a/.obsidian/plugins/obsidian-pandoc/styles.css b/.obsidian/plugins/obsidian-pandoc/styles.css
new file mode 100644
index 0000000..98facd9
--- /dev/null
+++ b/.obsidian/plugins/obsidian-pandoc/styles.css
@@ -0,0 +1,4 @@
+
+.pandoc-plugin-error {
+ color: red;
+}
diff --git a/2025-12-05.md b/2025-12-05.md
index 2ccc45a..650e26f 100644
--- a/2025-12-05.md
+++ b/2025-12-05.md
@@ -12,13 +12,4 @@ title: ""
## 2025-12-05 10:41
-### PDI Accubid Phase Office Space
-
-#occupational
-
-> [!quote] Joel Jansen to William Bonn 2025-12-05 (pp.)
-> PDI Accubid `Phase` "Office Space"
-> is normally used for core & shell retail office space
-
-Interpreted as tenant coworking space, a la
-[Coworking & Office Space in St. Pete | Rising Tide](https://risingtidecowork.com/)
\ No newline at end of file
+[[pdi-breakdowns#Area: Office Space]]
\ No newline at end of file
diff --git a/2026-01-07.md b/2026-01-07.md
new file mode 100644
index 0000000..f4f722d
--- /dev/null
+++ b/2026-01-07.md
@@ -0,0 +1,90 @@
+---
+id:
+aliases: []
+title: 2026-01-07
+tags:
+ - authorship/original
+ - destiny/permanent
+ - status/draft
+ - type/daily
+---
+# 2026-01-07
+
+## 2026-01-07 10:03
+
+At Ace, "residential" always meant single-family/duplex construction,
+but I think now we were the outliers.
+
+## 2026-01-07 10:05
+
+See [[pdi-breakdowns#Location]].
+
+I have---for some time now---
+been trying to figure out the purpose of the non-system breakdowns.
+
+[[location-vs-scope]]
+
+Perhaps there is another dichotomy
+in that an estimator may use the area classifications of the design
+or according to their own understanding of each term.
+For lack of a better example,
+whether a "101 - KITCHEN", without provisions for cooking,
+would be broken down under "Kitchen".
+
+## 2026-01-07 10:42
+
+When I got to work today Art admonished a fellow estimator
+for not uploading _all_ of a project's drawings,
+even those they did not intend to take off, to Trimble Connect.
+Art suggested that the estimator should upload all the drawings,
+but only add them to LiveCount as needed.
+
+I take issue with the suggestion on principle
+since doing so would not benefit the estimator or their senior
+(if they aren't added, the estimator can do nothing with them),
+but would require not-insignificant effort.
+Effort that would ultimately benefit no one:---
+
+Trimble Connect's ham-fisted approach to version control
+means that the fewer times it must be used, the better.
+
+> I'm currently dealing with the headache of an estimate
+> where such caution was not applied.
+
+The probability that any construction will be performed
+according the drawings that we take off
+(or even their immediate successors)
+I suspect is slim to zero.
+That Ops would have the patience to add the revisions,
+fighting with Trimble Connect as they would be,
+I suspect is even less.
+
+> On my current project, after trying in vain to play by Trimble's rules,
+> I started by deleting all the drawings I could
+> (those without takeoff associated with them)
+> then reuploaded the revised set.
+> I'm confident that this would be the dominant strategy.
+
+***
+
+It's curious to me that the possibility of scope revisions
+doesn't seem to be at the front of every estimator's mind
+when doing takeoff or considering process changes,
+like it was for my mentors and peers at Ace.
+
+## 2026-01-07 12:13
+
+Just now Jorge admonished another peer
+for using insulated wire for pool bonding.
+
+## 2026-01-07 16:03
+
+#occupational #topic/organization
+
+There is a palpable animosity for [[pdi-estimating#Bid Estimating|Bid]]
+in [[pdi-estimating#Construction Estimating (ConEst)|ConEst]],
+stemming---I believe---from an lack of buy-in on Bid's part.
+Their lack is easily explained by their [[estimating-culture#Incentives|incentive structure]]:
+Since throughput is systematically prioritized over accuracy,
+ConEst has a strictly antagonistic role
+because it slows down the bid process.
diff --git a/breakdown-objects.md b/breakdown-objects.md
index a9b7cfc..5dad7ce 100644
--- a/breakdown-objects.md
+++ b/breakdown-objects.md
@@ -57,20 +57,3 @@ and every even level has
```
equipment of the same type is assumed to be evenly spaced.
-
-## Location vs. Scope
-
-%%TODO:%%
-
-![[location-vs-scope.excalidraw]]
-
-MDPB is physically _located_ in Building A,
-but serves only loads in Building B.
-
-```
-location = Buildings["Building A"]
-scope = Buildings["Building B"]
-```
-
-Were Building B removed from the contract scope,
-it can be expected that MDPB would be as well.
diff --git a/construction-methods.md b/construction-methods.md
index 6d86912..96c3b0d 100644
--- a/construction-methods.md
+++ b/construction-methods.md
@@ -11,6 +11,8 @@ title: Construction Methods
---
# Construction Methods
+
+
%%
TYPICAL EIFS ON
@@ -37,6 +39,12 @@ EIFS ON CIP CONC
%%
+## Core and Shell
+
+A **core and shell** installation is one that provides the minimum requirements.
+A **cold shell** installation excludes heating as well.
+Such spaces are "finished" under a separate contract.
+
## Shear Walls
Shear walls span the height of a building.
diff --git a/electrical-takeoff.md b/electrical-takeoff.md
index fd8b6f8..395ed6d 100644
--- a/electrical-takeoff.md
+++ b/electrical-takeoff.md
@@ -52,6 +52,8 @@ even where serving Amenity spaces.
`COMMON ASSEMBLIES`/`MECHANICAL CONNECTIONS ...`/...
+When using length-based assemblies use adders per [[feeders-takeoff]].
+
### Stair Pressurization Fans
Assume branch circuit conductors must be protected
diff --git a/estimating-culture.md b/estimating-culture.md
index d080947..5499add 100644
--- a/estimating-culture.md
+++ b/estimating-culture.md
@@ -55,7 +55,8 @@ between the estimator and the employer
where the employer is hopelessly outmatched,
and the estimator's [[strategy#Strictly Dominant Strategy|strictly dominant strategy]]---
resisted only by their [[personal-values]]---
-is to abuse the system: to bid fast, lie often, take the bag, and leave.
+is to abuse the system: to bid fast, take the bag, lie often,
+and leave when people get too suspicious.
## Collaboration
diff --git a/fire-alarm-takeoff.md b/fire-alarm-takeoff.md
index 439c569..d3a4c18 100644
--- a/fire-alarm-takeoff.md
+++ b/fire-alarm-takeoff.md
@@ -192,6 +192,14 @@ _Design Build (alternative method):_
## Fire Smoke Dampers (FSD's)
+In [[pdi-building-types#High Rise|high rise construction]],
+usually found on every level with units.
+
+> [!tip]
+> If possible, use
+> * `Area` = "Typical - Fire Smoke Dampers"
+> with quantity per level as shown.
+
For each damper, take off both
1. * `System` = "FA - Fire Alarm"
diff --git a/location-vs-scope.excalidraw.md b/location-vs-scope.excalidraw.md
index 3b3408e..00e9d5c 100644
--- a/location-vs-scope.excalidraw.md
+++ b/location-vs-scope.excalidraw.md
@@ -1,7 +1,6 @@
---
id:
aliases: []
-
excalidraw-plugin: parsed
tags:
- excalidraw
@@ -78,3 +77,20 @@ DUtO/MZs4vM8wNgDCJyP0NwN8m5kpFs8iPgN0IzblL5bdBAEYGwAYKo+WAQITE8L6gswk5k84mOms/5P
```
%%
+
+## Location vs. Scope
+
+%%TODO:%%
+
+![[location-vs-scope.excalidraw]]
+
+MDPB is physically _located_ in Building A,
+but serves only loads in Building B.
+
+```
+location = Buildings["Building A"]
+scope = Buildings["Building B"]
+```
+
+Were Building B removed from the contract scope,
+it can be expected that MDPB would be as well.
diff --git a/location-vs-scope.md b/location-vs-scope.md
new file mode 100644
index 0000000..1fb24f3
--- /dev/null
+++ b/location-vs-scope.md
@@ -0,0 +1,32 @@
+---
+id:
+aliases: []
+title: Location vs. Scope
+tags: []
+---
+# Location vs. Scope
+
+A detailed breakdown being a necessity of a quality estimate,
+it is important to consider what one means
+when they say that some portion of the installation is _in_ some place.
+
+![[location-vs-scope.excalidraw]]
+
+MDPB is physically _located_ in Building A,
+but serves only loads in Building B.
+
+If a customer requests a cost breakdown by building,
+under which building would you put MDPB?
+
+Were Building B removed from the contract scope,
+it can be expected that MDPB would be as well.
+Were Building A removed from the contract scope,
+it can be expected that MDPB would be relocated.
+Therefore if the customer requests a cost breakdown by _building_,
+it would be confusing to do so along location.
+That is, to include MDPB and its feeders in the price for Building A.
+
+```
+Panel_MDPB.Location = Buildings["Building A"]
+Panel_MDPB.Scope = Buildings["Building B"]
+```
diff --git a/nfpa-70_dump_wiring-methods.md b/nfpa-70_dump_wiring-methods.md
index d343a9d..49695a9 100644
--- a/nfpa-70_dump_wiring-methods.md
+++ b/nfpa-70_dump_wiring-methods.md
@@ -24,7 +24,7 @@ This article covers the use, installation, and construction specifications for a
The definition in this section shall apply within this article and throughout the Code.
-Armored Cable, Type AC.
+#### Armored Cable, Type AC.
A fabricated assembly of insulated conductors in a flexible interlocked metallic armor. See 320.100.
@@ -169,7 +169,7 @@ This article covers the use, installation, and construction specifications for f
The definition in this section shall apply within this article and throughout the Code.
-Flat Cable Assembly, Type FC.
+#### Flat Cable Assembly, Type FC.
An assembly of parallel conductors formed integrally with an insulating material web specifically designed for field installation in surface metal raceway.
@@ -282,38 +282,38 @@ This article covers a field-installed wiring system for branch circuits incorpor
The definitions in this section shall apply only within this article.
-Bottom Shield.
+#### Bottom Shield.
A protective layer that is installed between the floor and Type FCC flat conductor cable to protect the cable from physical damage and may or may not be incorporated as an integral part of the cable.
-Cable Connector.
+#### Cable Connector.
A connector designed to join Type FCC cables without using a junction box.
-FCC System.
+#### FCC System.
A complete wiring system for branch circuits that is designed for installation under carpet squares.
> [!info] Informational Note:
> The FCC system includes Type FCC cable and associated shielding, connectors, terminators, adapters, boxes, and receptacles.
-Insulating End.
+#### Insulating End.
An insulator designed to electrically insulate the end of a Type FCC cable.
-Metal Shield Connections.
+#### Metal Shield Connections.
Means of connection designed to electrically and mechanically connect a metal shield to another metal shield, to a receptacle housing or self-contained device, or to a transition assembly.
-Top Shield.
+#### Top Shield.
A grounded metal shield covering under-carpet components of the FCC system for the purposes of providing protection against physical damage.
-Transition Assembly.
+#### Transition Assembly.
An assembly to facilitate connection of the FCC system to other wiring systems, incorporating (1) a means of electrical interconnection and (2) a suitable box or covering for providing electrical safety and protection against physical damage.
-Type FCC Cable.
+#### Type FCC Cable.
Three or more flat copper conductors placed edge-to-edge and separated and enclosed within an insulating assembly.
@@ -494,7 +494,7 @@ This article covers the use, installation, and construction specifications for i
The definition in this section shall apply within this article and throughout the Code.
-Integrated Gas Spacer Cable, Type IGS.
+#### Integrated Gas Spacer Cable, Type IGS.
A factory assembly of one or more conductors, each individually insulated and enclosed in a loose fit, nonmetallic flexible conduit as an integrated gas spacer cable rated 0 volts through 600 volts.
@@ -613,7 +613,7 @@ This article covers the use, installation, and construction specifications for p
The definition in this section shall apply within this article and throughout this Code.
-Power and Control Tray Cable, Type TC.
+#### Power and Control Tray Cable, Type TC.
A factory assembly of two or more insulated conductors, with or without associated bare or covered equipment grounding conductors, under a nonmetallic jacket.
@@ -754,7 +754,7 @@ This article covers the use, installation, and construction specifications for u
The definition in this section shall apply within this article and throughout the Code.
-Type P. Cable
+#### Type P. Cable
A factory assembly of one or more insulated flexible tinned copper conductors, with associated equipment grounding conductor(s), with or without a braided metallic armor and with an overall nonmetallic jacket.
@@ -840,7 +840,7 @@ This article covers the use, installation, and construction specifications for u
The definition in this section shall apply within this article and throughout the Code.
-Underground Feeder and Branch-Circuit Cable, Type UF.
+#### Underground Feeder and Branch-Circuit Cable, Type UF.
A factory assembly of one or more insulated conductors with an integral or an overall covering of nonmetallic material suitable for direct burial in the earth.
@@ -939,7 +939,7 @@ This article covers the use, installation, and construction specifications for i
The definition in this section shall apply within this article and throughout the Code.
-Intermediate Metal Conduit (IMC).
+#### Intermediate Metal Conduit (IMC).
A steel threadable raceway of circular cross section designed for the physical protection and routing of conductors and cables and for use as an equipment grounding conductor when installed with its integral or associated coupling and appropriate fittings.
@@ -1101,7 +1101,7 @@ This article covers the use, installation, and construction specifications for r
The definition in this section shall apply within this article and throughout the Code.
-Rigid Metal Conduit (RMC).
+#### Rigid Metal Conduit (RMC).
A threadable raceway of circular cross section designed for the physical protection and routing of conductors and cables and for use as an equipment grounding conductor when installed with its integral or associated coupling and appropriate fittings.
@@ -1297,7 +1297,7 @@ This article covers the use, installation, and construction specifications for f
The definition in this section shall apply within this article and throughout the Code.
-Flexible Metal Conduit (FMC).
+#### Flexible Metal Conduit (FMC).
A raceway of circular cross section made of helically wound, formed, interlocked metal strip.
@@ -1509,7 +1509,7 @@ This article covers the use, installation, and construction specifications for l
The definition in this section shall apply within this article and throughout the Code.
-Liquidtight Flexible Metal Conduit (LFMC).
+#### Liquidtight Flexible Metal Conduit (LFMC).
A raceway of circular cross section having an outer liquidtight, nonmetallic, sunlight-resistant jacket over an inner flexible metal core with associated couplings, connectors, and fittings for the installation of electric conductors.
@@ -1643,15 +1643,13 @@ LFMC shall be marked according to 110.21. The trade size and other information r
This article covers the use, installation, and construction specifications for high density polyethylene (HDPE) conduit and associated fittings.
> [!info] Informational Note:
-> Refer to Article 352 for Rigid Polyvinyl Chloride Conduit: Type PVC and Article 355 for Reinforced Thermosetting
-
-Resin Conduit: Type RTRC.
+> Refer to Article 352 for Rigid Polyvinyl Chloride Conduit: Type PVC and Article 355 for Reinforced Thermosetting Resin Conduit: Type RTRC.
### 353.2 Definition.
The definition in this section shall apply within this article and throughout the Code.
-High Density Polyethylene (HDPE) Conduit.
+#### High Density Polyethylene (HDPE) Conduit.
A nonmetallic raceway of circular cross section, with associated couplings, connectors, and fittings for the installation of electrical conductors.
@@ -1776,7 +1774,7 @@ This article covers the use, installation, and construction specifications for n
The definition in this section shall apply within this article and throughout the Code.
-Nonmetallic Underground Conduit with Conductors (NUCC).
+#### Nonmetallic Underground Conduit with Conductors (NUCC).
A factory assembly of conductors or cables inside a nonmetallic, smooth wall raceway with a circular cross section.
@@ -1919,15 +1917,13 @@ Identification of conductors or cables used in the assembly shall be provided on
This article covers the use, installation, and construction specification for reinforced thermosetting resin conduit (RTRC) and associated fittings.
> [!info] Informational Note:
-> Refer to Article 352 for Rigid Polyvinyl Chloride Conduit: Type PVC, and Article 353 for High Density Polyethylene
-
-Conduit: Type HDPE.
+> Refer to Article 352 for Rigid Polyvinyl Chloride Conduit: Type PVC, and Article 353 for High Density Polyethylene Conduit: Type HDPE.
### 355.2 Definition.
The definition in this section shall apply within this article and throughout the Code.
-Reinforced Thermosetting Resin Conduit (RTRC).
+#### Reinforced Thermosetting Resin Conduit (RTRC).
A rigid nonmetallic raceway of circular cross section, with integral or associated couplings, connectors, and fittings for the installation of electrical conductors and cables.
@@ -2195,7 +2191,7 @@ This article covers the use, installation, and construction specifications for l
The definition in this section shall apply within this article and throughout the Code.
-Liquidtight Flexible Nonmetallic Conduit (LFNC).
+#### Liquidtight Flexible Nonmetallic Conduit (LFNC).
A raceway of circular cross section of various types as follows:
@@ -2342,7 +2338,7 @@ This article covers the use, installation, and construction specifications for e
The definition in this section shall apply within this article and throughout the Code.
-Electrical Metallic Tubing (EMT).
+#### Electrical Metallic Tubing (EMT).
An unthreaded thinwall raceway of circular cross section designed for the physical protection and routing of conductors and cables and for use as an equipment grounding conductor when installed utilizing appropriate fittings.
@@ -2516,7 +2512,7 @@ This article covers the use, installation, and construction specifications for f
The definition in this section shall apply within this article and throughout the Code.
-Flexible Metallic Tubing (FMT).
+#### Flexible Metallic Tubing (FMT).
A metal raceway that is circular in cross section, flexible, and liquidtight without a nonmetallic jacket.
@@ -2645,7 +2641,7 @@ This article covers the use, installation, and construction specifications for e
The definition in this section shall apply within this article and throughout the Code.
-Electrical Nonmetallic Tubing (ENT).
+#### Electrical Nonmetallic Tubing (ENT).
A nonmetallic, pliable, corrugated raceway of circular cross section with integral or associated couplings, connectors, and fittings for the installation of electrical conductors. ENT is composed of a material that is resistant to moisture and chemical atmospheres and is flame retardant.
@@ -2819,13 +2815,13 @@ This article covers the use, installation, and construction requirements of meta
The definitions in this section shall apply within this article and throughout the Code.
-Metal Auxiliary Gutter.
+#### Metal Auxiliary Gutter.
A sheet metal enclosure used to supplement wiring spaces at meter centers, distribution centers, switchgear, switchboards, and similar points of wiring systems. The enclosure has hinged or removable covers for housing and protecting electrical wires, cable, and busbars.
The enclosure is designed for conductors to be laid or set in place after the enclosures have been installed as a complete system.
-Nonmetallic Auxiliary Gutter.
+#### Nonmetallic Auxiliary Gutter.
A flame-retardant, nonmetallic enclosure used to supplement wiring spaces at meter centers, distribution centers, switchgear, switchboards, and similar points of wiring systems. The enclosure has hinged or removable covers for housing and protecting electrical wires, cable, and busbars. The enclosure is designed for conductors to be laid or set in place after the enclosures have been installed as a complete system.
@@ -3017,7 +3013,7 @@ This article covers service-entrance, feeder, and branch-circuit busways and ass
The definition in this section shall apply within this article and throughout the Code.
-Busway.
+#### Busway.
A raceway consisting of a metal enclosure containing factory-mounted, bare or insulated conductors, which are usually copper or aluminum bars, rods, or tubes.
@@ -3297,7 +3293,7 @@ This article covers the use and installation requirements of cablebus and associ
The definition in this section shall apply within this article and throughout the Code.
-Cablebus.
+#### Cablebus.
An assembly of units or sections with insulated conductors having associated fittings forming a structural system used to securely fasten or support conductors and conductor terminations in a completely enclosed, ventilated, protective metal housing. This assembly is designed to carry fault current and to withstand the magnetic forces of such current.
@@ -3429,11 +3425,11 @@ This article covers cellular concrete floor raceways, the hollow spaces in floor
The definitions in this section shall apply only within this article.
-Cell.
+#### Cell.
A single, enclosed tubular space in a floor made of precast cellular concrete slabs, the direction of the cell being parallel to the direction of the floor member.
-Header.
+#### Header.
Transverse metal raceways for electrical conductors, providing access to predetermined cells of a precast cellular concrete floor, thereby permitting the installation of electrical conductors from a distribution center to the floor cells.
@@ -3508,15 +3504,15 @@ This article covers the use and installation requirements for cellular metal flo
The definitions in this section shall apply within this article and throughout the Code.
-Cellular Metal Floor Raceway.
+#### Cellular Metal Floor Raceway.
The hollow spaces of cellular metal floors, together with suitable fittings, that may be approved as enclosed channel for electrical conductors.
-Cell.
+#### Cell.
A single enclosed tubular space in a cellular metal floor member, the axis of the cell being parallel to the axis of the metal floor member.
-Header.
+#### Header.
A transverse raceway for electrical conductors, providing access to predetermined cells of a cellular metal floor, thereby permitting the installation of electrical conductors from a distribution center to the cells.
@@ -3599,7 +3595,7 @@ This article covers the use, installation, and construction specifications for m
The definition in this section shall apply within this article and throughout the Code.
-Metal Wireways.
+#### Metal Wireways.
Sheet metal troughs with hinged or removable covers for housing and protecting electrical wires and cable and in which conductors are laid in place after the raceway has been installed as a complete system.
@@ -3748,7 +3744,7 @@ This article covers the use, installation, and construction specifications for n
The definition in this section shall apply within this article and throughout the Code.
-Nonmetallic Wireways.
+#### Nonmetallic Wireways.
Flame-retardant, nonmetallic troughs with removable covers for housing and protecting electrical wires and cables in which conductors are laid in place after the raceway has been installed as a complete system.
@@ -3921,11 +3917,11 @@ This article covers the use, installation, and construction specifications for n
The definitions in this section shall apply within this article and throughout the Code.
-Concealable Nonmetallic Extension.
+#### Concealable Nonmetallic Extension.
A listed assembly of two, three, or four insulated circuit conductors within a nonmetallic jacket, an extruded thermoplastic covering, or a sealed nonmetallic covering. The classification includes surface extensions intended for mounting directly on the surface of walls or ceilings and concealed with paint, texture, joint compound, plaster, wallpaper, tile, wall paneling, or other similar materials.
-Nonmetallic Extension.
+#### Nonmetallic Extension.
An assembly of two insulated conductors within a nonmetallic jacket or an extruded thermoplastic covering. The classification includes surface extensions intended for mounting directly on the surface of walls or ceilings.
@@ -4094,7 +4090,7 @@ This article covers the use, installation, and construction specifications of st
The definition in this section shall apply within this article and throughout the Code.
-Strut-Type Channel Raceway.
+#### Strut-Type Channel Raceway.
A metal raceway that is intended to be mounted to the surface of or suspended from a structure, with associated accessories for the installation of electrical conductors and cables.
@@ -4232,7 +4228,7 @@ This article covers the use, installation, and construction specifications for s
The definition in this section shall apply within this article and throughout the Code.
-Surface Metal Raceway.
+#### Surface Metal Raceway.
A metal raceway that is intended to be mounted to the surface of a structure, with associated couplings, connectors, boxes, and fittings for the installation of electrical conductors.
@@ -4329,7 +4325,7 @@ This article covers the use, installation, and construction specifications for s
The definition in this section shall apply within this article and throughout the Code.
-Surface Nonmetallic Raceway.
+#### Surface Nonmetallic Raceway.
A nonmetallic raceway that is intended to be mounted to the surface of a structure, with associated couplings, connectors, boxes, and fittings for the installation of electrical conductors.
@@ -4415,7 +4411,7 @@ This article covers the use and installation requirements for underfloor raceway
The definition in this section shall apply within this article and throughout the Code.
-Underfloor Raceway.
+#### Underfloor Raceway.
A raceway and associated components designed and intended for installation beneath or flush with the surface of a floor for the installation of cables and electrical conductors.
@@ -4517,7 +4513,7 @@ This article covers cable tray systems, including ladder, ventilated trough, ven
The definition in this section shall apply within this article and throughout the Code.
-Cable Tray System.
+#### Cable Tray System.
A unit or assembly of units or sections and associated fittings forming a structural system used to securely fasten or support cables and raceways.
@@ -5244,55 +5240,55 @@ This article covers the installation of low-voltage suspended ceiling power dist
The definitions in this section shall apply only within this article.
-Busbar.
+#### Busbar.
A noninsulated conductor electrically connected to the source of supply and physically supported on an insulator providing a power rail for connection to utilization equipment, such as sensors, actuators, A/V devices, low-voltage luminaire assemblies, and similar electrical equipment.
-Busbar Support.
+#### Busbar Support.
An insulator that runs the length of a section of suspended ceiling bus rail that serves to support and isolate the busbars from the suspended grid rail.
-Connector.
+#### Connector.
A term used to refer to an electromechanical fitting.
-Connector, Load.
+#### Connector, Load.
An electromechanical connector used for power from the busbar to utilization equipment.
-Connector, Pendant.
+#### Connector, Pendant.
An electromechanical or mechanical connector used to suspend low-voltage luminaire or utilization equipment below the grid rail and to supply power to connect from the busbar to utilization equipment.
-Connector, Power Feed.
+#### Connector, Power Feed.
An electromechanical connector used to connect the power supply to a power distribution cable, to connect directly to the busbar, or to connect from a power distribution cable to the busbar.
-Connector, Rail to Rail.
+#### Connector, Rail to Rail.
An electromechanical connector used to interconnect busbars from one ceiling grid rail to another grid rail.
-Grid Bus Rail.
+#### Grid Bus Rail.
A combination of the busbar, the busbar support, and the structural suspended ceiling grid system.
-Low-Voltage Suspended Ceiling Power Distribution System.
+#### Low-Voltage Suspended Ceiling Power Distribution System.
A system that serves as a support for a finished ceiling surface and consists of a busbar and busbar support system to distribute power to utilization equipment supplied by a Class 2 power supply.
-Power Supply.
+#### Power Supply.
A Class 2 power supply connected between the branch-circuit power distribution system and the busbar low-voltage suspended ceiling power distribution system.
-Rail.
+#### Rail.
The structural support for the suspended ceiling system typically forming the ceiling grid supporting the ceiling tile and listed utilization equipment, such as sensors, actuators, A/V devices, and low-voltage luminaires and similar electrical equipment.
-Reverse Polarity Protection (Backfeed Protection).
+#### Reverse Polarity Protection (Backfeed Protection).
A system that prevents two interconnected power supplies, connected positive to negative, from passing current from one power source into a second power source.
-Suspended Ceiling Grid.
+#### Suspended Ceiling Grid.
A system that serves as a support for a finished ceiling surface and other utilization equipment.
@@ -5480,7 +5476,7 @@ This article covers the use, installation, and construction specifications of co
The definition in this section shall apply within this article and throughout the Code.
-Concealed Knob-and-Tube Wiring.
+#### Concealed Knob-and-Tube Wiring.
A wiring method using knobs, tubes, and flexible nonmetallic tubing for the protection and support of single insulated conductors.
@@ -5588,7 +5584,7 @@ This article covers the use, installation, and construction specifications for m
### 396.2 Definitions.
-Insulated Conductor.
+#### Insulated Conductor.
This definition shall apply only within this article.
@@ -5599,11 +5595,9 @@ For the purposes of this article, an insulated conductor includes the following:
* (2) Overhead service conductors encased in a polymeric material that has been evaluated for the applied nominal voltage.
> [!info] Informational Note:
-> Evidence of evaluation for the applied nominal voltage can be given by certification that the conductors have met the requirements of ICEA S-76-474-2011, Standard for Neutral Supported Power Cable Assemblies with Weather-Resistant Extruded
+> Evidence of evaluation for the applied nominal voltage can be given by certification that the conductors have met the requirements of ICEA S-76-474-2011, Standard for Neutral Supported Power Cable Assemblies with Weather-Resistant Extruded Insulation Rated 600 Volts.
-Insulation Rated 600 Volts.
-
-Messenger-Supported Wiring.
+#### Messenger-Supported Wiring.
This definition shall apply within this article and throughout the Code.
@@ -5702,7 +5696,7 @@ This article covers the use, installation, and construction specifications of op
The definition in this section shall apply within this article and throughout the Code.
-Open Wiring on Insulators.
+#### Open Wiring on Insulators.
An exposed wiring method using cleats, knobs, tubes, and flexible tubing for the protection and support of single insulated conductors run in or on buildings.
@@ -5827,7 +5821,7 @@ This article covers the use and installation for outdoor overhead conductors ove
The definitions in this section shall apply only within this article.
-Outdoor Overhead Conductors.
+#### Outdoor Overhead Conductors.
Single conductors, insulated, covered, or bare, installed outdoors on support structures in free air.
diff --git a/pdi-breakdowns.md b/pdi-breakdowns.md
index d5f8f04..c663555 100644
--- a/pdi-breakdowns.md
+++ b/pdi-breakdowns.md
@@ -11,29 +11,35 @@ title: PDI Breakdowns
---
# PDI Breakdowns
-## Bid Item: Site
+## Location
+
+### Bid Item: Site
* `Bid Item` = "1 - Site"
* `Area` = "2 - Site"
* `Phase` = "Site"
-## Bid Item: Garage
+### Bid Item: Garage
* `Bid Item` = "2 - Garage"
* `Area` = "XX - Level XX Garage"
* `Phase` = "Garage"
-## Bid Item: Building
+#### Area: Stairwells Garage
+
+* `Area` = "S - Stairwells Garage"
+
+### Bid Item: Building
* `Bid Item` = "3 - Building"
-### Owner
+#### Owner
-#### Area: Building
+##### Area: Building
* `Area` = "XX - Level XX Building"
-##### Phase: Back of House (BOH)
+###### Phase: Back of House (BOH)
* `Phase` = "Building - Back of House (BOH)"
@@ -42,11 +48,16 @@ Catch all for spaces not
* all bathrooms
* owner offices
-##### Phase: Corridor
+###### Phase: Corridor
* `Phase` = "Building - Corridor"
-#### Area: Interior Amenity
+###### Phase: Units
+
+* `Area` = "Typical - Unit A"
+* `Phase` = "UNIT - ..."
+
+##### Area: Interior Amenity
* `Area` = "XX - Level XX Interior Amenity Building"
* `Phase` = "Interior Amenity"
@@ -69,7 +80,7 @@ Also includes
* meeting rooms
* event spaces
-#### Area: Kitchen
+##### Area: Kitchen
* `Area` = "XX - Level XX Kitchen Building"
* `Phase` = "Kitchen"
@@ -83,7 +94,19 @@ Does not include small "catering kitchens"
which only include 20A provisions
(microwaves, commercial refrigerators, etc.).
-#### Area: Retail
+##### Area: Stairwells Building
+
+* `Area` = "S - Stairwells Building"
+* `Phase` = "Building - Back of House (BOH)"
+
+#### Tenant
+
+Residents of leased units may accurately be called tenants,
+but the unqualified "tenant" almost always refers to _commercial_ tenants.
+
+These spaces seem to be, by definition, [[construction-methods#Core and Shell|shell construction]].
+
+##### Area: Retail
* `Area` = "XX - Level XX Retail Building"
* `Phase` = "Retail"
@@ -91,11 +114,14 @@ which only include 20A provisions
Core and shell for mercantile occupancies.
Does not include finished restaurants
-#### Area: Office Space
+##### Area: Office Space
* `Area` = "XX - Level XX Retail Building"
* `Phase` = "Office Space"
-Core and shell for office occupancies.
+> [!quote] Joel Jansen to William Bonn 2025-12-05 (pp.)
+> PDI Accubid `Phase` "Office Space"
+> is normally used for core & shell retail office space
-"coworking spaces"
+Interpreted as tenant coworking space, a la
+[Coworking & Office Space in St. Pete | Rising Tide](https://risingtidecowork.com/)
diff --git a/subfeeds-takeoff.md b/subfeeds-takeoff.md
index 1950695..e74f64c 100644
--- a/subfeeds-takeoff.md
+++ b/subfeeds-takeoff.md
@@ -9,12 +9,9 @@ tags:
- authorship/original
title: Subfeeds
---
-# Subfeeds
+# Subfeeds Takeoff
-## Unit Load Center Subfeeds
-
-Route from meter center to unit load center,
-using adders appropriate for the difference in elevation.
+Use adders appropriate for the difference in elevation.
Use an additional 10ft for makeup when using cable.
> [!tip]
@@ -24,8 +21,7 @@ Use an additional 10ft for makeup when using cable.
Typical of hotels and dormitories.
-Route from panel to center of the room,
-using adders appropriate for the difference in elevation.
+Route from panel to center of the room.
If voltage drop is to be considered in takeoff,
Use the table provided in the drawings.
@@ -37,6 +33,10 @@ If no table is provided, use the following:
| #10 | 200ft |
| #8 | >200ft |
+## Unit Load Center Subfeeds
+
+Route from meter center to unit load center.
+
#### Pigtail Adaptors
[[distribution-equipment#Pigtail Adaptors|Pigtail Adaptors]]
diff --git a/two-way-takeoff.md b/two-way-takeoff.md
index ded9873..ad21c95 100644
--- a/two-way-takeoff.md
+++ b/two-way-takeoff.md
@@ -23,6 +23,14 @@ title: Two-Way Takeoff
> `System` = "FA - Two Way Communication"
+%%
+It's curious we use the longer of FCR to elevator lobbies/FCR to stairwells
+rather than just the total length,
+since in high-rises _all_ stairwells with locking doors
+require communication systems per
+[[ibc_s0403#403.5.3.1 Stairway communication system.]]
+%%
+
## Horizontal
1. * `Area` = Same as Fire Command Room
diff --git a/units-takeoff.md b/units-takeoff.md
index 3f5339f..651f004 100644
--- a/units-takeoff.md
+++ b/units-takeoff.md
@@ -19,6 +19,8 @@ title: Unit Takeoff
> [!info]
> See [[multi-family-dwellings]].
+[[pdi-building-types]]
+
> [!tip] Preparing for Unit Takeoff
> Units generally have very little variation.
> It is usually best to copy-paste takeoffs
diff --git a/wiring-method-selection.md b/wiring-method-selection.md
index fb8ab39..333c1b0 100644
--- a/wiring-method-selection.md
+++ b/wiring-method-selection.md
@@ -133,7 +133,8 @@ Cable type wiring methods (MC, NM, SE)
may only be used where they will be concealed from view.
> [!important] Exception:
-> Temporary provisions for unfinished spaces (e.g. core and shell retail)
+> Temporary provisions for unfinished spaces
+> (e.g. core and shell [[pdi-building-types#Retail|retail]])
#### Multi-Circuit Homeruns
@@ -196,7 +197,7 @@ Not usually permissible, except in Florida.
## Flow Chart
```mermaid
-flowchart LR
+flowchart
A[Construction Type]
A -- I, II --> B[Can be run in slab?]
B -- No --> D[Concealed?]
@@ -218,5 +219,5 @@ in a 2-hour rated assembly.
This usually requires no change to takeoff for high-rises
since electrical riser rooms are themselves fire-rated.
-* RHW-2 insulated conductors in conduit -- "Lifeline Cable"
-* 2-hour rated metal clad cable -- "Vitalink"
\ No newline at end of file
+* RHW-2 insulated conductors in conduit --- "Lifeline Cable"
+* 2-hour rated metal clad cable --- "Vitalink"
\ No newline at end of file