From 10a81f46ff4ffa00dcb4ede1eb160b3fa182df3d Mon Sep 17 00:00:00 2001
From: DerGrumpf
Date: Tue, 17 Feb 2026 21:56:21 +0100
Subject: [PATCH] vault backup: 2026-02-17 21:56:21
---
.obsidian/plugins/obsidian-pandoc/main.js | 10221 ++++++++++++++++
.../plugins/obsidian-pandoc/manifest.json | 10 +
.obsidian/plugins/obsidian-pandoc/styles.css | 4 +
.obsidian/plugins/typst/main.js | 1116 ++
.obsidian/plugins/typst/manifest.json | 13 +
.../plugins/typst/obsidian_typst_bg.wasm | Bin 0 -> 26995481 bytes
.obsidian/plugins/typst/styles.css | 92 +
Dailys/2026/02 Februar/11.02.2026.md | 4 +-
Dailys/2026/02 Februar/15.02.2026.md | 14 +
Dailys/{ => 2026/02 Februar}/19.02.2026.md | 0
Dailys/2026/Veranstaltungen - 2026.md | 2 +
Dailys/Wohnorte.md | 5 +-
.../IFN/Programmieren WiSe 25 26/course.csv | 4 +-
.../Assets/Vortrag/Danger_dan_Nova_Phil.pdf | Bin 0 -> 1745212 bytes
.../Medienrecht/Assets/Vortrag/Ideas.md | 5 +
...gsreihenfolge_SE__MR_WS_25_26_Theissen.pdf | Bin 0 -> 492387 bytes
Todo.md | 10 +-
17 files changed, 11488 insertions(+), 12 deletions(-)
create mode 100644 .obsidian/plugins/obsidian-pandoc/main.js
create mode 100644 .obsidian/plugins/obsidian-pandoc/manifest.json
create mode 100644 .obsidian/plugins/obsidian-pandoc/styles.css
create mode 100644 .obsidian/plugins/typst/main.js
create mode 100644 .obsidian/plugins/typst/manifest.json
create mode 100644 .obsidian/plugins/typst/obsidian_typst_bg.wasm
create mode 100644 .obsidian/plugins/typst/styles.css
create mode 100644 Dailys/2026/02 Februar/15.02.2026.md
rename Dailys/{ => 2026/02 Februar}/19.02.2026.md (100%)
create mode 100644 Semester/WiSe 2526/Medienrecht/Assets/Vortrag/Danger_dan_Nova_Phil.pdf
create mode 100644 Semester/WiSe 2526/Medienrecht/Assets/Vortrag/Vortragsreihenfolge_SE__MR_WS_25_26_Theissen.pdf
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/.obsidian/plugins/typst/main.js b/.obsidian/plugins/typst/main.js
new file mode 100644
index 0000000..06009e8
--- /dev/null
+++ b/.obsidian/plugins/typst/main.js
@@ -0,0 +1,1116 @@
+/*
+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 __commonJS = (cb, mod) => function __require() {
+ return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+ for (var name in all)
+ __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+ if (from && typeof from === "object" || typeof from === "function") {
+ for (let key of __getOwnPropNames(from))
+ if (!__hasOwnProp.call(to, key) && key !== except)
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+ }
+ return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+ // If the importer is in node compatibility mode or this is not an ESM
+ // file that has been converted to a CommonJS file using a Babel-
+ // compatible transform (i.e. "__esModule" has not been set), then set
+ // "default" to the CommonJS "module.exports" for node compatibility.
+ isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+ mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/js-untar/build/dist/untar.js
+var require_untar = __commonJS({
+ "node_modules/js-untar/build/dist/untar.js"(exports, module2) {
+ !function(e, r) {
+ "function" == typeof define && define.amd ? define([], r) : "object" == typeof exports ? module2.exports = r() : e.untar = r();
+ }(exports, function() {
+ "use strict";
+ function e(e2) {
+ function r2(e3) {
+ for (var r3 = 0, n3 = t2.length; r3 < n3; ++r3)
+ t2[r3](e3);
+ a2.push(e3);
+ }
+ if ("function" != typeof Promise)
+ throw new Error("Promise implementation not available in this environment.");
+ var t2 = [], a2 = [], n2 = new Promise(function(t3, a3) {
+ e2(t3, a3, r2);
+ });
+ n2.progress = function(e3) {
+ if ("function" != typeof e3)
+ throw new Error("cb is not a function.");
+ for (var r3 = 0, i3 = a2.length; r3 < i3; ++r3)
+ e3(a2[r3]);
+ return t2.push(e3), n2;
+ };
+ var i2 = n2.then;
+ return n2.then = function(e3, r3, t3) {
+ return i2.call(n2, e3, r3), void 0 !== t3 && n2.progress(t3), n2;
+ }, n2;
+ }
+ function r(r2) {
+ if (!(r2 instanceof ArrayBuffer))
+ throw new TypeError("arrayBuffer is not an instance of ArrayBuffer.");
+ if (!n.Worker)
+ throw new Error("Worker implementation is not available in this environment.");
+ return new e(function(e2, n2, i2) {
+ var o2 = new Worker(a), s = [];
+ o2.onerror = function(e3) {
+ n2(e3);
+ }, o2.onmessage = function(r3) {
+ switch (r3 = r3.data, r3.type) {
+ case "log":
+ console[r3.data.level]("Worker: " + r3.data.msg);
+ break;
+ case "extract":
+ var a2 = t(r3.data);
+ s.push(a2), i2(a2);
+ break;
+ case "complete":
+ o2.terminate(), e2(s);
+ break;
+ case "error":
+ o2.terminate(), n2(new Error(r3.data.message));
+ break;
+ default:
+ o2.terminate(), n2(new Error("Unknown message from worker: " + r3.type));
+ }
+ }, o2.postMessage({ type: "extract", buffer: r2 }, [r2]);
+ });
+ }
+ function t(e2) {
+ return Object.defineProperties(e2, o), e2;
+ }
+ var a, n = window || this, i = n.URL || n.webkitURL, o = { blob: { get: function() {
+ return this._blob || (this._blob = new Blob([this.buffer]));
+ } }, getBlobUrl: { value: function() {
+ return this._blobUrl || (this._blobUrl = i.createObjectURL(this.blob));
+ } }, readAsString: { value: function() {
+ for (var e2 = this.buffer, r2 = e2.byteLength, t2 = 1, a2 = new DataView(e2), n2 = [], i2 = 0; i2 < r2; ++i2) {
+ var o2 = a2.getUint8(i2 * t2, true);
+ n2.push(o2);
+ }
+ return this._string = String.fromCharCode.apply(null, n2);
+ } }, readAsJSON: { value: function() {
+ return JSON.parse(this.readAsString());
+ } } };
+ return a = (window || this).URL.createObjectURL(new Blob(['"use strict";function UntarWorker(){}function decodeUTF8(e){for(var r="",t=0;t127){if(a>191&&a<224){if(t>=e.length)throw"UTF-8 decode: incomplete 2-byte sequence";a=(31&a)<<6|63&e[t]}else if(a>223&&a<240){if(t+1>=e.length)throw"UTF-8 decode: incomplete 3-byte sequence";a=(15&a)<<12|(63&e[t])<<6|63&e[++t]}else{if(!(a>239&&a<248))throw"UTF-8 decode: unknown multibyte start 0x"+a.toString(16)+" at index "+(t-1);if(t+2>=e.length)throw"UTF-8 decode: incomplete 4-byte sequence";a=(7&a)<<18|(63&e[t])<<12|(63&e[++t])<<6|63&e[++t]}++t}if(a<=65535)r+=String.fromCharCode(a);else{if(!(a<=1114111))throw"UTF-8 decode: code point 0x"+a.toString(16)+" exceeds UTF-16 reach";a-=65536,r+=String.fromCharCode(a>>10|55296),r+=String.fromCharCode(1023&a|56320)}}return r}function PaxHeader(e){this._fields=e}function TarFile(){}function UntarStream(e){this._bufferView=new DataView(e),this._position=0}function UntarFileStream(e){this._stream=new UntarStream(e),this._globalPaxHeader=null}if(UntarWorker.prototype={onmessage:function(e){try{if("extract"!==e.data.type)throw new Error("Unknown message type: "+e.data.type);this.untarBuffer(e.data.buffer)}catch(r){this.postError(r)}},postError:function(e){this.postMessage({type:"error",data:{message:e.message}})},postLog:function(e,r){this.postMessage({type:"log",data:{level:e,msg:r}})},untarBuffer:function(e){try{for(var r=new UntarFileStream(e);r.hasNext();){var t=r.next();this.postMessage({type:"extract",data:t},[t.buffer])}this.postMessage({type:"complete"})}catch(a){this.postError(a)}},postMessage:function(e,r){self.postMessage(e,r)}},"undefined"!=typeof self){var worker=new UntarWorker;self.onmessage=function(e){worker.onmessage(e)}}PaxHeader.parse=function(e){for(var r=new Uint8Array(e),t=[];r.length>0;){var a=parseInt(decodeUTF8(r.subarray(0,r.indexOf(32)))),n=decodeUTF8(r.subarray(0,a)),i=n.match(/^\\d+ ([^=]+)=(.*)\\n$/);if(null===i)throw new Error("Invalid PAX header data format.");var s=i[1],o=i[2];0===o.length?o=null:null!==o.match(/^\\d+$/)&&(o=parseInt(o));var f={name:s,value:o};t.push(f),r=r.subarray(a)}return new PaxHeader(t)},PaxHeader.prototype={applyHeader:function(e){this._fields.forEach(function(r){var t=r.name,a=r.value;"path"===t?(t="name",void 0!==e.prefix&&delete e.prefix):"linkpath"===t&&(t="linkname"),null===a?delete e[t]:e[t]=a})}},UntarStream.prototype={readString:function(e){for(var r=1,t=e*r,a=[],n=0;n-1&&(r.version=e.readString(2),r.uname=e.readString(32),r.gname=e.readString(32),r.devmajor=parseInt(e.readString(8)),r.devminor=parseInt(e.readString(8)),r.namePrefix=e.readString(155),r.namePrefix.length>0&&(r.name=r.namePrefix+"/"+r.name)),e.position(i),r.type){case"0":case"":r.buffer=e.readBuffer(r.size);break;case"1":break;case"2":break;case"3":break;case"4":break;case"5":break;case"6":break;case"7":break;case"g":t=!0,this._globalPaxHeader=PaxHeader.parse(e.readBuffer(r.size));break;case"x":t=!0,a=PaxHeader.parse(e.readBuffer(r.size))}void 0===r.buffer&&(r.buffer=new ArrayBuffer(0));var s=i+r.size;return r.size%512!==0&&(s+=512-r.size%512),e.position(s),t&&(r=this._readNextFile()),null!==this._globalPaxHeader&&this._globalPaxHeader.applyHeader(r),null!==a&&a.applyHeader(r),r}};'])), r;
+ });
+ }
+});
+
+// src/main.ts
+var main_exports = {};
+__export(main_exports, {
+ default: () => TypstPlugin
+});
+module.exports = __toCommonJS(main_exports);
+var import_obsidian = require("obsidian");
+
+// src/compiler.worker.ts
+function inlineWorker() {
+ let blob = new Blob(['var re={},o,B=typeof TextDecoder!="undefined"?new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0}):{decode:()=>{throw Error("TextDecoder not available")}};typeof TextDecoder!="undefined"&&B.decode();var p=null;function v(){return(p===null||p.byteLength===0)&&(p=new Uint8Array(o.memory.buffer)),p}function M(t,e){return t=t>>>0,B.decode(v().subarray(t,t+e))}var d=new Array(128).fill(void 0);d.push(void 0,null,!0,!1);var T=d.length;function w(t){T===d.length&&d.push(d.length+1);let e=T;return T=d[e],d[e]=t,e}function f(t){return d[t]}function V(t){t<132||(d[t]=T,T=t)}function x(t){let e=f(t);return V(t),e}function O(t){return t==null}var h=null;function X(){return(h===null||h.byteLength===0)&&(h=new Float64Array(o.memory.buffer)),h}var A=null;function _(){return(A===null||A.byteLength===0)&&(A=new Int32Array(o.memory.buffer)),A}var l=0,W=typeof TextEncoder!="undefined"?new TextEncoder("utf-8"):{encode:()=>{throw Error("TextEncoder not available")}},J=typeof W.encodeInto=="function"?function(t,e){return W.encodeInto(t,e)}:function(t,e){let n=W.encode(t);return e.set(n),{read:t.length,written:n.length}};function g(t,e,n){if(n===void 0){let c=W.encode(t),u=e(c.length,1)>>>0;return v().subarray(u,u+c.length).set(c),l=c.length,u}let r=t.length,a=e(r,1)>>>0,i=v(),s=0;for(;s127)break;i[a+s]=c}if(s!==r){s!==0&&(t=t.slice(s)),a=n(a,r,r=s+t.length*3,1)>>>0;let c=v().subarray(a+s,a+r),u=J(t,c);s+=u.written}return l=s,a}var E=128;function K(t){if(E==1)throw new Error("out of js stack");return d[--E]=t,E}function Q(t,e){let n=e(t.length*1,1)>>>0;return v().set(t,n/1),l=t.length,n}var k=null;function Y(){return(k===null||k.byteLength===0)&&(k=new Uint8ClampedArray(o.memory.buffer)),k}function Z(t,e){return t=t>>>0,Y().subarray(t/1,t/1+e)}function R(t,e){try{return t.apply(this,e)}catch(n){o.__wbindgen_exn_store(w(n))}}var U=class{__destroy_into_raw(){let e=this.__wbg_ptr;return this.__wbg_ptr=0,e}free(){let e=this.__destroy_into_raw();o.__wbg_systemworld_free(e)}constructor(e,n){try{let r=g(e,o.__wbindgen_malloc,o.__wbindgen_realloc),a=l,i=o.systemworld_new(r,a,K(n));return this.__wbg_ptr=i>>>0,this}finally{d[E++]=void 0}}compile_image(e,n,r,a,i,s){try{let b=o.__wbindgen_add_to_stack_pointer(-16),m=g(e,o.__wbindgen_malloc,o.__wbindgen_realloc),S=l,L=g(n,o.__wbindgen_malloc,o.__wbindgen_realloc),j=l,D=g(a,o.__wbindgen_malloc,o.__wbindgen_realloc),G=l;o.systemworld_compile_image(b,this.__wbg_ptr,m,S,L,j,r,D,G,i,s);var c=_()[b/4+0],u=_()[b/4+1],y=_()[b/4+2];if(y)throw x(u);return x(c)}finally{o.__wbindgen_add_to_stack_pointer(16)}}compile_svg(e,n){let r,a;try{let m=o.__wbindgen_add_to_stack_pointer(-16),S=g(e,o.__wbindgen_malloc,o.__wbindgen_realloc),L=l,j=g(n,o.__wbindgen_malloc,o.__wbindgen_realloc),D=l;o.systemworld_compile_svg(m,this.__wbg_ptr,S,L,j,D);var i=_()[m/4+0],s=_()[m/4+1],c=_()[m/4+2],u=_()[m/4+3],y=i,b=s;if(u)throw y=0,b=0,x(c);return r=y,a=b,M(y,b)}finally{o.__wbindgen_add_to_stack_pointer(16),o.__wbindgen_free(r,a,1)}}add_font(e){let n=Q(e,o.__wbindgen_malloc),r=l;o.systemworld_add_font(this.__wbg_ptr,n,r)}};async function $(t,e){if(typeof Response=="function"&&t instanceof Response){if(typeof WebAssembly.instantiateStreaming=="function")try{return await WebAssembly.instantiateStreaming(t,e)}catch(r){if(t.headers.get("Content-Type")!="application/wasm")console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\\n",r);else throw r}let n=await t.arrayBuffer();return await WebAssembly.instantiate(n,e)}else{let n=await WebAssembly.instantiate(t,e);return n instanceof WebAssembly.Instance?{instance:n,module:t}:n}}function ee(){let t={};return t.wbg={},t.wbg.__wbindgen_string_new=function(e,n){let r=M(e,n);return w(r)},t.wbg.__wbindgen_object_drop_ref=function(e){x(e)},t.wbg.__wbindgen_number_get=function(e,n){let r=f(n),a=typeof r=="number"?r:void 0;X()[e/8+1]=O(a)?0:a,_()[e/4+0]=!O(a)},t.wbg.__wbindgen_string_get=function(e,n){let r=f(n),a=typeof r=="string"?r:void 0;var i=O(a)?0:g(a,o.__wbindgen_malloc,o.__wbindgen_realloc),s=l;_()[e/4+1]=s,_()[e/4+0]=i},t.wbg.__wbindgen_object_clone_ref=function(e){let n=f(e);return w(n)},t.wbg.__wbg_new_abda76e883ba8a5f=function(){let e=new Error;return w(e)},t.wbg.__wbg_stack_658279fe44541cf6=function(e,n){let r=f(n).stack,a=g(r,o.__wbindgen_malloc,o.__wbindgen_realloc),i=l;_()[e/4+1]=i,_()[e/4+0]=a},t.wbg.__wbg_error_f851667af71bcfc6=function(e,n){let r,a;try{r=e,a=n,console.error(M(e,n))}finally{o.__wbindgen_free(r,a,1)}},t.wbg.__wbg_newwithu8clampedarrayandsh_d94fd1baabf57428=function(){return R(function(e,n,r,a){let i=new ImageData(Z(e,n),r>>>0,a>>>0);return w(i)},arguments)},t.wbg.__wbindgen_number_new=function(e){return w(e)},t.wbg.__wbg_call_53fc3abd42e24ec8=function(){return R(function(e,n,r){let a=f(e).call(f(n),f(r));return w(a)},arguments)},t.wbg.__wbg_getTime_ed6ee333b702f8fc=function(e){return f(e).getTime()},t.wbg.__wbg_getTimezoneOffset_5cb2b8973dd9f251=function(e){return f(e).getTimezoneOffset()},t.wbg.__wbg_new_a49511604c14761d=function(e){let n=new Date(f(e));return w(n)},t.wbg.__wbg_new0_ad75dd38f92424e2=function(){return w(new Date)},t.wbg.__wbindgen_throw=function(e,n){throw new Error(M(e,n))},t}function te(t,e){return o=t.exports,F.__wbindgen_wasm_module=e,h=null,A=null,p=null,k=null,o}async function F(t){if(o!==void 0)return o;typeof t=="undefined"&&(t=new URL("obsidian_typst_bg.wasm",re.url));let e=ee();(typeof t=="string"||typeof Request=="function"&&t instanceof Request||typeof URL=="function"&&t instanceof URL)&&(t=fetch(t));let{instance:n,module:r}=await $(await t,e);return te(n,r)}var q=F;var z=!1,oe=new TextDecoder,P,H,N=[],C=new XMLHttpRequest;function ae(t){try{if(!z){if(t.startsWith("@")){if(N.includes(t.slice(1)))return H+t.slice(1);throw 2}t="http://localhost/_capacitor_file_"+P+"/"+t,C.open("GET",t,!1);try{C.send()}catch(r){throw console.error(r),3}if(C.status==404)throw 2;return C.responseText}let e=new Int32Array(new SharedArrayBuffer(4,{maxByteLength:1e8}));e[0]=0,postMessage({buffer:e,path:t});let n=Atomics.wait(e,0,0);if(e[0]==0)return oe.decode(Uint8Array.from(e.slice(1)));throw e[0]}catch(e){throw typeof e!="number"?(console.error(e),1):e}}var I;onmessage=t=>{let e=t.data;switch(e.type){case"canUseSharedArrayBuffer":z=e.data;break;case"startup":q(e.data.wasm).then(n=>{I=new U("",ae),console.log("Typst web assembly loaded!")}),P=e.data.basePath,H=e.data.packagePath;break;case"fonts":e.data.forEach(n=>I.add_font(new Uint8Array(n)));break;case"compile":if(e.data.format=="image"){let n=e.data;postMessage(I.compile_image(n.source,n.path,n.pixel_per_pt,n.fill,n.size,n.display))}else e.data.format=="svg"&&postMessage(I.compile_svg(e.data.source,e.data.path));break;case"packages":N=e.data;break;default:throw e}};console.log("Typst compiler worker loaded!");\n']);
+ let url = URL.createObjectURL(blob);
+ let worker = new Worker(url);
+ URL.revokeObjectURL(url);
+ return worker;
+}
+
+// src/typst-render-element.ts
+var _TypstRenderElement = class _TypstRenderElement extends HTMLElement {
+ async connectedCallback() {
+ if (!this.isConnected) {
+ console.warn("Typst Renderer: Canvas element has been called before connection");
+ return;
+ }
+ if (this.format == "image" && this.canvas == void 0) {
+ this.canvas = this.appendChild(createEl("canvas", { attr: { height: _TypstRenderElement.prevHeight }, cls: "typst-doc" }));
+ }
+ this.num = _TypstRenderElement.nextId.toString();
+ _TypstRenderElement.nextId += 1;
+ this.id = "TypstRenderElement-" + this.num;
+ this.abortController = new AbortController();
+ if (this.display) {
+ this.style.display = "block";
+ this.resizeObserver = new ResizeObserver((entries) => {
+ var _a2;
+ if (((_a2 = entries[0]) == null ? void 0 : _a2.contentBoxSize[0].inlineSize) !== this.size) {
+ this.draw();
+ }
+ });
+ this.resizeObserver.observe(this);
+ }
+ await this.draw();
+ }
+ disconnectedCallback() {
+ if (this.format == "image") {
+ _TypstRenderElement.prevHeight = this.canvas.height;
+ }
+ if (this.display && this.resizeObserver != void 0) {
+ this.resizeObserver.disconnect();
+ }
+ }
+ async draw() {
+ this.abortController.abort();
+ this.abortController = new AbortController();
+ try {
+ await navigator.locks.request(this.id, { signal: this.abortController.signal }, async () => {
+ let fontSize = parseFloat(getComputedStyle(this).fontSize);
+ this.size = this.display ? this.clientWidth : parseFloat(getComputedStyle(this).lineHeight);
+ if (!(this.size > 0)) {
+ return;
+ }
+ try {
+ let result = await _TypstRenderElement.compile(this.path, this.source, this.size, this.display, fontSize);
+ if (result instanceof ImageData && this.format == "image") {
+ this.drawToCanvas(result);
+ } else if (typeof result == "string" && this.format == "svg") {
+ this.innerHTML = result;
+ let child = this.firstElementChild;
+ child.setAttribute("width", child.getAttribute("width").replace("pt", ""));
+ child.setAttribute("height", child.getAttribute("height").replace("pt", ""));
+ child.setAttribute("width", `${this.firstElementChild.clientWidth / fontSize}em`);
+ child.setAttribute("height", `${this.firstElementChild.clientHeight / fontSize}em`);
+ }
+ } catch (error) {
+ error = error.slice(9);
+ let pre = createEl("pre", {
+ attr: {
+ style: "white-space: pre;"
+ }
+ });
+ pre.textContent = error;
+ this.outerHTML = pre.outerHTML;
+ return;
+ }
+ });
+ } catch (error) {
+ return;
+ }
+ }
+ drawToCanvas(image) {
+ let ctx = this.canvas.getContext("2d");
+ this.canvas.width = image.width;
+ this.canvas.height = image.height;
+ ctx.imageSmoothingEnabled = true;
+ ctx.imageSmoothingQuality = "high";
+ ctx.putImageData(image, 0, 0);
+ }
+};
+_TypstRenderElement.nextId = 0;
+_TypstRenderElement.prevHeight = 0;
+var TypstRenderElement = _TypstRenderElement;
+
+// src/main.ts
+var import_js_untar = __toESM(require_untar());
+
+// node_modules/fflate/esm/browser.js
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 2,
+ 2,
+ 2,
+ 2,
+ 3,
+ 3,
+ 3,
+ 3,
+ 4,
+ 4,
+ 4,
+ 4,
+ 5,
+ 5,
+ 5,
+ 5,
+ 0,
+ /* unused */
+ 0,
+ 0,
+ /* impossible */
+ 0
+]);
+var fdeb = new u8([
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 2,
+ 2,
+ 3,
+ 3,
+ 4,
+ 4,
+ 5,
+ 5,
+ 6,
+ 6,
+ 7,
+ 7,
+ 8,
+ 8,
+ 9,
+ 9,
+ 10,
+ 10,
+ 11,
+ 11,
+ 12,
+ 12,
+ 13,
+ 13,
+ /* unused */
+ 0,
+ 0
+]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+ var b = new u16(31);
+ for (var i = 0; i < 31; ++i) {
+ b[i] = start += 1 << eb[i - 1];
+ }
+ var r = new i32(b[30]);
+ for (var i = 1; i < 30; ++i) {
+ for (var j = b[i]; j < b[i + 1]; ++j) {
+ r[j] = j - b[i] << 5 | i;
+ }
+ }
+ return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0; i < 32768; ++i) {
+ x = (i & 43690) >> 1 | (i & 21845) << 1;
+ x = (x & 52428) >> 2 | (x & 13107) << 2;
+ x = (x & 61680) >> 4 | (x & 3855) << 4;
+ rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = function(cd, mb, r) {
+ var s = cd.length;
+ var i = 0;
+ var l = new u16(mb);
+ for (; i < s; ++i) {
+ if (cd[i])
+ ++l[cd[i] - 1];
+ }
+ var le = new u16(mb);
+ for (i = 1; i < mb; ++i) {
+ le[i] = le[i - 1] + l[i - 1] << 1;
+ }
+ var co;
+ if (r) {
+ co = new u16(1 << mb);
+ var rvb = 15 - mb;
+ for (i = 0; i < s; ++i) {
+ if (cd[i]) {
+ var sv = i << 4 | cd[i];
+ var r_1 = mb - cd[i];
+ var v = le[cd[i] - 1]++ << r_1;
+ for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+ co[rev[v] >> rvb] = sv;
+ }
+ }
+ }
+ } else {
+ co = new u16(s);
+ for (i = 0; i < s; ++i) {
+ if (cd[i]) {
+ co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+ }
+ }
+ }
+ return co;
+};
+var flt = new u8(288);
+for (i = 0; i < 144; ++i)
+ flt[i] = 8;
+var i;
+for (i = 144; i < 256; ++i)
+ flt[i] = 9;
+var i;
+for (i = 256; i < 280; ++i)
+ flt[i] = 7;
+var i;
+for (i = 280; i < 288; ++i)
+ flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0; i < 32; ++i)
+ fdt[i] = 5;
+var i;
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a) {
+ var m = a[0];
+ for (var i = 1; i < a.length; ++i) {
+ if (a[i] > m)
+ m = a[i];
+ }
+ return m;
+};
+var bits = function(d, p, m) {
+ var o = p / 8 | 0;
+ return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+ var o = p / 8 | 0;
+ return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+ return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+ if (s == null || s < 0)
+ s = 0;
+ if (e == null || e > v.length)
+ e = v.length;
+ return new u8(v.subarray(s, e));
+};
+var ec = [
+ "unexpected EOF",
+ "invalid block type",
+ "invalid length/literal",
+ "invalid distance",
+ "stream finished",
+ "no stream handler",
+ ,
+ "no callback",
+ "invalid UTF-8 data",
+ "extra field too long",
+ "date not in range 1980-2099",
+ "filename too long",
+ "stream finishing",
+ "invalid zip data"
+ // determined by unknown compression method
+];
+var err = function(ind, msg, nt) {
+ var e = new Error(msg || ec[ind]);
+ e.code = ind;
+ if (Error.captureStackTrace)
+ Error.captureStackTrace(e, err);
+ if (!nt)
+ throw e;
+ return e;
+};
+var inflt = function(dat, st, buf, dict) {
+ var sl = dat.length, dl = dict ? dict.length : 0;
+ if (!sl || st.f && !st.l)
+ return buf || new u8(0);
+ var noBuf = !buf;
+ var resize = noBuf || st.i != 2;
+ var noSt = st.i;
+ if (noBuf)
+ buf = new u8(sl * 3);
+ var cbuf = function(l2) {
+ var bl = buf.length;
+ if (l2 > bl) {
+ var nbuf = new u8(Math.max(bl * 2, l2));
+ nbuf.set(buf);
+ buf = nbuf;
+ }
+ };
+ var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+ var tbts = sl * 8;
+ do {
+ if (!lm) {
+ final = bits(dat, pos, 1);
+ var type = bits(dat, pos + 1, 3);
+ pos += 3;
+ if (!type) {
+ var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+ if (t > sl) {
+ if (noSt)
+ err(0);
+ break;
+ }
+ if (resize)
+ cbuf(bt + l);
+ buf.set(dat.subarray(s, t), bt);
+ st.b = bt += l, st.p = pos = t * 8, st.f = final;
+ continue;
+ } else if (type == 1)
+ lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+ else if (type == 2) {
+ var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+ var tl = hLit + bits(dat, pos + 5, 31) + 1;
+ pos += 14;
+ var ldt = new u8(tl);
+ var clt = new u8(19);
+ for (var i = 0; i < hcLen; ++i) {
+ clt[clim[i]] = bits(dat, pos + i * 3, 7);
+ }
+ pos += hcLen * 3;
+ var clb = max(clt), clbmsk = (1 << clb) - 1;
+ var clm = hMap(clt, clb, 1);
+ for (var i = 0; i < tl; ) {
+ var r = clm[bits(dat, pos, clbmsk)];
+ pos += r & 15;
+ var s = r >> 4;
+ if (s < 16) {
+ ldt[i++] = s;
+ } else {
+ var c = 0, n = 0;
+ if (s == 16)
+ n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+ else if (s == 17)
+ n = 3 + bits(dat, pos, 7), pos += 3;
+ else if (s == 18)
+ n = 11 + bits(dat, pos, 127), pos += 7;
+ while (n--)
+ ldt[i++] = c;
+ }
+ }
+ var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+ lbt = max(lt);
+ dbt = max(dt);
+ lm = hMap(lt, lbt, 1);
+ dm = hMap(dt, dbt, 1);
+ } else
+ err(1);
+ if (pos > tbts) {
+ if (noSt)
+ err(0);
+ break;
+ }
+ }
+ if (resize)
+ cbuf(bt + 131072);
+ var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+ var lpos = pos;
+ for (; ; lpos = pos) {
+ var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+ pos += c & 15;
+ if (pos > tbts) {
+ if (noSt)
+ err(0);
+ break;
+ }
+ if (!c)
+ err(2);
+ if (sym < 256)
+ buf[bt++] = sym;
+ else if (sym == 256) {
+ lpos = pos, lm = null;
+ break;
+ } else {
+ var add = sym - 254;
+ if (sym > 264) {
+ var i = sym - 257, b = fleb[i];
+ add = bits(dat, pos, (1 << b) - 1) + fl[i];
+ pos += b;
+ }
+ var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+ if (!d)
+ err(3);
+ pos += d & 15;
+ var dt = fd[dsym];
+ if (dsym > 3) {
+ var b = fdeb[dsym];
+ dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+ }
+ if (pos > tbts) {
+ if (noSt)
+ err(0);
+ break;
+ }
+ if (resize)
+ cbuf(bt + 131072);
+ var end = bt + add;
+ if (bt < dt) {
+ var shift = dl - dt, dend = Math.min(dt, end);
+ if (shift + bt < 0)
+ err(3);
+ for (; bt < dend; ++bt)
+ buf[bt] = dict[shift + bt];
+ }
+ for (; bt < end; ++bt)
+ buf[bt] = buf[bt - dt];
+ }
+ }
+ st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+ if (lm)
+ final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+ } while (!final);
+ return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /* @__PURE__ */ new u8(0);
+var gzs = function(d) {
+ if (d[0] != 31 || d[1] != 139 || d[2] != 8)
+ err(6, "invalid gzip data");
+ var flg = d[3];
+ var st = 10;
+ if (flg & 4)
+ st += (d[10] | d[11] << 8) + 2;
+ for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])
+ ;
+ return st + (flg & 2);
+};
+var gzl = function(d) {
+ var l = d.length;
+ return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
+};
+var zls = function(d, dict) {
+ if ((d[0] & 15) != 8 || d[0] >> 4 > 7 || (d[0] << 8 | d[1]) % 31)
+ err(6, "invalid zlib data");
+ if ((d[1] >> 5 & 1) == +!dict)
+ err(6, "invalid zlib data: " + (d[1] & 32 ? "need" : "unexpected") + " dictionary");
+ return (d[1] >> 3 & 4) + 2;
+};
+function inflateSync(data, opts) {
+ return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+function gunzipSync(data, opts) {
+ var st = gzs(data);
+ if (st + 8 > data.length)
+ err(6, "invalid gzip data");
+ return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary);
+}
+function unzlibSync(data, opts) {
+ return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+function decompressSync(data, opts) {
+ return data[0] == 31 && data[1] == 139 && data[2] == 8 ? gunzipSync(data, opts) : (data[0] & 15) != 8 || data[0] >> 4 > 7 || (data[0] << 8 | data[1]) % 31 ? inflateSync(data, opts) : unzlibSync(data, opts);
+}
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+ td.decode(et, { stream: true });
+ tds = 1;
+} catch (e) {
+}
+
+// src/main.ts
+var DEFAULT_SETTINGS = {
+ format: "image",
+ noFill: true,
+ fill: "#ffffff",
+ pixel_per_pt: 3,
+ search_system: false,
+ override_math: false,
+ font_families: [],
+ preamable: {
+ shared: "#set text(fill: white, size: SIZE)\n#set page(width: WIDTH, height: HEIGHT)",
+ math: "#set page(margin: 0pt)\n#set align(horizon)",
+ code: "#set page(margin: (y: 1em, x: 0pt))"
+ },
+ plugin_version: "0.10.0",
+ autoDownloadPackages: true
+};
+var TypstPlugin = class extends import_obsidian.Plugin {
+ constructor() {
+ super(...arguments);
+ this.prevCanvasHeight = 0;
+ }
+ async onload() {
+ console.log("loading Typst Renderer");
+ this.textEncoder = new TextEncoder();
+ await this.loadSettings();
+ this.pluginPath = this.app.vault.configDir + "/plugins/typst/";
+ this.packagePath = this.pluginPath + "packages/";
+ this.wasmPath = this.pluginPath + "obsidian_typst_bg.wasm";
+ this.compilerWorker = new inlineWorker();
+ if (!await this.app.vault.adapter.exists(this.wasmPath) || this.settings.plugin_version != "0.10.0") {
+ new import_obsidian.Notice("Typst Renderer: Downloading required web assembly component!", 5e3);
+ try {
+ await this.fetchWasm();
+ new import_obsidian.Notice("Typst Renderer: Web assembly component downloaded!", 5e3);
+ } catch (error) {
+ new import_obsidian.Notice("Typst Renderer: Failed to fetch component: " + error, 0);
+ console.error("Typst Renderer: Failed to fetch component: " + error);
+ }
+ }
+ this.compilerWorker.postMessage({
+ type: "startup",
+ data: {
+ wasm: URL.createObjectURL(
+ new Blob(
+ [await this.app.vault.adapter.readBinary(this.wasmPath)],
+ { type: "application/wasm" }
+ )
+ ),
+ //@ts-ignore
+ basePath: this.app.vault.adapter.basePath,
+ packagePath: this.packagePath
+ }
+ });
+ if (import_obsidian.Platform.isDesktopApp) {
+ this.compilerWorker.postMessage({ type: "canUseSharedArrayBuffer", data: true });
+ this.fs = require("fs");
+ let fonts = await Promise.all(
+ //@ts-expect-error
+ (await window.queryLocalFonts()).filter((font) => this.settings.font_families.contains(font.family.toLowerCase())).map(
+ async (font) => await (await font.blob()).arrayBuffer()
+ )
+ );
+ this.compilerWorker.postMessage({ type: "fonts", data: fonts }, fonts);
+ } else {
+ await this.app.vault.adapter.mkdir(this.packagePath);
+ const packages = await this.getPackageList();
+ this.compilerWorker.postMessage({ type: "packages", data: packages });
+ }
+ TypstRenderElement.compile = (a, b, c, d, e) => this.processThenCompileTypst(a, b, c, d, e);
+ if (customElements.get("typst-renderer") == void 0) {
+ customElements.define("typst-renderer", TypstRenderElement);
+ }
+ await (0, import_obsidian.loadMathJax)();
+ (0, import_obsidian.renderMath)("", false);
+ this.tex2chtml = MathJax.tex2chtml;
+ this.overrideMathJax(this.settings.override_math);
+ this.addCommand({
+ id: "toggle-math-override",
+ name: "Toggle math block override",
+ callback: () => this.overrideMathJax(!this.settings.override_math)
+ });
+ this.addSettingTab(new TypstSettingTab(this.app, this));
+ this.registerMarkdownCodeBlockProcessor("typst", async (source, el, ctx) => {
+ el.appendChild(this.createTypstRenderElement("/" + ctx.sourcePath, `${this.settings.preamable.code}
+${source}`, true, false));
+ });
+ console.log("loaded Typst Renderer");
+ }
+ async fetchWasm() {
+ let response;
+ let data;
+ response = (0, import_obsidian.requestUrl)(`https://api.github.com/repos/fenjalien/obsidian-typst/releases/tags/${"0.10.0"}`);
+ data = await response.json;
+ let asset = data.assets.find((a) => a.name == "obsidian_typst_bg.wasm");
+ if (asset == void 0) {
+ throw "Could not find the correct file!";
+ }
+ response = (0, import_obsidian.requestUrl)({ url: asset.url, headers: { "Accept": "application/octet-stream" } });
+ data = await response.arrayBuffer;
+ await this.app.vault.adapter.writeBinary(
+ this.wasmPath,
+ data
+ );
+ this.settings.plugin_version = "0.10.0";
+ await this.saveSettings();
+ }
+ async getPackageList() {
+ let getFolders = async (f) => (await this.app.vault.adapter.list(f)).folders;
+ let packages = [];
+ for (const namespace of await getFolders(this.packagePath)) {
+ for (const name of await getFolders(namespace)) {
+ for (const version of await getFolders(name)) {
+ packages.push(version.split("/").slice(-3).join("/"));
+ }
+ }
+ }
+ return packages;
+ }
+ async deletePackages(packages) {
+ for (const folder of packages) {
+ await this.app.vault.adapter.rmdir(this.packagePath + folder, true);
+ }
+ }
+ async compileToTypst(path, source, size, display) {
+ return await navigator.locks.request("typst renderer compiler", async (lock) => {
+ let message;
+ if (this.settings.format == "svg") {
+ message = {
+ type: "compile",
+ data: {
+ format: "svg",
+ path,
+ source
+ }
+ };
+ } else if (this.settings.format == "image") {
+ message = {
+ type: "compile",
+ data: {
+ format: "image",
+ source,
+ path,
+ pixel_per_pt: this.settings.pixel_per_pt,
+ fill: `${this.settings.fill}${this.settings.noFill ? "00" : "ff"}`,
+ size,
+ display
+ }
+ };
+ }
+ this.compilerWorker.postMessage(message);
+ while (true) {
+ let result;
+ try {
+ result = await new Promise((resolve, reject) => {
+ const listener = (ev) => {
+ remove();
+ resolve(ev.data);
+ };
+ const errorListener = (error) => {
+ remove();
+ reject(error.message);
+ };
+ const remove = () => {
+ this.compilerWorker.removeEventListener("message", listener);
+ this.compilerWorker.removeEventListener("error", errorListener);
+ };
+ this.compilerWorker.addEventListener("message", listener);
+ this.compilerWorker.addEventListener("error", errorListener);
+ });
+ } catch (e) {
+ if (import_obsidian.Platform.isMobileApp && e.startsWith("Uncaught Error: package not found (searched for")) {
+ const spec = e.match(/"@preview\/.*?"/)[0].slice(2, -1).replace(":", "/");
+ const [namespace, name, version] = spec.split("/");
+ try {
+ await this.fetchPackage(this.packagePath + spec + "/", name, version);
+ } catch (error) {
+ if (error == 2) {
+ throw e;
+ }
+ throw error;
+ }
+ const packages = await this.getPackageList();
+ this.compilerWorker.postMessage({ type: "packages", data: packages });
+ this.compilerWorker.postMessage(message);
+ continue;
+ }
+ throw e;
+ }
+ if (result instanceof ImageData || typeof result == "string") {
+ return result;
+ }
+ await this.handleWorkerRequest(result);
+ }
+ });
+ }
+ async handleWorkerRequest({ buffer: wbuffer, path }) {
+ try {
+ const text = await (path.startsWith("@") ? this.preparePackage(path.slice(1)) : this.getFileString(path));
+ if (text) {
+ let buffer = Int32Array.from(this.textEncoder.encode(
+ text
+ ));
+ if (wbuffer.byteLength < buffer.byteLength + 4) {
+ wbuffer.buffer.grow(buffer.byteLength + 4);
+ }
+ wbuffer.set(buffer, 1);
+ wbuffer[0] = 0;
+ }
+ } catch (error) {
+ if (typeof error === "number") {
+ wbuffer[0] = error;
+ } else {
+ wbuffer[0] = 1;
+ console.error(error);
+ }
+ } finally {
+ Atomics.notify(wbuffer, 0);
+ }
+ }
+ async getFileString(path) {
+ try {
+ if (require("path").isAbsolute(path)) {
+ return await this.fs.promises.readFile(path, { encoding: "utf8" });
+ } else {
+ return await this.app.vault.adapter.read((0, import_obsidian.normalizePath)(path));
+ }
+ } catch (e) {
+ console.error(e);
+ if (e.code == "ENOENT") {
+ throw 2;
+ }
+ if (e.code == "EACCES") {
+ throw 3;
+ }
+ if (e.code == "EISDIR") {
+ throw 4;
+ }
+ throw 5;
+ }
+ }
+ async preparePackage(spec) {
+ if (import_obsidian.Platform.isDesktopApp) {
+ let subdir = "/typst/packages/" + spec;
+ let dir = require("path").normalize(this.getDataDir() + subdir);
+ if (this.fs.existsSync(dir)) {
+ return dir;
+ }
+ dir = require("path").normalize(this.getCacheDir() + subdir);
+ if (this.fs.existsSync(dir)) {
+ return dir;
+ }
+ }
+ const folder = this.packagePath + spec + "/";
+ if (await this.app.vault.adapter.exists(folder)) {
+ return folder;
+ }
+ if (spec.startsWith("preview") && this.settings.autoDownloadPackages) {
+ const [namespace, name, version] = spec.split("/");
+ try {
+ await this.fetchPackage(folder, name, version);
+ return folder;
+ } catch (e) {
+ if (e == 2) {
+ throw e;
+ }
+ console.error(e);
+ throw 3;
+ }
+ }
+ throw 2;
+ }
+ getDataDir() {
+ if (import_obsidian.Platform.isLinux) {
+ if ("XDG_DATA_HOME" in process.env) {
+ return process.env["XDG_DATA_HOME"];
+ } else {
+ return process.env["HOME"] + "/.local/share";
+ }
+ } else if (import_obsidian.Platform.isWin) {
+ return process.env["APPDATA"];
+ } else if (import_obsidian.Platform.isMacOS) {
+ return process.env["HOME"] + "/Library/Application Support";
+ }
+ throw "Cannot find data directory on an unknown platform";
+ }
+ getCacheDir() {
+ if (import_obsidian.Platform.isLinux) {
+ if ("XDG_CACHE_HOME" in process.env) {
+ return process.env["XDG_DATA_HOME"];
+ } else {
+ return process.env["HOME"] + "/.cache";
+ }
+ } else if (import_obsidian.Platform.isWin) {
+ return process.env["LOCALAPPDATA"];
+ } else if (import_obsidian.Platform.isMacOS) {
+ return process.env["HOME"] + "/Library/Caches";
+ }
+ throw "Cannot find cache directory on an unknown platform";
+ }
+ async fetchPackage(folder, name, version) {
+ const url = `https://packages.typst.org/preview/${name}-${version}.tar.gz`;
+ const response = await fetch(url);
+ if (response.status == 404) {
+ throw 2;
+ }
+ await this.app.vault.adapter.mkdir(folder);
+ await (0, import_js_untar.default)(decompressSync(new Uint8Array(await response.arrayBuffer())).buffer).progress(async (file) => {
+ if (file.type == "5" && file.name != ".") {
+ await this.app.vault.adapter.mkdir(folder + file.name);
+ }
+ if (file.type === "0") {
+ await this.app.vault.adapter.writeBinary(folder + file.name, file.buffer);
+ }
+ });
+ }
+ async processThenCompileTypst(path, source, size, display, fontSize) {
+ const dpr = window.devicePixelRatio;
+ const pxToPt = (px) => px.toString() + "pt";
+ const sizing = `#let (WIDTH, HEIGHT, SIZE, THEME) = (${display ? pxToPt(size) : "auto"}, ${!display ? pxToPt(size) : "auto"}, ${pxToPt(fontSize)}, "${document.body.getCssPropertyValue("color-scheme")}")`;
+ return this.compileToTypst(
+ path,
+ `${sizing}
+${this.settings.preamable.shared}
+${source}`,
+ size,
+ display
+ );
+ }
+ createTypstRenderElement(path, source, display, math) {
+ let renderer = new TypstRenderElement();
+ renderer.format = this.settings.format;
+ renderer.source = source;
+ renderer.path = path;
+ renderer.display = display;
+ renderer.math = math;
+ return renderer;
+ }
+ createTypstMath(source, r) {
+ const display = r.display;
+ source = `${this.settings.preamable.math}
+${display ? `$ ${source} $` : `$${source}$`}`;
+ return this.createTypstRenderElement("/586f8912-f3a8-4455-8a4a-3729469c2cc1.typ", source, display, true);
+ }
+ onunload() {
+ MathJax.tex2chtml = this.tex2chtml;
+ this.compilerWorker.terminate();
+ }
+ async overrideMathJax(value) {
+ this.settings.override_math = value;
+ await this.saveSettings();
+ if (this.settings.override_math) {
+ MathJax.tex2chtml = (e, r) => this.createTypstMath(e, r);
+ } else {
+ MathJax.tex2chtml = this.tex2chtml;
+ }
+ }
+ async loadSettings() {
+ this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
+ }
+ async saveSettings() {
+ await this.saveData(this.settings);
+ }
+};
+var TypstSettingTab = class extends import_obsidian.PluginSettingTab {
+ constructor(app, plugin) {
+ super(app, plugin);
+ this.plugin = plugin;
+ }
+ async display() {
+ const { containerEl } = this;
+ containerEl.empty();
+ new import_obsidian.Setting(containerEl).setName("Render Format").addDropdown((dropdown) => {
+ dropdown.addOptions({
+ svg: "SVG",
+ image: "Image"
+ }).setValue(this.plugin.settings.format).onChange(async (value) => {
+ this.plugin.settings.format = value;
+ await this.plugin.saveSettings();
+ if (value == "svg") {
+ no_fill.setDisabled(true);
+ fill_color.setDisabled(true);
+ pixel_per_pt.setDisabled(true);
+ } else {
+ no_fill.setDisabled(false);
+ fill_color.setDisabled(this.plugin.settings.noFill);
+ pixel_per_pt.setDisabled(false);
+ }
+ });
+ });
+ let no_fill = new import_obsidian.Setting(containerEl).setName("No Fill (Transparent)").setDisabled(this.plugin.settings.format == "svg").addToggle((toggle) => {
+ toggle.setValue(this.plugin.settings.noFill).onChange(
+ async (value) => {
+ this.plugin.settings.noFill = value;
+ await this.plugin.saveSettings();
+ fill_color.setDisabled(value);
+ }
+ );
+ });
+ let fill_color = new import_obsidian.Setting(containerEl).setName("Fill Color").setDisabled(this.plugin.settings.noFill || this.plugin.settings.format == "svg").addColorPicker((picker) => {
+ picker.setValue(this.plugin.settings.fill).onChange(
+ async (value) => {
+ this.plugin.settings.fill = value;
+ await this.plugin.saveSettings();
+ }
+ );
+ });
+ let pixel_per_pt = new import_obsidian.Setting(containerEl).setName("Pixel Per Point").setDisabled(this.plugin.settings.format == "svg").addSlider(
+ (slider) => slider.setValue(this.plugin.settings.pixel_per_pt).setLimits(1, 5, 1).onChange(
+ async (value) => {
+ this.plugin.settings.pixel_per_pt = value;
+ await this.plugin.saveSettings();
+ }
+ ).setDynamicTooltip()
+ );
+ new import_obsidian.Setting(containerEl).setName("Override Math Blocks").addToggle((toggle) => {
+ toggle.setValue(this.plugin.settings.override_math).onChange((value) => this.plugin.overrideMathJax(value));
+ });
+ new import_obsidian.Setting(containerEl).setName("Shared Preamble").addTextArea((c) => c.setValue(this.plugin.settings.preamable.shared).onChange(async (value) => {
+ this.plugin.settings.preamable.shared = value;
+ await this.plugin.saveSettings();
+ }));
+ new import_obsidian.Setting(containerEl).setName("Code Block Preamble").addTextArea((c) => c.setValue(this.plugin.settings.preamable.code).onChange(async (value) => {
+ this.plugin.settings.preamable.code = value;
+ await this.plugin.saveSettings();
+ }));
+ new import_obsidian.Setting(containerEl).setName("Math Block Preamble").addTextArea((c) => c.setValue(this.plugin.settings.preamable.math).onChange(async (value) => {
+ this.plugin.settings.preamable.math = value;
+ await this.plugin.saveSettings();
+ }));
+ if (!import_obsidian.Platform.isMobileApp) {
+ const fontSettings = containerEl.createDiv({ cls: "setting-item font-settings" });
+ fontSettings.createDiv({ text: "Fonts", cls: "setting-item-name" });
+ fontSettings.createDiv({ text: "Font family names that should be loaded for Typst from your system. Requires a reload on change.", cls: "setting-item-description" });
+ const addFontsDiv = fontSettings.createDiv({ cls: "add-fonts-div" });
+ const fontsInput = addFontsDiv.createEl("input", { type: "text", placeholder: "Enter a font family", cls: "font-input" });
+ const addFontBtn = addFontsDiv.createEl("button", { text: "Add" });
+ const fontTagsDiv = fontSettings.createDiv({ cls: "font-tags-div" });
+ const addFontTag = async () => {
+ if (!this.plugin.settings.font_families.contains(fontsInput.value)) {
+ this.plugin.settings.font_families.push(fontsInput.value.toLowerCase());
+ await this.plugin.saveSettings();
+ }
+ fontsInput.value = "";
+ this.renderFontTags(fontTagsDiv);
+ };
+ fontsInput.addEventListener("keydown", async (ev) => {
+ if (ev.key == "Enter") {
+ addFontTag();
+ }
+ });
+ addFontBtn.addEventListener("click", async () => addFontTag());
+ this.renderFontTags(fontTagsDiv);
+ new import_obsidian.Setting(containerEl).setName("Download Missing Packages").setDesc("When on, if the compiler cannot find a package in the system it will attempt to download it. Packages downloaded this way will be stored within the vault in the plugin's folder. Always on for mobile.").addToggle((toggle) => toggle.setValue(this.plugin.settings.autoDownloadPackages).onChange(async (value) => {
+ this.plugin.settings.autoDownloadPackages = value;
+ await this.plugin.saveSettings();
+ }));
+ }
+ const packageSettingsDiv = containerEl.createDiv({ cls: "setting-item package-settings" });
+ packageSettingsDiv.createDiv({ text: "Downloaded Packages", cls: "setting-item-name" });
+ packageSettingsDiv.createDiv({ text: "These are the currently downloaded packages. Select the packages you want to delete.", cls: "setting-item-description" });
+ (await this.plugin.getPackageList()).forEach((pkg) => {
+ const [namespace, name, version] = pkg.split("/");
+ const packageItem = packageSettingsDiv.createDiv({ cls: "package-item" });
+ packageItem.createEl("input", { type: "checkbox", cls: "package-checkbox", value: pkg, attr: { name: "package-checkbox" } });
+ packageItem.createEl("p", { text: name });
+ packageItem.createEl("p", { text: version, cls: "package-version" });
+ });
+ const deletePackagesBtn = packageSettingsDiv.createEl("button", { text: "Delete Selected Packages", cls: "delete-pkg-btn" });
+ deletePackagesBtn.addEventListener("click", () => {
+ const selectedPackageElements = packageSettingsDiv.querySelectorAll('input[name="package-checkbox"]:checked');
+ let packagesToDelete = [];
+ selectedPackageElements.forEach((pkgEl) => {
+ packagesToDelete.push(pkgEl.getAttribute("value"));
+ packageSettingsDiv.removeChild(pkgEl.parentNode);
+ });
+ this.plugin.deletePackages(packagesToDelete);
+ });
+ }
+ renderFontTags(fontTagsDiv) {
+ fontTagsDiv.innerHTML = "";
+ this.plugin.settings.font_families.forEach((fontFamily) => {
+ const fontTag = fontTagsDiv.createEl("span", { cls: "font-tag" });
+ fontTag.createEl("span", { text: fontFamily, cls: "font-tag-text", attr: { style: `font-family: ${fontFamily};` } });
+ const removeBtn = fontTag.createEl("span", { text: "x", cls: "tag-btn" });
+ removeBtn.addEventListener("click", async () => {
+ this.plugin.settings.font_families.remove(fontFamily);
+ await this.plugin.saveSettings();
+ this.renderFontTags(fontTagsDiv);
+ });
+ });
+ }
+};
+
+/* nosourcemap */
\ No newline at end of file
diff --git a/.obsidian/plugins/typst/manifest.json b/.obsidian/plugins/typst/manifest.json
new file mode 100644
index 0000000..ff397ed
--- /dev/null
+++ b/.obsidian/plugins/typst/manifest.json
@@ -0,0 +1,13 @@
+{
+ "id": "typst",
+ "name": "Typst Renderer",
+ "version": "0.10.0",
+ "minAppVersion": "1.0.0",
+ "description": "Renders `typst` code blocks and math blocks with Typst.",
+ "author": "fenjalien",
+ "authorUrl": "https://github.com/fenjalien",
+ "fundingUrl": {
+ "GitHub Sponsor": "https://github.com/sponsors/fenjalien",
+ "ko-fi": "https://ko-fi.com/fenjalien"
+ }
+}
\ No newline at end of file
diff --git a/.obsidian/plugins/typst/obsidian_typst_bg.wasm b/.obsidian/plugins/typst/obsidian_typst_bg.wasm
new file mode 100644
index 0000000000000000000000000000000000000000..87362db28935150857e2c1f16e8d73ab0e0bd501
GIT binary patch
literal 26995481
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