From e4746b6d0f0ef8b75415ef4742b471ba4bab336d Mon Sep 17 00:00:00 2001 From: Joachim Happel Date: Thu, 8 Aug 2024 12:11:42 +0200 Subject: [PATCH] chore: vault backup from Joachims-PC at 2024-08-08T12:11 --- .obsidian/app.json | 1 + .obsidian/appearance.json | 1 + .obsidian/community-plugins.json | 3 + .obsidian/core-plugins-migration.json | 30 + .obsidian/core-plugins.json | 20 + .obsidian/plugins/cicada-sync/data.json | 17 + .obsidian/plugins/cicada-sync/main.js | 5764 +++++++++++++++++++ .obsidian/plugins/cicada-sync/manifest.json | 10 + .obsidian/plugins/cicada-sync/styles.css | 15 + .obsidian/workspace.json | 154 + Readme.md | 9 + 11 files changed, 6024 insertions(+) create mode 100644 .obsidian/app.json create mode 100644 .obsidian/appearance.json create mode 100644 .obsidian/community-plugins.json create mode 100644 .obsidian/core-plugins-migration.json create mode 100644 .obsidian/core-plugins.json create mode 100644 .obsidian/plugins/cicada-sync/data.json create mode 100644 .obsidian/plugins/cicada-sync/main.js create mode 100644 .obsidian/plugins/cicada-sync/manifest.json create mode 100644 .obsidian/plugins/cicada-sync/styles.css create mode 100644 .obsidian/workspace.json create mode 100644 Readme.md diff --git a/.obsidian/app.json b/.obsidian/app.json new file mode 100644 index 0000000..9e26dfe --- /dev/null +++ b/.obsidian/app.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/.obsidian/appearance.json b/.obsidian/appearance.json new file mode 100644 index 0000000..9e26dfe --- /dev/null +++ b/.obsidian/appearance.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/.obsidian/community-plugins.json b/.obsidian/community-plugins.json new file mode 100644 index 0000000..da92f4f --- /dev/null +++ b/.obsidian/community-plugins.json @@ -0,0 +1,3 @@ +[ + "cicada-sync" +] \ No newline at end of file diff --git a/.obsidian/core-plugins-migration.json b/.obsidian/core-plugins-migration.json new file mode 100644 index 0000000..436f43c --- /dev/null +++ b/.obsidian/core-plugins-migration.json @@ -0,0 +1,30 @@ +{ + "file-explorer": true, + "global-search": true, + "switcher": true, + "graph": true, + "backlink": true, + "canvas": true, + "outgoing-link": true, + "tag-pane": true, + "properties": false, + "page-preview": true, + "daily-notes": true, + "templates": true, + "note-composer": true, + "command-palette": true, + "slash-command": false, + "editor-status": true, + "bookmarks": true, + "markdown-importer": false, + "zk-prefixer": false, + "random-note": false, + "outline": true, + "word-count": true, + "slides": false, + "audio-recorder": false, + "workspaces": false, + "file-recovery": true, + "publish": false, + "sync": false +} \ No newline at end of file diff --git a/.obsidian/core-plugins.json b/.obsidian/core-plugins.json new file mode 100644 index 0000000..9405bfd --- /dev/null +++ b/.obsidian/core-plugins.json @@ -0,0 +1,20 @@ +[ + "file-explorer", + "global-search", + "switcher", + "graph", + "backlink", + "canvas", + "outgoing-link", + "tag-pane", + "page-preview", + "daily-notes", + "templates", + "note-composer", + "command-palette", + "editor-status", + "bookmarks", + "outline", + "word-count", + "file-recovery" +] \ No newline at end of file diff --git a/.obsidian/plugins/cicada-sync/data.json b/.obsidian/plugins/cicada-sync/data.json new file mode 100644 index 0000000..c771514 --- /dev/null +++ b/.obsidian/plugins/cicada-sync/data.json @@ -0,0 +1,17 @@ +{ + "deviceName": "Joachims-PC", + "remoteRepo": "git@github.com:adapole/obsidian-yaos.git", + "basePath": "C:\\Users\\Joachim\\AppData\\Local\\Obsidian\\resources\\electron.asar\\renderer", + "branchName": "main", + "syncImages": false, + "syncAudio": false, + "syncVideos": false, + "syncPdfs": false, + "syncOtherFiles": false, + "syncMainSettings": false, + "syncAppearanceSettings": false, + "syncThemesAndSnippets": false, + "syncHotkeys": false, + "syncCorePluginSettings": false, + "syncCommunityPluginSettings": false +} \ No newline at end of file diff --git a/.obsidian/plugins/cicada-sync/main.js b/.obsidian/plugins/cicada-sync/main.js new file mode 100644 index 0000000..232de5b --- /dev/null +++ b/.obsidian/plugins/cicada-sync/main.js @@ -0,0 +1,5764 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ + +"use strict"; +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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +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); +var __publicField = (obj, key, value) => { + __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + return value; +}; + +// node_modules/dayjs/dayjs.min.js +var require_dayjs_min = __commonJS({ + "node_modules/dayjs/dayjs.min.js"(exports, module2) { + !function(t, e) { + "object" == typeof exports && "undefined" != typeof module2 ? module2.exports = e() : "function" == typeof define && define.amd ? define(e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs = e(); + }(exports, function() { + "use strict"; + var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", c = "month", f = "quarter", h = "year", d = "date", l = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = { name: "en", weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), ordinal: function(t2) { + var e2 = ["th", "st", "nd", "rd"], n2 = t2 % 100; + return "[" + t2 + (e2[(n2 - 20) % 10] || e2[n2] || e2[0]) + "]"; + } }, m = function(t2, e2, n2) { + var r2 = String(t2); + return !r2 || r2.length >= e2 ? t2 : "" + Array(e2 + 1 - r2.length).join(n2) + t2; + }, v = { s: m, z: function(t2) { + var e2 = -t2.utcOffset(), n2 = Math.abs(e2), r2 = Math.floor(n2 / 60), i2 = n2 % 60; + return (e2 <= 0 ? "+" : "-") + m(r2, 2, "0") + ":" + m(i2, 2, "0"); + }, m: function t2(e2, n2) { + if (e2.date() < n2.date()) + return -t2(n2, e2); + var r2 = 12 * (n2.year() - e2.year()) + (n2.month() - e2.month()), i2 = e2.clone().add(r2, c), s2 = n2 - i2 < 0, u2 = e2.clone().add(r2 + (s2 ? -1 : 1), c); + return +(-(r2 + (n2 - i2) / (s2 ? i2 - u2 : u2 - i2)) || 0); + }, a: function(t2) { + return t2 < 0 ? Math.ceil(t2) || 0 : Math.floor(t2); + }, p: function(t2) { + return { M: c, y: h, w: o, d: a, D: d, h: u, m: s, s: i, ms: r, Q: f }[t2] || String(t2 || "").toLowerCase().replace(/s$/, ""); + }, u: function(t2) { + return void 0 === t2; + } }, g = "en", D = {}; + D[g] = M; + var p = "$isDayjsObject", S = function(t2) { + return t2 instanceof _ || !(!t2 || !t2[p]); + }, w = function t2(e2, n2, r2) { + var i2; + if (!e2) + return g; + if ("string" == typeof e2) { + var s2 = e2.toLowerCase(); + D[s2] && (i2 = s2), n2 && (D[s2] = n2, i2 = s2); + var u2 = e2.split("-"); + if (!i2 && u2.length > 1) + return t2(u2[0]); + } else { + var a2 = e2.name; + D[a2] = e2, i2 = a2; + } + return !r2 && i2 && (g = i2), i2 || !r2 && g; + }, O = function(t2, e2) { + if (S(t2)) + return t2.clone(); + var n2 = "object" == typeof e2 ? e2 : {}; + return n2.date = t2, n2.args = arguments, new _(n2); + }, b = v; + b.l = w, b.i = S, b.w = function(t2, e2) { + return O(t2, { locale: e2.$L, utc: e2.$u, x: e2.$x, $offset: e2.$offset }); + }; + var _ = function() { + function M2(t2) { + this.$L = w(t2.locale, null, true), this.parse(t2), this.$x = this.$x || t2.x || {}, this[p] = true; + } + var m2 = M2.prototype; + return m2.parse = function(t2) { + this.$d = function(t3) { + var e2 = t3.date, n2 = t3.utc; + if (null === e2) + return new Date(NaN); + if (b.u(e2)) + return new Date(); + if (e2 instanceof Date) + return new Date(e2); + if ("string" == typeof e2 && !/Z$/i.test(e2)) { + var r2 = e2.match($); + if (r2) { + var i2 = r2[2] - 1 || 0, s2 = (r2[7] || "0").substring(0, 3); + return n2 ? new Date(Date.UTC(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2)) : new Date(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2); + } + } + return new Date(e2); + }(t2), this.init(); + }, m2.init = function() { + var t2 = this.$d; + this.$y = t2.getFullYear(), this.$M = t2.getMonth(), this.$D = t2.getDate(), this.$W = t2.getDay(), this.$H = t2.getHours(), this.$m = t2.getMinutes(), this.$s = t2.getSeconds(), this.$ms = t2.getMilliseconds(); + }, m2.$utils = function() { + return b; + }, m2.isValid = function() { + return !(this.$d.toString() === l); + }, m2.isSame = function(t2, e2) { + var n2 = O(t2); + return this.startOf(e2) <= n2 && n2 <= this.endOf(e2); + }, m2.isAfter = function(t2, e2) { + return O(t2) < this.startOf(e2); + }, m2.isBefore = function(t2, e2) { + return this.endOf(e2) < O(t2); + }, m2.$g = function(t2, e2, n2) { + return b.u(t2) ? this[e2] : this.set(n2, t2); + }, m2.unix = function() { + return Math.floor(this.valueOf() / 1e3); + }, m2.valueOf = function() { + return this.$d.getTime(); + }, m2.startOf = function(t2, e2) { + var n2 = this, r2 = !!b.u(e2) || e2, f2 = b.p(t2), l2 = function(t3, e3) { + var i2 = b.w(n2.$u ? Date.UTC(n2.$y, e3, t3) : new Date(n2.$y, e3, t3), n2); + return r2 ? i2 : i2.endOf(a); + }, $2 = function(t3, e3) { + return b.w(n2.toDate()[t3].apply(n2.toDate("s"), (r2 ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e3)), n2); + }, y2 = this.$W, M3 = this.$M, m3 = this.$D, v2 = "set" + (this.$u ? "UTC" : ""); + switch (f2) { + case h: + return r2 ? l2(1, 0) : l2(31, 11); + case c: + return r2 ? l2(1, M3) : l2(0, M3 + 1); + case o: + var g2 = this.$locale().weekStart || 0, D2 = (y2 < g2 ? y2 + 7 : y2) - g2; + return l2(r2 ? m3 - D2 : m3 + (6 - D2), M3); + case a: + case d: + return $2(v2 + "Hours", 0); + case u: + return $2(v2 + "Minutes", 1); + case s: + return $2(v2 + "Seconds", 2); + case i: + return $2(v2 + "Milliseconds", 3); + default: + return this.clone(); + } + }, m2.endOf = function(t2) { + return this.startOf(t2, false); + }, m2.$set = function(t2, e2) { + var n2, o2 = b.p(t2), f2 = "set" + (this.$u ? "UTC" : ""), l2 = (n2 = {}, n2[a] = f2 + "Date", n2[d] = f2 + "Date", n2[c] = f2 + "Month", n2[h] = f2 + "FullYear", n2[u] = f2 + "Hours", n2[s] = f2 + "Minutes", n2[i] = f2 + "Seconds", n2[r] = f2 + "Milliseconds", n2)[o2], $2 = o2 === a ? this.$D + (e2 - this.$W) : e2; + if (o2 === c || o2 === h) { + var y2 = this.clone().set(d, 1); + y2.$d[l2]($2), y2.init(), this.$d = y2.set(d, Math.min(this.$D, y2.daysInMonth())).$d; + } else + l2 && this.$d[l2]($2); + return this.init(), this; + }, m2.set = function(t2, e2) { + return this.clone().$set(t2, e2); + }, m2.get = function(t2) { + return this[b.p(t2)](); + }, m2.add = function(r2, f2) { + var d2, l2 = this; + r2 = Number(r2); + var $2 = b.p(f2), y2 = function(t2) { + var e2 = O(l2); + return b.w(e2.date(e2.date() + Math.round(t2 * r2)), l2); + }; + if ($2 === c) + return this.set(c, this.$M + r2); + if ($2 === h) + return this.set(h, this.$y + r2); + if ($2 === a) + return y2(1); + if ($2 === o) + return y2(7); + var M3 = (d2 = {}, d2[s] = e, d2[u] = n, d2[i] = t, d2)[$2] || 1, m3 = this.$d.getTime() + r2 * M3; + return b.w(m3, this); + }, m2.subtract = function(t2, e2) { + return this.add(-1 * t2, e2); + }, m2.format = function(t2) { + var e2 = this, n2 = this.$locale(); + if (!this.isValid()) + return n2.invalidDate || l; + var r2 = t2 || "YYYY-MM-DDTHH:mm:ssZ", i2 = b.z(this), s2 = this.$H, u2 = this.$m, a2 = this.$M, o2 = n2.weekdays, c2 = n2.months, f2 = n2.meridiem, h2 = function(t3, n3, i3, s3) { + return t3 && (t3[n3] || t3(e2, r2)) || i3[n3].slice(0, s3); + }, d2 = function(t3) { + return b.s(s2 % 12 || 12, t3, "0"); + }, $2 = f2 || function(t3, e3, n3) { + var r3 = t3 < 12 ? "AM" : "PM"; + return n3 ? r3.toLowerCase() : r3; + }; + return r2.replace(y, function(t3, r3) { + return r3 || function(t4) { + switch (t4) { + case "YY": + return String(e2.$y).slice(-2); + case "YYYY": + return b.s(e2.$y, 4, "0"); + case "M": + return a2 + 1; + case "MM": + return b.s(a2 + 1, 2, "0"); + case "MMM": + return h2(n2.monthsShort, a2, c2, 3); + case "MMMM": + return h2(c2, a2); + case "D": + return e2.$D; + case "DD": + return b.s(e2.$D, 2, "0"); + case "d": + return String(e2.$W); + case "dd": + return h2(n2.weekdaysMin, e2.$W, o2, 2); + case "ddd": + return h2(n2.weekdaysShort, e2.$W, o2, 3); + case "dddd": + return o2[e2.$W]; + case "H": + return String(s2); + case "HH": + return b.s(s2, 2, "0"); + case "h": + return d2(1); + case "hh": + return d2(2); + case "a": + return $2(s2, u2, true); + case "A": + return $2(s2, u2, false); + case "m": + return String(u2); + case "mm": + return b.s(u2, 2, "0"); + case "s": + return String(e2.$s); + case "ss": + return b.s(e2.$s, 2, "0"); + case "SSS": + return b.s(e2.$ms, 3, "0"); + case "Z": + return i2; + } + return null; + }(t3) || i2.replace(":", ""); + }); + }, m2.utcOffset = function() { + return 15 * -Math.round(this.$d.getTimezoneOffset() / 15); + }, m2.diff = function(r2, d2, l2) { + var $2, y2 = this, M3 = b.p(d2), m3 = O(r2), v2 = (m3.utcOffset() - this.utcOffset()) * e, g2 = this - m3, D2 = function() { + return b.m(y2, m3); + }; + switch (M3) { + case h: + $2 = D2() / 12; + break; + case c: + $2 = D2(); + break; + case f: + $2 = D2() / 3; + break; + case o: + $2 = (g2 - v2) / 6048e5; + break; + case a: + $2 = (g2 - v2) / 864e5; + break; + case u: + $2 = g2 / n; + break; + case s: + $2 = g2 / e; + break; + case i: + $2 = g2 / t; + break; + default: + $2 = g2; + } + return l2 ? $2 : b.a($2); + }, m2.daysInMonth = function() { + return this.endOf(c).$D; + }, m2.$locale = function() { + return D[this.$L]; + }, m2.locale = function(t2, e2) { + if (!t2) + return this.$L; + var n2 = this.clone(), r2 = w(t2, e2, true); + return r2 && (n2.$L = r2), n2; + }, m2.clone = function() { + return b.w(this.$d, this); + }, m2.toDate = function() { + return new Date(this.valueOf()); + }, m2.toJSON = function() { + return this.isValid() ? this.toISOString() : null; + }, m2.toISOString = function() { + return this.$d.toISOString(); + }, m2.toString = function() { + return this.$d.toUTCString(); + }, M2; + }(), k = _.prototype; + return O.prototype = k, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", c], ["$y", h], ["$D", d]].forEach(function(t2) { + k[t2[1]] = function(e2) { + return this.$g(e2, t2[0], t2[1]); + }; + }), O.extend = function(t2, e2) { + return t2.$i || (t2(e2, _, O), t2.$i = true), O; + }, O.locale = w, O.isDayjs = S, O.unix = function(t2) { + return O(1e3 * t2); + }, O.en = D[g], O.Ls = D, O.p = {}, O; + }); + } +}); + +// node_modules/ms/index.js +var require_ms = __commonJS({ + "node_modules/ms/index.js"(exports, module2) { + var s = 1e3; + var m = s * 60; + var h = m * 60; + var d = h * 24; + var w = d * 7; + var y = d * 365.25; + module2.exports = function(val, options) { + options = options || {}; + var type = typeof val; + if (type === "string" && val.length > 0) { + return parse(val); + } else if (type === "number" && isFinite(val)) { + return options.long ? fmtLong(val) : fmtShort(val); + } + throw new Error( + "val is not a non-empty string or a valid number. val=" + JSON.stringify(val) + ); + }; + function parse(str) { + str = String(str); + if (str.length > 100) { + return; + } + var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec( + str + ); + if (!match) { + return; + } + var n = parseFloat(match[1]); + var type = (match[2] || "ms").toLowerCase(); + switch (type) { + case "years": + case "year": + case "yrs": + case "yr": + case "y": + return n * y; + case "weeks": + case "week": + case "w": + return n * w; + case "days": + case "day": + case "d": + return n * d; + case "hours": + case "hour": + case "hrs": + case "hr": + case "h": + return n * h; + case "minutes": + case "minute": + case "mins": + case "min": + case "m": + return n * m; + case "seconds": + case "second": + case "secs": + case "sec": + case "s": + return n * s; + case "milliseconds": + case "millisecond": + case "msecs": + case "msec": + case "ms": + return n; + default: + return void 0; + } + } + function fmtShort(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return Math.round(ms / d) + "d"; + } + if (msAbs >= h) { + return Math.round(ms / h) + "h"; + } + if (msAbs >= m) { + return Math.round(ms / m) + "m"; + } + if (msAbs >= s) { + return Math.round(ms / s) + "s"; + } + return ms + "ms"; + } + function fmtLong(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return plural(ms, msAbs, d, "day"); + } + if (msAbs >= h) { + return plural(ms, msAbs, h, "hour"); + } + if (msAbs >= m) { + return plural(ms, msAbs, m, "minute"); + } + if (msAbs >= s) { + return plural(ms, msAbs, s, "second"); + } + return ms + " ms"; + } + function plural(ms, msAbs, n, name) { + var isPlural = msAbs >= n * 1.5; + return Math.round(ms / n) + " " + name + (isPlural ? "s" : ""); + } + } +}); + +// node_modules/debug/src/common.js +var require_common = __commonJS({ + "node_modules/debug/src/common.js"(exports, module2) { + function setup(env) { + createDebug.debug = createDebug; + createDebug.default = createDebug; + createDebug.coerce = coerce; + createDebug.disable = disable; + createDebug.enable = enable; + createDebug.enabled = enabled; + createDebug.humanize = require_ms(); + createDebug.destroy = destroy; + Object.keys(env).forEach((key) => { + createDebug[key] = env[key]; + }); + createDebug.names = []; + createDebug.skips = []; + createDebug.formatters = {}; + function selectColor(namespace) { + let hash = 0; + for (let i = 0; i < namespace.length; i++) { + hash = (hash << 5) - hash + namespace.charCodeAt(i); + hash |= 0; + } + return createDebug.colors[Math.abs(hash) % createDebug.colors.length]; + } + createDebug.selectColor = selectColor; + function createDebug(namespace) { + let prevTime; + let enableOverride = null; + let namespacesCache; + let enabledCache; + function debug2(...args) { + if (!debug2.enabled) { + return; + } + const self2 = debug2; + const curr = Number(new Date()); + const ms = curr - (prevTime || curr); + self2.diff = ms; + self2.prev = prevTime; + self2.curr = curr; + prevTime = curr; + args[0] = createDebug.coerce(args[0]); + if (typeof args[0] !== "string") { + args.unshift("%O"); + } + let index = 0; + args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => { + if (match === "%%") { + return "%"; + } + index++; + const formatter = createDebug.formatters[format]; + if (typeof formatter === "function") { + const val = args[index]; + match = formatter.call(self2, val); + args.splice(index, 1); + index--; + } + return match; + }); + createDebug.formatArgs.call(self2, args); + const logFn = self2.log || createDebug.log; + logFn.apply(self2, args); + } + debug2.namespace = namespace; + debug2.useColors = createDebug.useColors(); + debug2.color = createDebug.selectColor(namespace); + debug2.extend = extend; + debug2.destroy = createDebug.destroy; + Object.defineProperty(debug2, "enabled", { + enumerable: true, + configurable: false, + get: () => { + if (enableOverride !== null) { + return enableOverride; + } + if (namespacesCache !== createDebug.namespaces) { + namespacesCache = createDebug.namespaces; + enabledCache = createDebug.enabled(namespace); + } + return enabledCache; + }, + set: (v) => { + enableOverride = v; + } + }); + if (typeof createDebug.init === "function") { + createDebug.init(debug2); + } + return debug2; + } + function extend(namespace, delimiter) { + const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace); + newDebug.log = this.log; + return newDebug; + } + function enable(namespaces) { + createDebug.save(namespaces); + createDebug.namespaces = namespaces; + createDebug.names = []; + createDebug.skips = []; + let i; + const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/); + const len = split.length; + for (i = 0; i < len; i++) { + if (!split[i]) { + continue; + } + namespaces = split[i].replace(/\*/g, ".*?"); + if (namespaces[0] === "-") { + createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$")); + } else { + createDebug.names.push(new RegExp("^" + namespaces + "$")); + } + } + } + function disable() { + const namespaces = [ + ...createDebug.names.map(toNamespace), + ...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace) + ].join(","); + createDebug.enable(""); + return namespaces; + } + function enabled(name) { + if (name[name.length - 1] === "*") { + return true; + } + let i; + let len; + for (i = 0, len = createDebug.skips.length; i < len; i++) { + if (createDebug.skips[i].test(name)) { + return false; + } + } + for (i = 0, len = createDebug.names.length; i < len; i++) { + if (createDebug.names[i].test(name)) { + return true; + } + } + return false; + } + function toNamespace(regexp) { + return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*"); + } + function coerce(val) { + if (val instanceof Error) { + return val.stack || val.message; + } + return val; + } + function destroy() { + console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."); + } + createDebug.enable(createDebug.load()); + return createDebug; + } + module2.exports = setup; + } +}); + +// node_modules/debug/src/browser.js +var require_browser = __commonJS({ + "node_modules/debug/src/browser.js"(exports, module2) { + exports.formatArgs = formatArgs; + exports.save = save; + exports.load = load; + exports.useColors = useColors; + exports.storage = localstorage(); + exports.destroy = (() => { + let warned = false; + return () => { + if (!warned) { + warned = true; + console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."); + } + }; + })(); + exports.colors = [ + "#0000CC", + "#0000FF", + "#0033CC", + "#0033FF", + "#0066CC", + "#0066FF", + "#0099CC", + "#0099FF", + "#00CC00", + "#00CC33", + "#00CC66", + "#00CC99", + "#00CCCC", + "#00CCFF", + "#3300CC", + "#3300FF", + "#3333CC", + "#3333FF", + "#3366CC", + "#3366FF", + "#3399CC", + "#3399FF", + "#33CC00", + "#33CC33", + "#33CC66", + "#33CC99", + "#33CCCC", + "#33CCFF", + "#6600CC", + "#6600FF", + "#6633CC", + "#6633FF", + "#66CC00", + "#66CC33", + "#9900CC", + "#9900FF", + "#9933CC", + "#9933FF", + "#99CC00", + "#99CC33", + "#CC0000", + "#CC0033", + "#CC0066", + "#CC0099", + "#CC00CC", + "#CC00FF", + "#CC3300", + "#CC3333", + "#CC3366", + "#CC3399", + "#CC33CC", + "#CC33FF", + "#CC6600", + "#CC6633", + "#CC9900", + "#CC9933", + "#CCCC00", + "#CCCC33", + "#FF0000", + "#FF0033", + "#FF0066", + "#FF0099", + "#FF00CC", + "#FF00FF", + "#FF3300", + "#FF3333", + "#FF3366", + "#FF3399", + "#FF33CC", + "#FF33FF", + "#FF6600", + "#FF6633", + "#FF9900", + "#FF9933", + "#FFCC00", + "#FFCC33" + ]; + function useColors() { + if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) { + return true; + } + if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) { + return false; + } + return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773 + typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31? + // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages + typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker + typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/); + } + function formatArgs(args) { + args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff); + if (!this.useColors) { + return; + } + const c = "color: " + this.color; + args.splice(1, 0, c, "color: inherit"); + let index = 0; + let lastC = 0; + args[0].replace(/%[a-zA-Z%]/g, (match) => { + if (match === "%%") { + return; + } + index++; + if (match === "%c") { + lastC = index; + } + }); + args.splice(lastC, 0, c); + } + exports.log = console.debug || console.log || (() => { + }); + function save(namespaces) { + try { + if (namespaces) { + exports.storage.setItem("debug", namespaces); + } else { + exports.storage.removeItem("debug"); + } + } catch (error) { + } + } + function load() { + let r; + try { + r = exports.storage.getItem("debug"); + } catch (error) { + } + if (!r && typeof process !== "undefined" && "env" in process) { + r = process.env.DEBUG; + } + return r; + } + function localstorage() { + try { + return localStorage; + } catch (error) { + } + } + module2.exports = require_common()(exports); + var { formatters } = module2.exports; + formatters.j = function(v) { + try { + return JSON.stringify(v); + } catch (error) { + return "[UnexpectedJSONParseError]: " + error.message; + } + }; + } +}); + +// node_modules/@kwsites/file-exists/dist/src/index.js +var require_src = __commonJS({ + "node_modules/@kwsites/file-exists/dist/src/index.js"(exports) { + "use strict"; + var __importDefault = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + var fs_1 = require("fs"); + var debug_1 = __importDefault(require_browser()); + var log = debug_1.default("@kwsites/file-exists"); + function check(path, isFile, isDirectory) { + log(`checking %s`, path); + try { + const stat = fs_1.statSync(path); + if (stat.isFile() && isFile) { + log(`[OK] path represents a file`); + return true; + } + if (stat.isDirectory() && isDirectory) { + log(`[OK] path represents a directory`); + return true; + } + log(`[FAIL] path represents something other than a file or directory`); + return false; + } catch (e) { + if (e.code === "ENOENT") { + log(`[FAIL] path is not accessible: %o`, e); + return false; + } + log(`[FATAL] %o`, e); + throw e; + } + } + function exists2(path, type = exports.READABLE) { + return check(path, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0); + } + exports.exists = exists2; + exports.FILE = 1; + exports.FOLDER = 2; + exports.READABLE = exports.FILE + exports.FOLDER; + } +}); + +// node_modules/@kwsites/file-exists/dist/index.js +var require_dist = __commonJS({ + "node_modules/@kwsites/file-exists/dist/index.js"(exports) { + "use strict"; + function __export3(m) { + for (var p in m) + if (!exports.hasOwnProperty(p)) + exports[p] = m[p]; + } + Object.defineProperty(exports, "__esModule", { value: true }); + __export3(require_src()); + } +}); + +// node_modules/@kwsites/promise-deferred/dist/index.js +var require_dist2 = __commonJS({ + "node_modules/@kwsites/promise-deferred/dist/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.createDeferred = exports.deferred = void 0; + function deferred2() { + let done; + let fail; + let status = "pending"; + const promise = new Promise((_done, _fail) => { + done = _done; + fail = _fail; + }); + return { + promise, + done(result) { + if (status === "pending") { + status = "resolved"; + done(result); + } + }, + fail(error) { + if (status === "pending") { + status = "rejected"; + fail(error); + } + }, + get fulfilled() { + return status !== "pending"; + }, + get status() { + return status; + } + }; + } + exports.deferred = deferred2; + exports.createDeferred = deferred2; + exports.default = deferred2; + } +}); + +// src/main.ts +var main_exports = {}; +__export(main_exports, { + default: () => CicadaPlugin +}); +module.exports = __toCommonJS(main_exports); + +// src/utils/constants.ts +var PLUGIN_NAME = "CI-SYNC"; + +// node_modules/consola/dist/core.mjs +var LogLevels = { + silent: Number.NEGATIVE_INFINITY, + fatal: 0, + error: 0, + warn: 1, + log: 2, + info: 3, + success: 3, + fail: 3, + ready: 3, + start: 3, + box: 3, + debug: 4, + trace: 5, + verbose: Number.POSITIVE_INFINITY +}; +var LogTypes = { + // Silent + silent: { + level: -1 + }, + // Level 0 + fatal: { + level: LogLevels.fatal + }, + error: { + level: LogLevels.error + }, + // Level 1 + warn: { + level: LogLevels.warn + }, + // Level 2 + log: { + level: LogLevels.log + }, + // Level 3 + info: { + level: LogLevels.info + }, + success: { + level: LogLevels.success + }, + fail: { + level: LogLevels.fail + }, + ready: { + level: LogLevels.info + }, + start: { + level: LogLevels.info + }, + box: { + level: LogLevels.info + }, + // Level 4 + debug: { + level: LogLevels.debug + }, + // Level 5 + trace: { + level: LogLevels.trace + }, + // Verbose + verbose: { + level: LogLevels.verbose + } +}; +function isObject(value) { + return value !== null && typeof value === "object"; +} +function _defu(baseObject, defaults, namespace = ".", merger) { + if (!isObject(defaults)) { + return _defu(baseObject, {}, namespace, merger); + } + const object = Object.assign({}, defaults); + for (const key in baseObject) { + if (key === "__proto__" || key === "constructor") { + continue; + } + const value = baseObject[key]; + if (value === null || value === void 0) { + continue; + } + if (merger && merger(object, key, value, namespace)) { + continue; + } + if (Array.isArray(value) && Array.isArray(object[key])) { + object[key] = [...value, ...object[key]]; + } else if (isObject(value) && isObject(object[key])) { + object[key] = _defu( + value, + object[key], + (namespace ? `${namespace}.` : "") + key.toString(), + merger + ); + } else { + object[key] = value; + } + } + return object; +} +function createDefu(merger) { + return (...arguments_) => ( + // eslint-disable-next-line unicorn/no-array-reduce + arguments_.reduce((p, c) => _defu(p, c, "", merger), {}) + ); +} +var defu = createDefu(); +function isPlainObject(obj) { + return Object.prototype.toString.call(obj) === "[object Object]"; +} +function isLogObj(arg) { + if (!isPlainObject(arg)) { + return false; + } + if (!arg.message && !arg.args) { + return false; + } + if (arg.stack) { + return false; + } + return true; +} +var paused = false; +var queue = []; +var Consola = class { + constructor(options = {}) { + const types = options.types || LogTypes; + this.options = defu( + { + ...options, + defaults: { ...options.defaults }, + level: _normalizeLogLevel(options.level, types), + reporters: [...options.reporters || []] + }, + { + types: LogTypes, + throttle: 1e3, + throttleMin: 5, + formatOptions: { + date: true, + colors: false, + compact: true + } + } + ); + for (const type in types) { + const defaults = { + type, + ...this.options.defaults, + ...types[type] + }; + this[type] = this._wrapLogFn(defaults); + this[type].raw = this._wrapLogFn( + defaults, + true + ); + } + if (this.options.mockFn) { + this.mockTypes(); + } + this._lastLog = {}; + } + get level() { + return this.options.level; + } + set level(level) { + this.options.level = _normalizeLogLevel( + level, + this.options.types, + this.options.level + ); + } + prompt(message, opts) { + if (!this.options.prompt) { + throw new Error("prompt is not supported!"); + } + return this.options.prompt(message, opts); + } + create(options) { + const instance = new Consola({ + ...this.options, + ...options + }); + if (this._mockFn) { + instance.mockTypes(this._mockFn); + } + return instance; + } + withDefaults(defaults) { + return this.create({ + ...this.options, + defaults: { + ...this.options.defaults, + ...defaults + } + }); + } + withTag(tag) { + return this.withDefaults({ + tag: this.options.defaults.tag ? this.options.defaults.tag + ":" + tag : tag + }); + } + addReporter(reporter) { + this.options.reporters.push(reporter); + return this; + } + removeReporter(reporter) { + if (reporter) { + const i = this.options.reporters.indexOf(reporter); + if (i >= 0) { + return this.options.reporters.splice(i, 1); + } + } else { + this.options.reporters.splice(0); + } + return this; + } + setReporters(reporters) { + this.options.reporters = Array.isArray(reporters) ? reporters : [reporters]; + return this; + } + wrapAll() { + this.wrapConsole(); + this.wrapStd(); + } + restoreAll() { + this.restoreConsole(); + this.restoreStd(); + } + wrapConsole() { + for (const type in this.options.types) { + if (!console["__" + type]) { + console["__" + type] = console[type]; + } + console[type] = this[type].raw; + } + } + restoreConsole() { + for (const type in this.options.types) { + if (console["__" + type]) { + console[type] = console["__" + type]; + delete console["__" + type]; + } + } + } + wrapStd() { + this._wrapStream(this.options.stdout, "log"); + this._wrapStream(this.options.stderr, "log"); + } + _wrapStream(stream, type) { + if (!stream) { + return; + } + if (!stream.__write) { + stream.__write = stream.write; + } + stream.write = (data) => { + this[type].raw(String(data).trim()); + }; + } + restoreStd() { + this._restoreStream(this.options.stdout); + this._restoreStream(this.options.stderr); + } + _restoreStream(stream) { + if (!stream) { + return; + } + if (stream.__write) { + stream.write = stream.__write; + delete stream.__write; + } + } + pauseLogs() { + paused = true; + } + resumeLogs() { + paused = false; + const _queue = queue.splice(0); + for (const item of _queue) { + item[0]._logFn(item[1], item[2]); + } + } + mockTypes(mockFn) { + const _mockFn = mockFn || this.options.mockFn; + this._mockFn = _mockFn; + if (typeof _mockFn !== "function") { + return; + } + for (const type in this.options.types) { + this[type] = _mockFn(type, this.options.types[type]) || this[type]; + this[type].raw = this[type]; + } + } + _wrapLogFn(defaults, isRaw) { + return (...args) => { + if (paused) { + queue.push([this, defaults, args, isRaw]); + return; + } + return this._logFn(defaults, args, isRaw); + }; + } + _logFn(defaults, args, isRaw) { + if ((defaults.level || 0) > this.level) { + return false; + } + const logObj = { + date: /* @__PURE__ */ new Date(), + args: [], + ...defaults, + level: _normalizeLogLevel(defaults.level, this.options.types) + }; + if (!isRaw && args.length === 1 && isLogObj(args[0])) { + Object.assign(logObj, args[0]); + } else { + logObj.args = [...args]; + } + if (logObj.message) { + logObj.args.unshift(logObj.message); + delete logObj.message; + } + if (logObj.additional) { + if (!Array.isArray(logObj.additional)) { + logObj.additional = logObj.additional.split("\n"); + } + logObj.args.push("\n" + logObj.additional.join("\n")); + delete logObj.additional; + } + logObj.type = typeof logObj.type === "string" ? logObj.type.toLowerCase() : "log"; + logObj.tag = typeof logObj.tag === "string" ? logObj.tag : ""; + const resolveLog = (newLog = false) => { + const repeated = (this._lastLog.count || 0) - this.options.throttleMin; + if (this._lastLog.object && repeated > 0) { + const args2 = [...this._lastLog.object.args]; + if (repeated > 1) { + args2.push(`(repeated ${repeated} times)`); + } + this._log({ ...this._lastLog.object, args: args2 }); + this._lastLog.count = 1; + } + if (newLog) { + this._lastLog.object = logObj; + this._log(logObj); + } + }; + clearTimeout(this._lastLog.timeout); + const diffTime = this._lastLog.time && logObj.date ? logObj.date.getTime() - this._lastLog.time.getTime() : 0; + this._lastLog.time = logObj.date; + if (diffTime < this.options.throttle) { + try { + const serializedLog = JSON.stringify([ + logObj.type, + logObj.tag, + logObj.args + ]); + const isSameLog = this._lastLog.serialized === serializedLog; + this._lastLog.serialized = serializedLog; + if (isSameLog) { + this._lastLog.count = (this._lastLog.count || 0) + 1; + if (this._lastLog.count > this.options.throttleMin) { + this._lastLog.timeout = setTimeout( + resolveLog, + this.options.throttle + ); + return; + } + } + } catch (e) { + } + } + resolveLog(true); + } + _log(logObj) { + for (const reporter of this.options.reporters) { + reporter.log(logObj, { + options: this.options + }); + } + } +}; +function _normalizeLogLevel(input, types = {}, defaultLevel = 3) { + if (input === void 0) { + return defaultLevel; + } + if (typeof input === "number") { + return input; + } + if (types[input] && types[input].level !== void 0) { + return types[input].level; + } + return defaultLevel; +} +Consola.prototype.add = Consola.prototype.addReporter; +Consola.prototype.remove = Consola.prototype.removeReporter; +Consola.prototype.clear = Consola.prototype.removeReporter; +Consola.prototype.withScope = Consola.prototype.withTag; +Consola.prototype.mock = Consola.prototype.mockTypes; +Consola.prototype.pause = Consola.prototype.pauseLogs; +Consola.prototype.resume = Consola.prototype.resumeLogs; +function createConsola(options = {}) { + return new Consola(options); +} + +// node_modules/consola/dist/browser.mjs +var BrowserReporter = class { + constructor(options) { + this.options = { ...options }; + this.defaultColor = "#7f8c8d"; + this.levelColorMap = { + 0: "#c0392b", + // Red + 1: "#f39c12", + // Yellow + 3: "#00BCD4" + // Cyan + }; + this.typeColorMap = { + success: "#2ecc71" + // Green + }; + } + _getLogFn(level) { + if (level < 1) { + return console.__error || console.error; + } + if (level === 1) { + return console.__warn || console.warn; + } + return console.__log || console.log; + } + log(logObj) { + const consoleLogFn = this._getLogFn(logObj.level); + const type = logObj.type === "log" ? "" : logObj.type; + const tag = logObj.tag || ""; + const color = this.typeColorMap[logObj.type] || this.levelColorMap[logObj.level] || this.defaultColor; + const style = ` + background: ${color}; + border-radius: 0.5em; + color: white; + font-weight: bold; + padding: 2px 0.5em; + `; + const badge = `%c${[tag, type].filter(Boolean).join(":")}`; + if (typeof logObj.args[0] === "string") { + consoleLogFn( + `${badge}%c ${logObj.args[0]}`, + style, + // Empty string as style resets to default console style + "", + ...logObj.args.slice(1) + ); + } else { + consoleLogFn(badge, style, ...logObj.args); + } + } +}; +function createConsola2(options = {}) { + const consola2 = createConsola({ + reporters: options.reporters || [new BrowserReporter({})], + prompt(message, options2 = {}) { + if (options2.type === "confirm") { + return Promise.resolve(confirm(message)); + } + return Promise.resolve(prompt(message)); + }, + ...options + }); + return consola2; +} +var consola = createConsola2(); + +// src/utils/logger.ts +var logger = consola.create({ level: LogLevels.debug }).withTag(PLUGIN_NAME); +var logger_default = logger; + +// src/utils/notifier.ts +var import_obsidian = require("obsidian"); +var notifyUserAboutFailure = (message) => new import_obsidian.Notice(`FATAL: ${message}`); + +// src/controllers/syncController.ts +var import_obsidian2 = require("obsidian"); +var SyncController = class { + constructor(gitService, gitignoreService) { + this.gitService = gitService; + this.gitignoreService = gitignoreService; + logger_default.debug("Initialized sync controller."); + } + async createVaultBackup() { + if (await this.gitService.unstagedChangesExist()) { + await this.handleUnstagedChanges(); + } else { + logger_default.info("No changes in vault detected for backup/sync."); + try { + await this.gitService.gitPushUpstream(); + try { + await this.gitService.gitPull(); + } catch (e) { + logger_default.error("Pull failed."); + } + } catch (error) { + logger_default.warn("Failed to push branch upstream"); + try { + await this.gitService.gitPull(); + await this.gitService.gitPushUpstream(); + logger_default.success("Synced local and remote."); + } catch (e) { + notifyUserAboutFailure("Failed to sync with remote"); + logger_default.error("Pull and upstream failed."); + } + } + } + if (await this.gitService.isLocalAhead()) { + await this.handleLocalAhead(); + } + } + async handleLocalAhead() { + try { + await this.gitService.gitPush(); + this.notifyUserAboutBackup(); + } catch (e) { + logger_default.warn("Remote and local have conflicting changes!"); + logger_default.info("Starting rebase process..."); + try { + await this.gitService.gitPullWithRebase(); + await this.gitService.gitPush(); + this.notifyUserAboutBackup(); + logger_default.success("Created vault sync."); + } catch (e2) { + this.notifyUserAboutConflicts(); + logger_default.error("Automatic rebasing failed."); + } + } + } + async handleUnstagedChanges() { + logger_default.info("Unstaged changes detected. Syncronizing..."); + await this.gitService.gitStageAll(); + await this.gitService.gitCommit(); + } + notifyUserAboutBackup() { + new import_obsidian2.Notice("Successfully synced up vault!"); + } + notifyUserAboutConflicts() { + new import_obsidian2.Notice( + "Your local and remote repositories had conflicting changes." + ); + new import_obsidian2.Notice( + "Please fix the changes and then click the sync button again." + ); + } + async sync() { + if (await this.gitService.isRepo()) { + logger_default.debug("Vault is initialized as a Git repository."); + } else { + logger_default.fatal("Vault is not initialized as a Git repository."); + notifyUserAboutFailure("Vault is not a Git repository."); + return; + } + if (await this.gitService.isRemoteConfigured()) { + logger_default.debug("Remote repository is configured."); + } else { + logger_default.fatal("Remote repository is not configured."); + notifyUserAboutFailure("Remote repository is not configured."); + return; + } + if (await this.gitService.isRebasing()) { + logger_default.debug("Stopping in progress rebase."); + await this.gitService.stopRebasing(); + } + await this.createVaultBackup(); + } +}; + +// src/services/gitService.ts +var import_dayjs = __toESM(require_dayjs_min()); + +// node_modules/simple-git/dist/esm/index.js +var import_file_exists = __toESM(require_dist(), 1); +var import_debug = __toESM(require_browser(), 1); +var import_child_process = require("child_process"); +var import_promise_deferred = __toESM(require_dist2(), 1); +var import_promise_deferred2 = __toESM(require_dist2(), 1); +var __defProp2 = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropNames2 = Object.getOwnPropertyNames; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp2 = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp2.call(b, prop)) + __defNormalProp2(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp2(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); +var __markAsModule = (target) => __defProp2(target, "__esModule", { value: true }); +var __esm = (fn, res) => function __init() { + return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res; +}; +var __commonJS2 = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export2 = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); +}; +var __reExport = (target, module2, copyDefault, desc) => { + if (module2 && typeof module2 === "object" || typeof module2 === "function") { + for (let key of __getOwnPropNames2(module2)) + if (!__hasOwnProp2.call(target, key) && (copyDefault || key !== "default")) + __defProp2(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc2(module2, key)) || desc.enumerable }); + } + return target; +}; +var __toCommonJS2 = /* @__PURE__ */ ((cache2) => { + return (module2, temp) => { + return cache2 && cache2.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache2 && cache2.set(module2, temp), temp); + }; +})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0); +var __async = (__this, __arguments, generator) => { + return new Promise((resolve2, 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 ? resolve2(x.value) : Promise.resolve(x.value).then(fulfilled, rejected); + step((generator = generator.apply(__this, __arguments)).next()); + }); +}; +function pathspec(...paths) { + const key = new String(paths); + cache.set(key, paths); + return key; +} +function isPathSpec(path) { + return path instanceof String && cache.has(path); +} +function toPaths(pathSpec) { + return cache.get(pathSpec) || []; +} +var cache; +var init_pathspec = __esm({ + "src/lib/args/pathspec.ts"() { + cache = /* @__PURE__ */ new WeakMap(); + } +}); +var GitError; +var init_git_error = __esm({ + "src/lib/errors/git-error.ts"() { + GitError = class extends Error { + constructor(task, message) { + super(message); + this.task = task; + Object.setPrototypeOf(this, new.target.prototype); + } + }; + } +}); +var GitResponseError; +var init_git_response_error = __esm({ + "src/lib/errors/git-response-error.ts"() { + init_git_error(); + GitResponseError = class extends GitError { + constructor(git, message) { + super(void 0, message || String(git)); + this.git = git; + } + }; + } +}); +var TaskConfigurationError; +var init_task_configuration_error = __esm({ + "src/lib/errors/task-configuration-error.ts"() { + init_git_error(); + TaskConfigurationError = class extends GitError { + constructor(message) { + super(void 0, message); + } + }; + } +}); +function asFunction(source) { + return typeof source === "function" ? source : NOOP; +} +function isUserFunction(source) { + return typeof source === "function" && source !== NOOP; +} +function splitOn(input, char) { + const index = input.indexOf(char); + if (index <= 0) { + return [input, ""]; + } + return [input.substr(0, index), input.substr(index + 1)]; +} +function first(input, offset = 0) { + return isArrayLike(input) && input.length > offset ? input[offset] : void 0; +} +function last(input, offset = 0) { + if (isArrayLike(input) && input.length > offset) { + return input[input.length - 1 - offset]; + } +} +function isArrayLike(input) { + return !!(input && typeof input.length === "number"); +} +function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") { + return input.split(separator).reduce((output, line) => { + const lineContent = trimmed2 ? line.trim() : line; + if (lineContent) { + output.push(lineContent); + } + return output; + }, []); +} +function forEachLineWithContent(input, callback) { + return toLinesWithContent(input, true).map((line) => callback(line)); +} +function folderExists(path) { + return (0, import_file_exists.exists)(path, import_file_exists.FOLDER); +} +function append(target, item) { + if (Array.isArray(target)) { + if (!target.includes(item)) { + target.push(item); + } + } else { + target.add(item); + } + return item; +} +function including(target, item) { + if (Array.isArray(target) && !target.includes(item)) { + target.push(item); + } + return target; +} +function remove(target, item) { + if (Array.isArray(target)) { + const index = target.indexOf(item); + if (index >= 0) { + target.splice(index, 1); + } + } else { + target.delete(item); + } + return item; +} +function asArray(source) { + return Array.isArray(source) ? source : [source]; +} +function asStringArray(source) { + return asArray(source).map(String); +} +function asNumber(source, onNaN = 0) { + if (source == null) { + return onNaN; + } + const num = parseInt(source, 10); + return isNaN(num) ? onNaN : num; +} +function prefixedArray(input, prefix) { + const output = []; + for (let i = 0, max = input.length; i < max; i++) { + output.push(prefix, input[i]); + } + return output; +} +function bufferToString(input) { + return (Array.isArray(input) ? Buffer.concat(input) : input).toString("utf-8"); +} +function pick(source, properties) { + return Object.assign({}, ...properties.map((property) => property in source ? { [property]: source[property] } : {})); +} +function delay(duration = 0) { + return new Promise((done) => setTimeout(done, duration)); +} +function orVoid(input) { + if (input === false) { + return void 0; + } + return input; +} +var NULL; +var NOOP; +var objectToString; +var init_util = __esm({ + "src/lib/utils/util.ts"() { + NULL = "\0"; + NOOP = () => { + }; + objectToString = Object.prototype.toString.call.bind(Object.prototype.toString); + } +}); +function filterType(input, filter, def) { + if (filter(input)) { + return input; + } + return arguments.length > 2 ? def : void 0; +} +function filterPrimitives(input, omit) { + const type = isPathSpec(input) ? "string" : typeof input; + return /number|string|boolean/.test(type) && (!omit || !omit.includes(type)); +} +function filterPlainObject(input) { + return !!input && objectToString(input) === "[object Object]"; +} +function filterFunction(input) { + return typeof input === "function"; +} +var filterArray; +var filterString; +var filterStringArray; +var filterStringOrStringArray; +var filterHasLength; +var init_argument_filters = __esm({ + "src/lib/utils/argument-filters.ts"() { + init_util(); + init_pathspec(); + filterArray = (input) => { + return Array.isArray(input); + }; + filterString = (input) => { + return typeof input === "string"; + }; + filterStringArray = (input) => { + return Array.isArray(input) && input.every(filterString); + }; + filterStringOrStringArray = (input) => { + return filterString(input) || Array.isArray(input) && input.every(filterString); + }; + filterHasLength = (input) => { + if (input == null || "number|boolean|function".includes(typeof input)) { + return false; + } + return Array.isArray(input) || typeof input === "string" || typeof input.length === "number"; + }; + } +}); +var ExitCodes; +var init_exit_codes = __esm({ + "src/lib/utils/exit-codes.ts"() { + ExitCodes = /* @__PURE__ */ ((ExitCodes2) => { + ExitCodes2[ExitCodes2["SUCCESS"] = 0] = "SUCCESS"; + ExitCodes2[ExitCodes2["ERROR"] = 1] = "ERROR"; + ExitCodes2[ExitCodes2["NOT_FOUND"] = -2] = "NOT_FOUND"; + ExitCodes2[ExitCodes2["UNCLEAN"] = 128] = "UNCLEAN"; + return ExitCodes2; + })(ExitCodes || {}); + } +}); +var GitOutputStreams; +var init_git_output_streams = __esm({ + "src/lib/utils/git-output-streams.ts"() { + GitOutputStreams = class { + constructor(stdOut, stdErr) { + this.stdOut = stdOut; + this.stdErr = stdErr; + } + asStrings() { + return new GitOutputStreams(this.stdOut.toString("utf8"), this.stdErr.toString("utf8")); + } + }; + } +}); +var LineParser; +var RemoteLineParser; +var init_line_parser = __esm({ + "src/lib/utils/line-parser.ts"() { + LineParser = class { + constructor(regExp, useMatches) { + this.matches = []; + this.parse = (line, target) => { + this.resetMatches(); + if (!this._regExp.every((reg, index) => this.addMatch(reg, index, line(index)))) { + return false; + } + return this.useMatches(target, this.prepareMatches()) !== false; + }; + this._regExp = Array.isArray(regExp) ? regExp : [regExp]; + if (useMatches) { + this.useMatches = useMatches; + } + } + useMatches(target, match) { + throw new Error(`LineParser:useMatches not implemented`); + } + resetMatches() { + this.matches.length = 0; + } + prepareMatches() { + return this.matches; + } + addMatch(reg, index, line) { + const matched = line && reg.exec(line); + if (matched) { + this.pushMatch(index, matched); + } + return !!matched; + } + pushMatch(_index, matched) { + this.matches.push(...matched.slice(1)); + } + }; + RemoteLineParser = class extends LineParser { + addMatch(reg, index, line) { + return /^remote:\s/.test(String(line)) && super.addMatch(reg, index, line); + } + pushMatch(index, matched) { + if (index > 0 || matched.length > 1) { + super.pushMatch(index, matched); + } + } + }; + } +}); +function createInstanceConfig(...options) { + const baseDir = process.cwd(); + const config = Object.assign(__spreadValues({ baseDir }, defaultOptions), ...options.filter((o) => typeof o === "object" && o)); + config.baseDir = config.baseDir || baseDir; + config.trimmed = config.trimmed === true; + return config; +} +var defaultOptions; +var init_simple_git_options = __esm({ + "src/lib/utils/simple-git-options.ts"() { + defaultOptions = { + binary: "git", + maxConcurrentProcesses: 5, + config: [], + trimmed: false + }; + } +}); +function appendTaskOptions(options, commands = []) { + if (!filterPlainObject(options)) { + return commands; + } + return Object.keys(options).reduce((commands2, key) => { + const value = options[key]; + if (isPathSpec(value)) { + commands2.push(value); + } else if (filterPrimitives(value, ["boolean"])) { + commands2.push(key + "=" + value); + } else { + commands2.push(key); + } + return commands2; + }, commands); +} +function getTrailingOptions(args, initialPrimitive = 0, objectOnly = false) { + const command = []; + for (let i = 0, max = initialPrimitive < 0 ? args.length : initialPrimitive; i < max; i++) { + if ("string|number".includes(typeof args[i])) { + command.push(String(args[i])); + } + } + appendTaskOptions(trailingOptionsArgument(args), command); + if (!objectOnly) { + command.push(...trailingArrayArgument(args)); + } + return command; +} +function trailingArrayArgument(args) { + const hasTrailingCallback = typeof last(args) === "function"; + return filterType(last(args, hasTrailingCallback ? 1 : 0), filterArray, []); +} +function trailingOptionsArgument(args) { + const hasTrailingCallback = filterFunction(last(args)); + return filterType(last(args, hasTrailingCallback ? 1 : 0), filterPlainObject); +} +function trailingFunctionArgument(args, includeNoop = true) { + const callback = asFunction(last(args)); + return includeNoop || isUserFunction(callback) ? callback : void 0; +} +var init_task_options = __esm({ + "src/lib/utils/task-options.ts"() { + init_argument_filters(); + init_util(); + init_pathspec(); + } +}); +function callTaskParser(parser3, streams) { + return parser3(streams.stdOut, streams.stdErr); +} +function parseStringResponse(result, parsers12, texts, trim = true) { + asArray(texts).forEach((text) => { + for (let lines = toLinesWithContent(text, trim), i = 0, max = lines.length; i < max; i++) { + const line = (offset = 0) => { + if (i + offset >= max) { + return; + } + return lines[i + offset]; + }; + parsers12.some(({ parse }) => parse(line, result)); + } + }); + return result; +} +var init_task_parser = __esm({ + "src/lib/utils/task-parser.ts"() { + init_util(); + } +}); +var utils_exports = {}; +__export2(utils_exports, { + ExitCodes: () => ExitCodes, + GitOutputStreams: () => GitOutputStreams, + LineParser: () => LineParser, + NOOP: () => NOOP, + NULL: () => NULL, + RemoteLineParser: () => RemoteLineParser, + append: () => append, + appendTaskOptions: () => appendTaskOptions, + asArray: () => asArray, + asFunction: () => asFunction, + asNumber: () => asNumber, + asStringArray: () => asStringArray, + bufferToString: () => bufferToString, + callTaskParser: () => callTaskParser, + createInstanceConfig: () => createInstanceConfig, + delay: () => delay, + filterArray: () => filterArray, + filterFunction: () => filterFunction, + filterHasLength: () => filterHasLength, + filterPlainObject: () => filterPlainObject, + filterPrimitives: () => filterPrimitives, + filterString: () => filterString, + filterStringArray: () => filterStringArray, + filterStringOrStringArray: () => filterStringOrStringArray, + filterType: () => filterType, + first: () => first, + folderExists: () => folderExists, + forEachLineWithContent: () => forEachLineWithContent, + getTrailingOptions: () => getTrailingOptions, + including: () => including, + isUserFunction: () => isUserFunction, + last: () => last, + objectToString: () => objectToString, + orVoid: () => orVoid, + parseStringResponse: () => parseStringResponse, + pick: () => pick, + prefixedArray: () => prefixedArray, + remove: () => remove, + splitOn: () => splitOn, + toLinesWithContent: () => toLinesWithContent, + trailingFunctionArgument: () => trailingFunctionArgument, + trailingOptionsArgument: () => trailingOptionsArgument +}); +var init_utils = __esm({ + "src/lib/utils/index.ts"() { + init_argument_filters(); + init_exit_codes(); + init_git_output_streams(); + init_line_parser(); + init_simple_git_options(); + init_task_options(); + init_task_parser(); + init_util(); + } +}); +var check_is_repo_exports = {}; +__export2(check_is_repo_exports, { + CheckRepoActions: () => CheckRepoActions, + checkIsBareRepoTask: () => checkIsBareRepoTask, + checkIsRepoRootTask: () => checkIsRepoRootTask, + checkIsRepoTask: () => checkIsRepoTask +}); +function checkIsRepoTask(action) { + switch (action) { + case "bare": + return checkIsBareRepoTask(); + case "root": + return checkIsRepoRootTask(); + } + const commands = ["rev-parse", "--is-inside-work-tree"]; + return { + commands, + format: "utf-8", + onError, + parser + }; +} +function checkIsRepoRootTask() { + const commands = ["rev-parse", "--git-dir"]; + return { + commands, + format: "utf-8", + onError, + parser(path) { + return /^\.(git)?$/.test(path.trim()); + } + }; +} +function checkIsBareRepoTask() { + const commands = ["rev-parse", "--is-bare-repository"]; + return { + commands, + format: "utf-8", + onError, + parser + }; +} +function isNotRepoMessage(error) { + return /(Not a git repository|Kein Git-Repository)/i.test(String(error)); +} +var CheckRepoActions; +var onError; +var parser; +var init_check_is_repo = __esm({ + "src/lib/tasks/check-is-repo.ts"() { + init_utils(); + CheckRepoActions = /* @__PURE__ */ ((CheckRepoActions2) => { + CheckRepoActions2["BARE"] = "bare"; + CheckRepoActions2["IN_TREE"] = "tree"; + CheckRepoActions2["IS_REPO_ROOT"] = "root"; + return CheckRepoActions2; + })(CheckRepoActions || {}); + onError = ({ exitCode }, error, done, fail) => { + if (exitCode === 128 && isNotRepoMessage(error)) { + return done(Buffer.from("false")); + } + fail(error); + }; + parser = (text) => { + return text.trim() === "true"; + }; + } +}); +function cleanSummaryParser(dryRun, text) { + const summary = new CleanResponse(dryRun); + const regexp = dryRun ? dryRunRemovalRegexp : removalRegexp; + toLinesWithContent(text).forEach((line) => { + const removed = line.replace(regexp, ""); + summary.paths.push(removed); + (isFolderRegexp.test(removed) ? summary.folders : summary.files).push(removed); + }); + return summary; +} +var CleanResponse; +var removalRegexp; +var dryRunRemovalRegexp; +var isFolderRegexp; +var init_CleanSummary = __esm({ + "src/lib/responses/CleanSummary.ts"() { + init_utils(); + CleanResponse = class { + constructor(dryRun) { + this.dryRun = dryRun; + this.paths = []; + this.files = []; + this.folders = []; + } + }; + removalRegexp = /^[a-z]+\s*/i; + dryRunRemovalRegexp = /^[a-z]+\s+[a-z]+\s*/i; + isFolderRegexp = /\/$/; + } +}); +var task_exports = {}; +__export2(task_exports, { + EMPTY_COMMANDS: () => EMPTY_COMMANDS, + adhocExecTask: () => adhocExecTask, + configurationErrorTask: () => configurationErrorTask, + isBufferTask: () => isBufferTask, + isEmptyTask: () => isEmptyTask, + straightThroughBufferTask: () => straightThroughBufferTask, + straightThroughStringTask: () => straightThroughStringTask +}); +function adhocExecTask(parser3) { + return { + commands: EMPTY_COMMANDS, + format: "empty", + parser: parser3 + }; +} +function configurationErrorTask(error) { + return { + commands: EMPTY_COMMANDS, + format: "empty", + parser() { + throw typeof error === "string" ? new TaskConfigurationError(error) : error; + } + }; +} +function straightThroughStringTask(commands, trimmed2 = false) { + return { + commands, + format: "utf-8", + parser(text) { + return trimmed2 ? String(text).trim() : text; + } + }; +} +function straightThroughBufferTask(commands) { + return { + commands, + format: "buffer", + parser(buffer) { + return buffer; + } + }; +} +function isBufferTask(task) { + return task.format === "buffer"; +} +function isEmptyTask(task) { + return task.format === "empty" || !task.commands.length; +} +var EMPTY_COMMANDS; +var init_task = __esm({ + "src/lib/tasks/task.ts"() { + init_task_configuration_error(); + EMPTY_COMMANDS = []; + } +}); +var clean_exports = {}; +__export2(clean_exports, { + CONFIG_ERROR_INTERACTIVE_MODE: () => CONFIG_ERROR_INTERACTIVE_MODE, + CONFIG_ERROR_MODE_REQUIRED: () => CONFIG_ERROR_MODE_REQUIRED, + CONFIG_ERROR_UNKNOWN_OPTION: () => CONFIG_ERROR_UNKNOWN_OPTION, + CleanOptions: () => CleanOptions, + cleanTask: () => cleanTask, + cleanWithOptionsTask: () => cleanWithOptionsTask, + isCleanOptionsArray: () => isCleanOptionsArray +}); +function cleanWithOptionsTask(mode, customArgs) { + const { cleanMode, options, valid } = getCleanOptions(mode); + if (!cleanMode) { + return configurationErrorTask(CONFIG_ERROR_MODE_REQUIRED); + } + if (!valid.options) { + return configurationErrorTask(CONFIG_ERROR_UNKNOWN_OPTION + JSON.stringify(mode)); + } + options.push(...customArgs); + if (options.some(isInteractiveMode)) { + return configurationErrorTask(CONFIG_ERROR_INTERACTIVE_MODE); + } + return cleanTask(cleanMode, options); +} +function cleanTask(mode, customArgs) { + const commands = ["clean", `-${mode}`, ...customArgs]; + return { + commands, + format: "utf-8", + parser(text) { + return cleanSummaryParser(mode === "n", text); + } + }; +} +function isCleanOptionsArray(input) { + return Array.isArray(input) && input.every((test) => CleanOptionValues.has(test)); +} +function getCleanOptions(input) { + let cleanMode; + let options = []; + let valid = { cleanMode: false, options: true }; + input.replace(/[^a-z]i/g, "").split("").forEach((char) => { + if (isCleanMode(char)) { + cleanMode = char; + valid.cleanMode = true; + } else { + valid.options = valid.options && isKnownOption(options[options.length] = `-${char}`); + } + }); + return { + cleanMode, + options, + valid + }; +} +function isCleanMode(cleanMode) { + return cleanMode === "f" || cleanMode === "n"; +} +function isKnownOption(option) { + return /^-[a-z]$/i.test(option) && CleanOptionValues.has(option.charAt(1)); +} +function isInteractiveMode(option) { + if (/^-[^\-]/.test(option)) { + return option.indexOf("i") > 0; + } + return option === "--interactive"; +} +var CONFIG_ERROR_INTERACTIVE_MODE; +var CONFIG_ERROR_MODE_REQUIRED; +var CONFIG_ERROR_UNKNOWN_OPTION; +var CleanOptions; +var CleanOptionValues; +var init_clean = __esm({ + "src/lib/tasks/clean.ts"() { + init_CleanSummary(); + init_utils(); + init_task(); + CONFIG_ERROR_INTERACTIVE_MODE = "Git clean interactive mode is not supported"; + CONFIG_ERROR_MODE_REQUIRED = 'Git clean mode parameter ("n" or "f") is required'; + CONFIG_ERROR_UNKNOWN_OPTION = "Git clean unknown option found in: "; + CleanOptions = /* @__PURE__ */ ((CleanOptions2) => { + CleanOptions2["DRY_RUN"] = "n"; + CleanOptions2["FORCE"] = "f"; + CleanOptions2["IGNORED_INCLUDED"] = "x"; + CleanOptions2["IGNORED_ONLY"] = "X"; + CleanOptions2["EXCLUDING"] = "e"; + CleanOptions2["QUIET"] = "q"; + CleanOptions2["RECURSIVE"] = "d"; + return CleanOptions2; + })(CleanOptions || {}); + CleanOptionValues = /* @__PURE__ */ new Set([ + "i", + ...asStringArray(Object.values(CleanOptions)) + ]); + } +}); +function configListParser(text) { + const config = new ConfigList(); + for (const item of configParser(text)) { + config.addValue(item.file, String(item.key), item.value); + } + return config; +} +function configGetParser(text, key) { + let value = null; + const values = []; + const scopes = /* @__PURE__ */ new Map(); + for (const item of configParser(text, key)) { + if (item.key !== key) { + continue; + } + values.push(value = item.value); + if (!scopes.has(item.file)) { + scopes.set(item.file, []); + } + scopes.get(item.file).push(value); + } + return { + key, + paths: Array.from(scopes.keys()), + scopes, + value, + values + }; +} +function configFilePath(filePath) { + return filePath.replace(/^(file):/, ""); +} +function* configParser(text, requestedKey = null) { + const lines = text.split("\0"); + for (let i = 0, max = lines.length - 1; i < max; ) { + const file = configFilePath(lines[i++]); + let value = lines[i++]; + let key = requestedKey; + if (value.includes("\n")) { + const line = splitOn(value, "\n"); + key = line[0]; + value = line[1]; + } + yield { file, key, value }; + } +} +var ConfigList; +var init_ConfigList = __esm({ + "src/lib/responses/ConfigList.ts"() { + init_utils(); + ConfigList = class { + constructor() { + this.files = []; + this.values = /* @__PURE__ */ Object.create(null); + } + get all() { + if (!this._all) { + this._all = this.files.reduce((all, file) => { + return Object.assign(all, this.values[file]); + }, {}); + } + return this._all; + } + addFile(file) { + if (!(file in this.values)) { + const latest = last(this.files); + this.values[file] = latest ? Object.create(this.values[latest]) : {}; + this.files.push(file); + } + return this.values[file]; + } + addValue(file, key, value) { + const values = this.addFile(file); + if (!values.hasOwnProperty(key)) { + values[key] = value; + } else if (Array.isArray(values[key])) { + values[key].push(value); + } else { + values[key] = [values[key], value]; + } + this._all = void 0; + } + }; + } +}); +function asConfigScope(scope, fallback) { + if (typeof scope === "string" && GitConfigScope.hasOwnProperty(scope)) { + return scope; + } + return fallback; +} +function addConfigTask(key, value, append2, scope) { + const commands = ["config", `--${scope}`]; + if (append2) { + commands.push("--add"); + } + commands.push(key, value); + return { + commands, + format: "utf-8", + parser(text) { + return text; + } + }; +} +function getConfigTask(key, scope) { + const commands = ["config", "--null", "--show-origin", "--get-all", key]; + if (scope) { + commands.splice(1, 0, `--${scope}`); + } + return { + commands, + format: "utf-8", + parser(text) { + return configGetParser(text, key); + } + }; +} +function listConfigTask(scope) { + const commands = ["config", "--list", "--show-origin", "--null"]; + if (scope) { + commands.push(`--${scope}`); + } + return { + commands, + format: "utf-8", + parser(text) { + return configListParser(text); + } + }; +} +function config_default() { + return { + addConfig(key, value, ...rest) { + return this._runTask(addConfigTask(key, value, rest[0] === true, asConfigScope( + rest[1], + "local" + /* local */ + )), trailingFunctionArgument(arguments)); + }, + getConfig(key, scope) { + return this._runTask(getConfigTask(key, asConfigScope(scope, void 0)), trailingFunctionArgument(arguments)); + }, + listConfig(...rest) { + return this._runTask(listConfigTask(asConfigScope(rest[0], void 0)), trailingFunctionArgument(arguments)); + } + }; +} +var GitConfigScope; +var init_config = __esm({ + "src/lib/tasks/config.ts"() { + init_ConfigList(); + init_utils(); + GitConfigScope = /* @__PURE__ */ ((GitConfigScope2) => { + GitConfigScope2["system"] = "system"; + GitConfigScope2["global"] = "global"; + GitConfigScope2["local"] = "local"; + GitConfigScope2["worktree"] = "worktree"; + return GitConfigScope2; + })(GitConfigScope || {}); + } +}); +function isDiffNameStatus(input) { + return diffNameStatus.has(input); +} +var DiffNameStatus; +var diffNameStatus; +var init_diff_name_status = __esm({ + "src/lib/tasks/diff-name-status.ts"() { + DiffNameStatus = /* @__PURE__ */ ((DiffNameStatus2) => { + DiffNameStatus2["ADDED"] = "A"; + DiffNameStatus2["COPIED"] = "C"; + DiffNameStatus2["DELETED"] = "D"; + DiffNameStatus2["MODIFIED"] = "M"; + DiffNameStatus2["RENAMED"] = "R"; + DiffNameStatus2["CHANGED"] = "T"; + DiffNameStatus2["UNMERGED"] = "U"; + DiffNameStatus2["UNKNOWN"] = "X"; + DiffNameStatus2["BROKEN"] = "B"; + return DiffNameStatus2; + })(DiffNameStatus || {}); + diffNameStatus = new Set(Object.values(DiffNameStatus)); + } +}); +function grepQueryBuilder(...params) { + return new GrepQuery().param(...params); +} +function parseGrep(grep) { + const paths = /* @__PURE__ */ new Set(); + const results = {}; + forEachLineWithContent(grep, (input) => { + const [path, line, preview] = input.split(NULL); + paths.add(path); + (results[path] = results[path] || []).push({ + line: asNumber(line), + path, + preview + }); + }); + return { + paths, + results + }; +} +function grep_default() { + return { + grep(searchTerm) { + const then = trailingFunctionArgument(arguments); + const options = getTrailingOptions(arguments); + for (const option of disallowedOptions) { + if (options.includes(option)) { + return this._runTask(configurationErrorTask(`git.grep: use of "${option}" is not supported.`), then); + } + } + if (typeof searchTerm === "string") { + searchTerm = grepQueryBuilder().param(searchTerm); + } + const commands = ["grep", "--null", "-n", "--full-name", ...options, ...searchTerm]; + return this._runTask({ + commands, + format: "utf-8", + parser(stdOut) { + return parseGrep(stdOut); + } + }, then); + } + }; +} +var disallowedOptions; +var Query; +var _a; +var GrepQuery; +var init_grep = __esm({ + "src/lib/tasks/grep.ts"() { + init_utils(); + init_task(); + disallowedOptions = ["-h"]; + Query = Symbol("grepQuery"); + GrepQuery = class { + constructor() { + this[_a] = []; + } + *[(_a = Query, Symbol.iterator)]() { + for (const query of this[Query]) { + yield query; + } + } + and(...and) { + and.length && this[Query].push("--and", "(", ...prefixedArray(and, "-e"), ")"); + return this; + } + param(...param) { + this[Query].push(...prefixedArray(param, "-e")); + return this; + } + }; + } +}); +var reset_exports = {}; +__export2(reset_exports, { + ResetMode: () => ResetMode, + getResetMode: () => getResetMode, + resetTask: () => resetTask +}); +function resetTask(mode, customArgs) { + const commands = ["reset"]; + if (isValidResetMode(mode)) { + commands.push(`--${mode}`); + } + commands.push(...customArgs); + return straightThroughStringTask(commands); +} +function getResetMode(mode) { + if (isValidResetMode(mode)) { + return mode; + } + switch (typeof mode) { + case "string": + case "undefined": + return "soft"; + } + return; +} +function isValidResetMode(mode) { + return ResetModes.includes(mode); +} +var ResetMode; +var ResetModes; +var init_reset = __esm({ + "src/lib/tasks/reset.ts"() { + init_task(); + ResetMode = /* @__PURE__ */ ((ResetMode2) => { + ResetMode2["MIXED"] = "mixed"; + ResetMode2["SOFT"] = "soft"; + ResetMode2["HARD"] = "hard"; + ResetMode2["MERGE"] = "merge"; + ResetMode2["KEEP"] = "keep"; + return ResetMode2; + })(ResetMode || {}); + ResetModes = Array.from(Object.values(ResetMode)); + } +}); +function createLog() { + return (0, import_debug.default)("simple-git"); +} +function prefixedLogger(to, prefix, forward) { + if (!prefix || !String(prefix).replace(/\s*/, "")) { + return !forward ? to : (message, ...args) => { + to(message, ...args); + forward(message, ...args); + }; + } + return (message, ...args) => { + to(`%s ${message}`, prefix, ...args); + if (forward) { + forward(message, ...args); + } + }; +} +function childLoggerName(name, childDebugger, { namespace: parentNamespace }) { + if (typeof name === "string") { + return name; + } + const childNamespace = childDebugger && childDebugger.namespace || ""; + if (childNamespace.startsWith(parentNamespace)) { + return childNamespace.substr(parentNamespace.length + 1); + } + return childNamespace || parentNamespace; +} +function createLogger(label, verbose, initialStep, infoDebugger = createLog()) { + const labelPrefix = label && `[${label}]` || ""; + const spawned = []; + const debugDebugger = typeof verbose === "string" ? infoDebugger.extend(verbose) : verbose; + const key = childLoggerName(filterType(verbose, filterString), debugDebugger, infoDebugger); + return step(initialStep); + function sibling(name, initial) { + return append(spawned, createLogger(label, key.replace(/^[^:]+/, name), initial, infoDebugger)); + } + function step(phase) { + const stepPrefix = phase && `[${phase}]` || ""; + const debug2 = debugDebugger && prefixedLogger(debugDebugger, stepPrefix) || NOOP; + const info = prefixedLogger(infoDebugger, `${labelPrefix} ${stepPrefix}`, debug2); + return Object.assign(debugDebugger ? debug2 : info, { + label, + sibling, + info, + step + }); + } +} +var init_git_logger = __esm({ + "src/lib/git-logger.ts"() { + init_utils(); + import_debug.default.formatters.L = (value) => String(filterHasLength(value) ? value.length : "-"); + import_debug.default.formatters.B = (value) => { + if (Buffer.isBuffer(value)) { + return value.toString("utf8"); + } + return objectToString(value); + }; + } +}); +var _TasksPendingQueue; +var TasksPendingQueue; +var init_tasks_pending_queue = __esm({ + "src/lib/runners/tasks-pending-queue.ts"() { + init_git_error(); + init_git_logger(); + _TasksPendingQueue = class { + constructor(logLabel = "GitExecutor") { + this.logLabel = logLabel; + this._queue = /* @__PURE__ */ new Map(); + } + withProgress(task) { + return this._queue.get(task); + } + createProgress(task) { + const name = _TasksPendingQueue.getName(task.commands[0]); + const logger2 = createLogger(this.logLabel, name); + return { + task, + logger: logger2, + name + }; + } + push(task) { + const progress = this.createProgress(task); + progress.logger("Adding task to the queue, commands = %o", task.commands); + this._queue.set(task, progress); + return progress; + } + fatal(err) { + for (const [task, { logger: logger2 }] of Array.from(this._queue.entries())) { + if (task === err.task) { + logger2.info(`Failed %o`, err); + logger2(`Fatal exception, any as-yet un-started tasks run through this executor will not be attempted`); + } else { + logger2.info(`A fatal exception occurred in a previous task, the queue has been purged: %o`, err.message); + } + this.complete(task); + } + if (this._queue.size !== 0) { + throw new Error(`Queue size should be zero after fatal: ${this._queue.size}`); + } + } + complete(task) { + const progress = this.withProgress(task); + if (progress) { + this._queue.delete(task); + } + } + attempt(task) { + const progress = this.withProgress(task); + if (!progress) { + throw new GitError(void 0, "TasksPendingQueue: attempt called for an unknown task"); + } + progress.logger("Starting task"); + return progress; + } + static getName(name = "empty") { + return `task:${name}:${++_TasksPendingQueue.counter}`; + } + }; + TasksPendingQueue = _TasksPendingQueue; + TasksPendingQueue.counter = 0; + } +}); +function pluginContext(task, commands) { + return { + method: first(task.commands) || "", + commands + }; +} +function onErrorReceived(target, logger2) { + return (err) => { + logger2(`[ERROR] child process exception %o`, err); + target.push(Buffer.from(String(err.stack), "ascii")); + }; +} +function onDataReceived(target, name, logger2, output) { + return (buffer) => { + logger2(`%s received %L bytes`, name, buffer); + output(`%B`, buffer); + target.push(buffer); + }; +} +var GitExecutorChain; +var init_git_executor_chain = __esm({ + "src/lib/runners/git-executor-chain.ts"() { + init_git_error(); + init_task(); + init_utils(); + init_tasks_pending_queue(); + GitExecutorChain = class { + constructor(_executor, _scheduler, _plugins) { + this._executor = _executor; + this._scheduler = _scheduler; + this._plugins = _plugins; + this._chain = Promise.resolve(); + this._queue = new TasksPendingQueue(); + } + get binary() { + return this._executor.binary; + } + get cwd() { + return this._cwd || this._executor.cwd; + } + set cwd(cwd) { + this._cwd = cwd; + } + get env() { + return this._executor.env; + } + get outputHandler() { + return this._executor.outputHandler; + } + chain() { + return this; + } + push(task) { + this._queue.push(task); + return this._chain = this._chain.then(() => this.attemptTask(task)); + } + attemptTask(task) { + return __async(this, null, function* () { + const onScheduleComplete = yield this._scheduler.next(); + const onQueueComplete = () => this._queue.complete(task); + try { + const { logger: logger2 } = this._queue.attempt(task); + return yield isEmptyTask(task) ? this.attemptEmptyTask(task, logger2) : this.attemptRemoteTask(task, logger2); + } catch (e) { + throw this.onFatalException(task, e); + } finally { + onQueueComplete(); + onScheduleComplete(); + } + }); + } + onFatalException(task, e) { + const gitError = e instanceof GitError ? Object.assign(e, { task }) : new GitError(task, e && String(e)); + this._chain = Promise.resolve(); + this._queue.fatal(gitError); + return gitError; + } + attemptRemoteTask(task, logger2) { + return __async(this, null, function* () { + const args = this._plugins.exec("spawn.args", [...task.commands], pluginContext(task, task.commands)); + const raw = yield this.gitResponse(task, this.binary, args, this.outputHandler, logger2.step("SPAWN")); + const outputStreams = yield this.handleTaskData(task, args, raw, logger2.step("HANDLE")); + logger2(`passing response to task's parser as a %s`, task.format); + if (isBufferTask(task)) { + return callTaskParser(task.parser, outputStreams); + } + return callTaskParser(task.parser, outputStreams.asStrings()); + }); + } + attemptEmptyTask(task, logger2) { + return __async(this, null, function* () { + logger2(`empty task bypassing child process to call to task's parser`); + return task.parser(this); + }); + } + handleTaskData(task, args, result, logger2) { + const { exitCode, rejection, stdOut, stdErr } = result; + return new Promise((done, fail) => { + logger2(`Preparing to handle process response exitCode=%d stdOut=`, exitCode); + const { error } = this._plugins.exec("task.error", { error: rejection }, __spreadValues(__spreadValues({}, pluginContext(task, args)), result)); + if (error && task.onError) { + logger2.info(`exitCode=%s handling with custom error handler`); + return task.onError(result, error, (newStdOut) => { + logger2.info(`custom error handler treated as success`); + logger2(`custom error returned a %s`, objectToString(newStdOut)); + done(new GitOutputStreams(Array.isArray(newStdOut) ? Buffer.concat(newStdOut) : newStdOut, Buffer.concat(stdErr))); + }, fail); + } + if (error) { + logger2.info(`handling as error: exitCode=%s stdErr=%s rejection=%o`, exitCode, stdErr.length, rejection); + return fail(error); + } + logger2.info(`retrieving task output complete`); + done(new GitOutputStreams(Buffer.concat(stdOut), Buffer.concat(stdErr))); + }); + } + gitResponse(task, command, args, outputHandler, logger2) { + return __async(this, null, function* () { + const outputLogger = logger2.sibling("output"); + const spawnOptions = this._plugins.exec("spawn.options", { + cwd: this.cwd, + env: this.env, + windowsHide: true + }, pluginContext(task, task.commands)); + return new Promise((done) => { + const stdOut = []; + const stdErr = []; + logger2.info(`%s %o`, command, args); + logger2("%O", spawnOptions); + let rejection = this._beforeSpawn(task, args); + if (rejection) { + return done({ + stdOut, + stdErr, + exitCode: 9901, + rejection + }); + } + this._plugins.exec("spawn.before", void 0, __spreadProps(__spreadValues({}, pluginContext(task, args)), { + kill(reason) { + rejection = reason || rejection; + } + })); + const spawned = (0, import_child_process.spawn)(command, args, spawnOptions); + spawned.stdout.on("data", onDataReceived(stdOut, "stdOut", logger2, outputLogger.step("stdOut"))); + spawned.stderr.on("data", onDataReceived(stdErr, "stdErr", logger2, outputLogger.step("stdErr"))); + spawned.on("error", onErrorReceived(stdErr, logger2)); + if (outputHandler) { + logger2(`Passing child process stdOut/stdErr to custom outputHandler`); + outputHandler(command, spawned.stdout, spawned.stderr, [...args]); + } + this._plugins.exec("spawn.after", void 0, __spreadProps(__spreadValues({}, pluginContext(task, args)), { + spawned, + close(exitCode, reason) { + done({ + stdOut, + stdErr, + exitCode, + rejection: rejection || reason + }); + }, + kill(reason) { + if (spawned.killed) { + return; + } + rejection = reason; + spawned.kill("SIGINT"); + } + })); + }); + }); + } + _beforeSpawn(task, args) { + let rejection; + this._plugins.exec("spawn.before", void 0, __spreadProps(__spreadValues({}, pluginContext(task, args)), { + kill(reason) { + rejection = reason || rejection; + } + })); + return rejection; + } + }; + } +}); +var git_executor_exports = {}; +__export2(git_executor_exports, { + GitExecutor: () => GitExecutor +}); +var GitExecutor; +var init_git_executor = __esm({ + "src/lib/runners/git-executor.ts"() { + init_git_executor_chain(); + GitExecutor = class { + constructor(binary = "git", cwd, _scheduler, _plugins) { + this.binary = binary; + this.cwd = cwd; + this._scheduler = _scheduler; + this._plugins = _plugins; + this._chain = new GitExecutorChain(this, this._scheduler, this._plugins); + } + chain() { + return new GitExecutorChain(this, this._scheduler, this._plugins); + } + push(task) { + return this._chain.push(task); + } + }; + } +}); +function taskCallback(task, response, callback = NOOP) { + const onSuccess = (data) => { + callback(null, data); + }; + const onError2 = (err) => { + if ((err == null ? void 0 : err.task) === task) { + callback(err instanceof GitResponseError ? addDeprecationNoticeToError(err) : err, void 0); + } + }; + response.then(onSuccess, onError2); +} +function addDeprecationNoticeToError(err) { + let log = (name) => { + console.warn(`simple-git deprecation notice: accessing GitResponseError.${name} should be GitResponseError.git.${name}, this will no longer be available in version 3`); + log = NOOP; + }; + return Object.create(err, Object.getOwnPropertyNames(err.git).reduce(descriptorReducer, {})); + function descriptorReducer(all, name) { + if (name in err) { + return all; + } + all[name] = { + enumerable: false, + configurable: false, + get() { + log(name); + return err.git[name]; + } + }; + return all; + } +} +var init_task_callback = __esm({ + "src/lib/task-callback.ts"() { + init_git_response_error(); + init_utils(); + } +}); +function changeWorkingDirectoryTask(directory, root) { + return adhocExecTask((instance) => { + if (!folderExists(directory)) { + throw new Error(`Git.cwd: cannot change to non-directory "${directory}"`); + } + return (root || instance).cwd = directory; + }); +} +var init_change_working_directory = __esm({ + "src/lib/tasks/change-working-directory.ts"() { + init_utils(); + init_task(); + } +}); +function checkoutTask(args) { + const commands = ["checkout", ...args]; + if (commands[1] === "-b" && commands.includes("-B")) { + commands[1] = remove(commands, "-B"); + } + return straightThroughStringTask(commands); +} +function checkout_default() { + return { + checkout() { + return this._runTask(checkoutTask(getTrailingOptions(arguments, 1)), trailingFunctionArgument(arguments)); + }, + checkoutBranch(branchName, startPoint) { + return this._runTask(checkoutTask(["-b", branchName, startPoint, ...getTrailingOptions(arguments)]), trailingFunctionArgument(arguments)); + }, + checkoutLocalBranch(branchName) { + return this._runTask(checkoutTask(["-b", branchName, ...getTrailingOptions(arguments)]), trailingFunctionArgument(arguments)); + } + }; +} +var init_checkout = __esm({ + "src/lib/tasks/checkout.ts"() { + init_utils(); + init_task(); + } +}); +function parseCommitResult(stdOut) { + const result = { + author: null, + branch: "", + commit: "", + root: false, + summary: { + changes: 0, + insertions: 0, + deletions: 0 + } + }; + return parseStringResponse(result, parsers, stdOut); +} +var parsers; +var init_parse_commit = __esm({ + "src/lib/parsers/parse-commit.ts"() { + init_utils(); + parsers = [ + new LineParser(/^\[([^\s]+)( \([^)]+\))? ([^\]]+)/, (result, [branch, root, commit]) => { + result.branch = branch; + result.commit = commit; + result.root = !!root; + }), + new LineParser(/\s*Author:\s(.+)/i, (result, [author]) => { + const parts = author.split("<"); + const email = parts.pop(); + if (!email || !email.includes("@")) { + return; + } + result.author = { + email: email.substr(0, email.length - 1), + name: parts.join("<").trim() + }; + }), + new LineParser(/(\d+)[^,]*(?:,\s*(\d+)[^,]*)(?:,\s*(\d+))/g, (result, [changes, insertions, deletions]) => { + result.summary.changes = parseInt(changes, 10) || 0; + result.summary.insertions = parseInt(insertions, 10) || 0; + result.summary.deletions = parseInt(deletions, 10) || 0; + }), + new LineParser(/^(\d+)[^,]*(?:,\s*(\d+)[^(]+\(([+-]))?/, (result, [changes, lines, direction]) => { + result.summary.changes = parseInt(changes, 10) || 0; + const count = parseInt(lines, 10) || 0; + if (direction === "-") { + result.summary.deletions = count; + } else if (direction === "+") { + result.summary.insertions = count; + } + }) + ]; + } +}); +function commitTask(message, files, customArgs) { + const commands = [ + "-c", + "core.abbrev=40", + "commit", + ...prefixedArray(message, "-m"), + ...files, + ...customArgs + ]; + return { + commands, + format: "utf-8", + parser: parseCommitResult + }; +} +function commit_default() { + return { + commit(message, ...rest) { + const next = trailingFunctionArgument(arguments); + const task = rejectDeprecatedSignatures(message) || commitTask(asArray(message), asArray(filterType(rest[0], filterStringOrStringArray, [])), [...filterType(rest[1], filterArray, []), ...getTrailingOptions(arguments, 0, true)]); + return this._runTask(task, next); + } + }; + function rejectDeprecatedSignatures(message) { + return !filterStringOrStringArray(message) && configurationErrorTask(`git.commit: requires the commit message to be supplied as a string/string[]`); + } +} +var init_commit = __esm({ + "src/lib/tasks/commit.ts"() { + init_parse_commit(); + init_utils(); + init_task(); + } +}); +function first_commit_default() { + return { + firstCommit() { + return this._runTask(straightThroughStringTask(["rev-list", "--max-parents=0", "HEAD"], true), trailingFunctionArgument(arguments)); + } + }; +} +var init_first_commit = __esm({ + "src/lib/tasks/first-commit.ts"() { + init_utils(); + init_task(); + } +}); +function hashObjectTask(filePath, write) { + const commands = ["hash-object", filePath]; + if (write) { + commands.push("-w"); + } + return straightThroughStringTask(commands, true); +} +var init_hash_object = __esm({ + "src/lib/tasks/hash-object.ts"() { + init_task(); + } +}); +function parseInit(bare, path, text) { + const response = String(text).trim(); + let result; + if (result = initResponseRegex.exec(response)) { + return new InitSummary(bare, path, false, result[1]); + } + if (result = reInitResponseRegex.exec(response)) { + return new InitSummary(bare, path, true, result[1]); + } + let gitDir = ""; + const tokens = response.split(" "); + while (tokens.length) { + const token = tokens.shift(); + if (token === "in") { + gitDir = tokens.join(" "); + break; + } + } + return new InitSummary(bare, path, /^re/i.test(response), gitDir); +} +var InitSummary; +var initResponseRegex; +var reInitResponseRegex; +var init_InitSummary = __esm({ + "src/lib/responses/InitSummary.ts"() { + InitSummary = class { + constructor(bare, path, existing, gitDir) { + this.bare = bare; + this.path = path; + this.existing = existing; + this.gitDir = gitDir; + } + }; + initResponseRegex = /^Init.+ repository in (.+)$/; + reInitResponseRegex = /^Rein.+ in (.+)$/; + } +}); +function hasBareCommand(command) { + return command.includes(bareCommand); +} +function initTask(bare = false, path, customArgs) { + const commands = ["init", ...customArgs]; + if (bare && !hasBareCommand(commands)) { + commands.splice(1, 0, bareCommand); + } + return { + commands, + format: "utf-8", + parser(text) { + return parseInit(commands.includes("--bare"), path, text); + } + }; +} +var bareCommand; +var init_init = __esm({ + "src/lib/tasks/init.ts"() { + init_InitSummary(); + bareCommand = "--bare"; + } +}); +function logFormatFromCommand(customArgs) { + for (let i = 0; i < customArgs.length; i++) { + const format = logFormatRegex.exec(customArgs[i]); + if (format) { + return `--${format[1]}`; + } + } + return ""; +} +function isLogFormat(customArg) { + return logFormatRegex.test(customArg); +} +var logFormatRegex; +var init_log_format = __esm({ + "src/lib/args/log-format.ts"() { + logFormatRegex = /^--(stat|numstat|name-only|name-status)(=|$)/; + } +}); +var DiffSummary; +var init_DiffSummary = __esm({ + "src/lib/responses/DiffSummary.ts"() { + DiffSummary = class { + constructor() { + this.changed = 0; + this.deletions = 0; + this.insertions = 0; + this.files = []; + } + }; + } +}); +function getDiffParser(format = "") { + const parser3 = diffSummaryParsers[format]; + return (stdOut) => parseStringResponse(new DiffSummary(), parser3, stdOut, false); +} +var statParser; +var numStatParser; +var nameOnlyParser; +var nameStatusParser; +var diffSummaryParsers; +var init_parse_diff_summary = __esm({ + "src/lib/parsers/parse-diff-summary.ts"() { + init_log_format(); + init_DiffSummary(); + init_diff_name_status(); + init_utils(); + statParser = [ + new LineParser(/(.+)\s+\|\s+(\d+)(\s+[+\-]+)?$/, (result, [file, changes, alterations = ""]) => { + result.files.push({ + file: file.trim(), + changes: asNumber(changes), + insertions: alterations.replace(/[^+]/g, "").length, + deletions: alterations.replace(/[^-]/g, "").length, + binary: false + }); + }), + new LineParser(/(.+) \|\s+Bin ([0-9.]+) -> ([0-9.]+) ([a-z]+)/, (result, [file, before, after]) => { + result.files.push({ + file: file.trim(), + before: asNumber(before), + after: asNumber(after), + binary: true + }); + }), + new LineParser(/(\d+) files? changed\s*((?:, \d+ [^,]+){0,2})/, (result, [changed, summary]) => { + const inserted = /(\d+) i/.exec(summary); + const deleted = /(\d+) d/.exec(summary); + result.changed = asNumber(changed); + result.insertions = asNumber(inserted == null ? void 0 : inserted[1]); + result.deletions = asNumber(deleted == null ? void 0 : deleted[1]); + }) + ]; + numStatParser = [ + new LineParser(/(\d+)\t(\d+)\t(.+)$/, (result, [changesInsert, changesDelete, file]) => { + const insertions = asNumber(changesInsert); + const deletions = asNumber(changesDelete); + result.changed++; + result.insertions += insertions; + result.deletions += deletions; + result.files.push({ + file, + changes: insertions + deletions, + insertions, + deletions, + binary: false + }); + }), + new LineParser(/-\t-\t(.+)$/, (result, [file]) => { + result.changed++; + result.files.push({ + file, + after: 0, + before: 0, + binary: true + }); + }) + ]; + nameOnlyParser = [ + new LineParser(/(.+)$/, (result, [file]) => { + result.changed++; + result.files.push({ + file, + changes: 0, + insertions: 0, + deletions: 0, + binary: false + }); + }) + ]; + nameStatusParser = [ + new LineParser(/([ACDMRTUXB])([0-9]{0,3})\t(.[^\t]*)(\t(.[^\t]*))?$/, (result, [status, _similarity, from, _to, to]) => { + result.changed++; + result.files.push({ + file: to != null ? to : from, + changes: 0, + status: orVoid(isDiffNameStatus(status) && status), + insertions: 0, + deletions: 0, + binary: false + }); + }) + ]; + diffSummaryParsers = { + [ + "" + /* NONE */ + ]: statParser, + [ + "--stat" + /* STAT */ + ]: statParser, + [ + "--numstat" + /* NUM_STAT */ + ]: numStatParser, + [ + "--name-status" + /* NAME_STATUS */ + ]: nameStatusParser, + [ + "--name-only" + /* NAME_ONLY */ + ]: nameOnlyParser + }; + } +}); +function lineBuilder(tokens, fields) { + return fields.reduce((line, field, index) => { + line[field] = tokens[index] || ""; + return line; + }, /* @__PURE__ */ Object.create({ diff: null })); +} +function createListLogSummaryParser(splitter = SPLITTER, fields = defaultFieldNames, logFormat = "") { + const parseDiffResult = getDiffParser(logFormat); + return function(stdOut) { + const all = toLinesWithContent(stdOut, true, START_BOUNDARY).map(function(item) { + const lineDetail = item.trim().split(COMMIT_BOUNDARY); + const listLogLine = lineBuilder(lineDetail[0].trim().split(splitter), fields); + if (lineDetail.length > 1 && !!lineDetail[1].trim()) { + listLogLine.diff = parseDiffResult(lineDetail[1]); + } + return listLogLine; + }); + return { + all, + latest: all.length && all[0] || null, + total: all.length + }; + }; +} +var START_BOUNDARY; +var COMMIT_BOUNDARY; +var SPLITTER; +var defaultFieldNames; +var init_parse_list_log_summary = __esm({ + "src/lib/parsers/parse-list-log-summary.ts"() { + init_utils(); + init_parse_diff_summary(); + init_log_format(); + START_BOUNDARY = "\xF2\xF2\xF2\xF2\xF2\xF2 "; + COMMIT_BOUNDARY = " \xF2\xF2"; + SPLITTER = " \xF2 "; + defaultFieldNames = ["hash", "date", "message", "refs", "author_name", "author_email"]; + } +}); +var diff_exports = {}; +__export2(diff_exports, { + diffSummaryTask: () => diffSummaryTask, + validateLogFormatConfig: () => validateLogFormatConfig +}); +function diffSummaryTask(customArgs) { + let logFormat = logFormatFromCommand(customArgs); + const commands = ["diff"]; + if (logFormat === "") { + logFormat = "--stat"; + commands.push("--stat=4096"); + } + commands.push(...customArgs); + return validateLogFormatConfig(commands) || { + commands, + format: "utf-8", + parser: getDiffParser(logFormat) + }; +} +function validateLogFormatConfig(customArgs) { + const flags = customArgs.filter(isLogFormat); + if (flags.length > 1) { + return configurationErrorTask(`Summary flags are mutually exclusive - pick one of ${flags.join(",")}`); + } + if (flags.length && customArgs.includes("-z")) { + return configurationErrorTask(`Summary flag ${flags} parsing is not compatible with null termination option '-z'`); + } +} +var init_diff = __esm({ + "src/lib/tasks/diff.ts"() { + init_log_format(); + init_parse_diff_summary(); + init_task(); + } +}); +function prettyFormat(format, splitter) { + const fields = []; + const formatStr = []; + Object.keys(format).forEach((field) => { + fields.push(field); + formatStr.push(String(format[field])); + }); + return [fields, formatStr.join(splitter)]; +} +function userOptions(input) { + return Object.keys(input).reduce((out, key) => { + if (!(key in excludeOptions)) { + out[key] = input[key]; + } + return out; + }, {}); +} +function parseLogOptions(opt = {}, customArgs = []) { + const splitter = filterType(opt.splitter, filterString, SPLITTER); + const format = !filterPrimitives(opt.format) && opt.format ? opt.format : { + hash: "%H", + date: opt.strictDate === false ? "%ai" : "%aI", + message: "%s", + refs: "%D", + body: opt.multiLine ? "%B" : "%b", + author_name: opt.mailMap !== false ? "%aN" : "%an", + author_email: opt.mailMap !== false ? "%aE" : "%ae" + }; + const [fields, formatStr] = prettyFormat(format, splitter); + const suffix = []; + const command = [ + `--pretty=format:${START_BOUNDARY}${formatStr}${COMMIT_BOUNDARY}`, + ...customArgs + ]; + const maxCount = opt.n || opt["max-count"] || opt.maxCount; + if (maxCount) { + command.push(`--max-count=${maxCount}`); + } + if (opt.from || opt.to) { + const rangeOperator = opt.symmetric !== false ? "..." : ".."; + suffix.push(`${opt.from || ""}${rangeOperator}${opt.to || ""}`); + } + if (filterString(opt.file)) { + command.push("--follow", pathspec(opt.file)); + } + appendTaskOptions(userOptions(opt), command); + return { + fields, + splitter, + commands: [...command, ...suffix] + }; +} +function logTask(splitter, fields, customArgs) { + const parser3 = createListLogSummaryParser(splitter, fields, logFormatFromCommand(customArgs)); + return { + commands: ["log", ...customArgs], + format: "utf-8", + parser: parser3 + }; +} +function log_default() { + return { + log(...rest) { + const next = trailingFunctionArgument(arguments); + const options = parseLogOptions(trailingOptionsArgument(arguments), filterType(arguments[0], filterArray)); + const task = rejectDeprecatedSignatures(...rest) || validateLogFormatConfig(options.commands) || createLogTask(options); + return this._runTask(task, next); + } + }; + function createLogTask(options) { + return logTask(options.splitter, options.fields, options.commands); + } + function rejectDeprecatedSignatures(from, to) { + return filterString(from) && filterString(to) && configurationErrorTask(`git.log(string, string) should be replaced with git.log({ from: string, to: string })`); + } +} +var excludeOptions; +var init_log = __esm({ + "src/lib/tasks/log.ts"() { + init_log_format(); + init_pathspec(); + init_parse_list_log_summary(); + init_utils(); + init_task(); + init_diff(); + excludeOptions = /* @__PURE__ */ ((excludeOptions2) => { + excludeOptions2[excludeOptions2["--pretty"] = 0] = "--pretty"; + excludeOptions2[excludeOptions2["max-count"] = 1] = "max-count"; + excludeOptions2[excludeOptions2["maxCount"] = 2] = "maxCount"; + excludeOptions2[excludeOptions2["n"] = 3] = "n"; + excludeOptions2[excludeOptions2["file"] = 4] = "file"; + excludeOptions2[excludeOptions2["format"] = 5] = "format"; + excludeOptions2[excludeOptions2["from"] = 6] = "from"; + excludeOptions2[excludeOptions2["to"] = 7] = "to"; + excludeOptions2[excludeOptions2["splitter"] = 8] = "splitter"; + excludeOptions2[excludeOptions2["symmetric"] = 9] = "symmetric"; + excludeOptions2[excludeOptions2["mailMap"] = 10] = "mailMap"; + excludeOptions2[excludeOptions2["multiLine"] = 11] = "multiLine"; + excludeOptions2[excludeOptions2["strictDate"] = 12] = "strictDate"; + return excludeOptions2; + })(excludeOptions || {}); + } +}); +var MergeSummaryConflict; +var MergeSummaryDetail; +var init_MergeSummary = __esm({ + "src/lib/responses/MergeSummary.ts"() { + MergeSummaryConflict = class { + constructor(reason, file = null, meta) { + this.reason = reason; + this.file = file; + this.meta = meta; + } + toString() { + return `${this.file}:${this.reason}`; + } + }; + MergeSummaryDetail = class { + constructor() { + this.conflicts = []; + this.merges = []; + this.result = "success"; + } + get failed() { + return this.conflicts.length > 0; + } + get reason() { + return this.result; + } + toString() { + if (this.conflicts.length) { + return `CONFLICTS: ${this.conflicts.join(", ")}`; + } + return "OK"; + } + }; + } +}); +var PullSummary; +var PullFailedSummary; +var init_PullSummary = __esm({ + "src/lib/responses/PullSummary.ts"() { + PullSummary = class { + constructor() { + this.remoteMessages = { + all: [] + }; + this.created = []; + this.deleted = []; + this.files = []; + this.deletions = {}; + this.insertions = {}; + this.summary = { + changes: 0, + deletions: 0, + insertions: 0 + }; + } + }; + PullFailedSummary = class { + constructor() { + this.remote = ""; + this.hash = { + local: "", + remote: "" + }; + this.branch = { + local: "", + remote: "" + }; + this.message = ""; + } + toString() { + return this.message; + } + }; + } +}); +function objectEnumerationResult(remoteMessages) { + return remoteMessages.objects = remoteMessages.objects || { + compressing: 0, + counting: 0, + enumerating: 0, + packReused: 0, + reused: { count: 0, delta: 0 }, + total: { count: 0, delta: 0 } + }; +} +function asObjectCount(source) { + const count = /^\s*(\d+)/.exec(source); + const delta = /delta (\d+)/i.exec(source); + return { + count: asNumber(count && count[1] || "0"), + delta: asNumber(delta && delta[1] || "0") + }; +} +var remoteMessagesObjectParsers; +var init_parse_remote_objects = __esm({ + "src/lib/parsers/parse-remote-objects.ts"() { + init_utils(); + remoteMessagesObjectParsers = [ + new RemoteLineParser(/^remote:\s*(enumerating|counting|compressing) objects: (\d+),/i, (result, [action, count]) => { + const key = action.toLowerCase(); + const enumeration = objectEnumerationResult(result.remoteMessages); + Object.assign(enumeration, { [key]: asNumber(count) }); + }), + new RemoteLineParser(/^remote:\s*(enumerating|counting|compressing) objects: \d+% \(\d+\/(\d+)\),/i, (result, [action, count]) => { + const key = action.toLowerCase(); + const enumeration = objectEnumerationResult(result.remoteMessages); + Object.assign(enumeration, { [key]: asNumber(count) }); + }), + new RemoteLineParser(/total ([^,]+), reused ([^,]+), pack-reused (\d+)/i, (result, [total, reused, packReused]) => { + const objects = objectEnumerationResult(result.remoteMessages); + objects.total = asObjectCount(total); + objects.reused = asObjectCount(reused); + objects.packReused = asNumber(packReused); + }) + ]; + } +}); +function parseRemoteMessages(_stdOut, stdErr) { + return parseStringResponse({ remoteMessages: new RemoteMessageSummary() }, parsers2, stdErr); +} +var parsers2; +var RemoteMessageSummary; +var init_parse_remote_messages = __esm({ + "src/lib/parsers/parse-remote-messages.ts"() { + init_utils(); + init_parse_remote_objects(); + parsers2 = [ + new RemoteLineParser(/^remote:\s*(.+)$/, (result, [text]) => { + result.remoteMessages.all.push(text.trim()); + return false; + }), + ...remoteMessagesObjectParsers, + new RemoteLineParser([/create a (?:pull|merge) request/i, /\s(https?:\/\/\S+)$/], (result, [pullRequestUrl]) => { + result.remoteMessages.pullRequestUrl = pullRequestUrl; + }), + new RemoteLineParser([/found (\d+) vulnerabilities.+\(([^)]+)\)/i, /\s(https?:\/\/\S+)$/], (result, [count, summary, url]) => { + result.remoteMessages.vulnerabilities = { + count: asNumber(count), + summary, + url + }; + }) + ]; + RemoteMessageSummary = class { + constructor() { + this.all = []; + } + }; + } +}); +function parsePullErrorResult(stdOut, stdErr) { + const pullError = parseStringResponse(new PullFailedSummary(), errorParsers, [stdOut, stdErr]); + return pullError.message && pullError; +} +var FILE_UPDATE_REGEX; +var SUMMARY_REGEX; +var ACTION_REGEX; +var parsers3; +var errorParsers; +var parsePullDetail; +var parsePullResult; +var init_parse_pull = __esm({ + "src/lib/parsers/parse-pull.ts"() { + init_PullSummary(); + init_utils(); + init_parse_remote_messages(); + FILE_UPDATE_REGEX = /^\s*(.+?)\s+\|\s+\d+\s*(\+*)(-*)/; + SUMMARY_REGEX = /(\d+)\D+((\d+)\D+\(\+\))?(\D+(\d+)\D+\(-\))?/; + ACTION_REGEX = /^(create|delete) mode \d+ (.+)/; + parsers3 = [ + new LineParser(FILE_UPDATE_REGEX, (result, [file, insertions, deletions]) => { + result.files.push(file); + if (insertions) { + result.insertions[file] = insertions.length; + } + if (deletions) { + result.deletions[file] = deletions.length; + } + }), + new LineParser(SUMMARY_REGEX, (result, [changes, , insertions, , deletions]) => { + if (insertions !== void 0 || deletions !== void 0) { + result.summary.changes = +changes || 0; + result.summary.insertions = +insertions || 0; + result.summary.deletions = +deletions || 0; + return true; + } + return false; + }), + new LineParser(ACTION_REGEX, (result, [action, file]) => { + append(result.files, file); + append(action === "create" ? result.created : result.deleted, file); + }) + ]; + errorParsers = [ + new LineParser(/^from\s(.+)$/i, (result, [remote]) => void (result.remote = remote)), + new LineParser(/^fatal:\s(.+)$/, (result, [message]) => void (result.message = message)), + new LineParser(/([a-z0-9]+)\.\.([a-z0-9]+)\s+(\S+)\s+->\s+(\S+)$/, (result, [hashLocal, hashRemote, branchLocal, branchRemote]) => { + result.branch.local = branchLocal; + result.hash.local = hashLocal; + result.branch.remote = branchRemote; + result.hash.remote = hashRemote; + }) + ]; + parsePullDetail = (stdOut, stdErr) => { + return parseStringResponse(new PullSummary(), parsers3, [stdOut, stdErr]); + }; + parsePullResult = (stdOut, stdErr) => { + return Object.assign(new PullSummary(), parsePullDetail(stdOut, stdErr), parseRemoteMessages(stdOut, stdErr)); + }; + } +}); +var parsers4; +var parseMergeResult; +var parseMergeDetail; +var init_parse_merge = __esm({ + "src/lib/parsers/parse-merge.ts"() { + init_MergeSummary(); + init_utils(); + init_parse_pull(); + parsers4 = [ + new LineParser(/^Auto-merging\s+(.+)$/, (summary, [autoMerge]) => { + summary.merges.push(autoMerge); + }), + new LineParser(/^CONFLICT\s+\((.+)\): Merge conflict in (.+)$/, (summary, [reason, file]) => { + summary.conflicts.push(new MergeSummaryConflict(reason, file)); + }), + new LineParser(/^CONFLICT\s+\((.+\/delete)\): (.+) deleted in (.+) and/, (summary, [reason, file, deleteRef]) => { + summary.conflicts.push(new MergeSummaryConflict(reason, file, { deleteRef })); + }), + new LineParser(/^CONFLICT\s+\((.+)\):/, (summary, [reason]) => { + summary.conflicts.push(new MergeSummaryConflict(reason, null)); + }), + new LineParser(/^Automatic merge failed;\s+(.+)$/, (summary, [result]) => { + summary.result = result; + }) + ]; + parseMergeResult = (stdOut, stdErr) => { + return Object.assign(parseMergeDetail(stdOut, stdErr), parsePullResult(stdOut, stdErr)); + }; + parseMergeDetail = (stdOut) => { + return parseStringResponse(new MergeSummaryDetail(), parsers4, stdOut); + }; + } +}); +function mergeTask(customArgs) { + if (!customArgs.length) { + return configurationErrorTask("Git.merge requires at least one option"); + } + return { + commands: ["merge", ...customArgs], + format: "utf-8", + parser(stdOut, stdErr) { + const merge = parseMergeResult(stdOut, stdErr); + if (merge.failed) { + throw new GitResponseError(merge); + } + return merge; + } + }; +} +var init_merge = __esm({ + "src/lib/tasks/merge.ts"() { + init_git_response_error(); + init_parse_merge(); + init_task(); + } +}); +function pushResultPushedItem(local, remote, status) { + const deleted = status.includes("deleted"); + const tag = status.includes("tag") || /^refs\/tags/.test(local); + const alreadyUpdated = !status.includes("new"); + return { + deleted, + tag, + branch: !tag, + new: !alreadyUpdated, + alreadyUpdated, + local, + remote + }; +} +var parsers5; +var parsePushResult; +var parsePushDetail; +var init_parse_push = __esm({ + "src/lib/parsers/parse-push.ts"() { + init_utils(); + init_parse_remote_messages(); + parsers5 = [ + new LineParser(/^Pushing to (.+)$/, (result, [repo]) => { + result.repo = repo; + }), + new LineParser(/^updating local tracking ref '(.+)'/, (result, [local]) => { + result.ref = __spreadProps(__spreadValues({}, result.ref || {}), { + local + }); + }), + new LineParser(/^[=*-]\s+([^:]+):(\S+)\s+\[(.+)]$/, (result, [local, remote, type]) => { + result.pushed.push(pushResultPushedItem(local, remote, type)); + }), + new LineParser(/^Branch '([^']+)' set up to track remote branch '([^']+)' from '([^']+)'/, (result, [local, remote, remoteName]) => { + result.branch = __spreadProps(__spreadValues({}, result.branch || {}), { + local, + remote, + remoteName + }); + }), + new LineParser(/^([^:]+):(\S+)\s+([a-z0-9]+)\.\.([a-z0-9]+)$/, (result, [local, remote, from, to]) => { + result.update = { + head: { + local, + remote + }, + hash: { + from, + to + } + }; + }) + ]; + parsePushResult = (stdOut, stdErr) => { + const pushDetail = parsePushDetail(stdOut, stdErr); + const responseDetail = parseRemoteMessages(stdOut, stdErr); + return __spreadValues(__spreadValues({}, pushDetail), responseDetail); + }; + parsePushDetail = (stdOut, stdErr) => { + return parseStringResponse({ pushed: [] }, parsers5, [stdOut, stdErr]); + }; + } +}); +var push_exports = {}; +__export2(push_exports, { + pushTagsTask: () => pushTagsTask, + pushTask: () => pushTask +}); +function pushTagsTask(ref = {}, customArgs) { + append(customArgs, "--tags"); + return pushTask(ref, customArgs); +} +function pushTask(ref = {}, customArgs) { + const commands = ["push", ...customArgs]; + if (ref.branch) { + commands.splice(1, 0, ref.branch); + } + if (ref.remote) { + commands.splice(1, 0, ref.remote); + } + remove(commands, "-v"); + append(commands, "--verbose"); + append(commands, "--porcelain"); + return { + commands, + format: "utf-8", + parser: parsePushResult + }; +} +var init_push = __esm({ + "src/lib/tasks/push.ts"() { + init_parse_push(); + init_utils(); + } +}); +function show_default() { + return { + showBuffer() { + const commands = ["show", ...getTrailingOptions(arguments, 1)]; + if (!commands.includes("--binary")) { + commands.splice(1, 0, "--binary"); + } + return this._runTask(straightThroughBufferTask(commands), trailingFunctionArgument(arguments)); + }, + show() { + const commands = ["show", ...getTrailingOptions(arguments, 1)]; + return this._runTask(straightThroughStringTask(commands), trailingFunctionArgument(arguments)); + } + }; +} +var init_show = __esm({ + "src/lib/tasks/show.ts"() { + init_utils(); + init_task(); + } +}); +var fromPathRegex; +var FileStatusSummary; +var init_FileStatusSummary = __esm({ + "src/lib/responses/FileStatusSummary.ts"() { + fromPathRegex = /^(.+) -> (.+)$/; + FileStatusSummary = class { + constructor(path, index, working_dir) { + this.path = path; + this.index = index; + this.working_dir = working_dir; + if (index + working_dir === "R") { + const detail = fromPathRegex.exec(path) || [null, path, path]; + this.from = detail[1] || ""; + this.path = detail[2] || ""; + } + } + }; + } +}); +function renamedFile(line) { + const [to, from] = line.split(NULL); + return { + from: from || to, + to + }; +} +function parser2(indexX, indexY, handler) { + return [`${indexX}${indexY}`, handler]; +} +function conflicts(indexX, ...indexY) { + return indexY.map((y) => parser2(indexX, y, (result, file) => append(result.conflicted, file))); +} +function splitLine(result, lineStr) { + const trimmed2 = lineStr.trim(); + switch (" ") { + case trimmed2.charAt(2): + return data(trimmed2.charAt(0), trimmed2.charAt(1), trimmed2.substr(3)); + case trimmed2.charAt(1): + return data(" ", trimmed2.charAt(0), trimmed2.substr(2)); + default: + return; + } + function data(index, workingDir, path) { + const raw = `${index}${workingDir}`; + const handler = parsers6.get(raw); + if (handler) { + handler(result, path); + } + if (raw !== "##" && raw !== "!!") { + result.files.push(new FileStatusSummary(path.replace(/\0.+$/, ""), index, workingDir)); + } + } +} +var StatusSummary; +var parsers6; +var parseStatusSummary; +var init_StatusSummary = __esm({ + "src/lib/responses/StatusSummary.ts"() { + init_utils(); + init_FileStatusSummary(); + StatusSummary = class { + constructor() { + this.not_added = []; + this.conflicted = []; + this.created = []; + this.deleted = []; + this.ignored = void 0; + this.modified = []; + this.renamed = []; + this.files = []; + this.staged = []; + this.ahead = 0; + this.behind = 0; + this.current = null; + this.tracking = null; + this.detached = false; + this.isClean = () => { + return !this.files.length; + }; + } + }; + parsers6 = new Map([ + parser2(" ", "A", (result, file) => append(result.created, file)), + parser2(" ", "D", (result, file) => append(result.deleted, file)), + parser2(" ", "M", (result, file) => append(result.modified, file)), + parser2("A", " ", (result, file) => append(result.created, file) && append(result.staged, file)), + parser2("A", "M", (result, file) => append(result.created, file) && append(result.staged, file) && append(result.modified, file)), + parser2("D", " ", (result, file) => append(result.deleted, file) && append(result.staged, file)), + parser2("M", " ", (result, file) => append(result.modified, file) && append(result.staged, file)), + parser2("M", "M", (result, file) => append(result.modified, file) && append(result.staged, file)), + parser2("R", " ", (result, file) => { + append(result.renamed, renamedFile(file)); + }), + parser2("R", "M", (result, file) => { + const renamed = renamedFile(file); + append(result.renamed, renamed); + append(result.modified, renamed.to); + }), + parser2("!", "!", (_result, _file) => { + append(_result.ignored = _result.ignored || [], _file); + }), + parser2("?", "?", (result, file) => append(result.not_added, file)), + ...conflicts( + "A", + "A", + "U" + /* UNMERGED */ + ), + ...conflicts( + "D", + "D", + "U" + /* UNMERGED */ + ), + ...conflicts( + "U", + "A", + "D", + "U" + /* UNMERGED */ + ), + [ + "##", + (result, line) => { + const aheadReg = /ahead (\d+)/; + const behindReg = /behind (\d+)/; + const currentReg = /^(.+?(?=(?:\.{3}|\s|$)))/; + const trackingReg = /\.{3}(\S*)/; + const onEmptyBranchReg = /\son\s([\S]+)$/; + let regexResult; + regexResult = aheadReg.exec(line); + result.ahead = regexResult && +regexResult[1] || 0; + regexResult = behindReg.exec(line); + result.behind = regexResult && +regexResult[1] || 0; + regexResult = currentReg.exec(line); + result.current = regexResult && regexResult[1]; + regexResult = trackingReg.exec(line); + result.tracking = regexResult && regexResult[1]; + regexResult = onEmptyBranchReg.exec(line); + result.current = regexResult && regexResult[1] || result.current; + result.detached = /\(no branch\)/.test(line); + } + ] + ]); + parseStatusSummary = function(text) { + const lines = text.split(NULL); + const status = new StatusSummary(); + for (let i = 0, l = lines.length; i < l; ) { + let line = lines[i++].trim(); + if (!line) { + continue; + } + if (line.charAt(0) === "R") { + line += NULL + (lines[i++] || ""); + } + splitLine(status, line); + } + return status; + }; + } +}); +function statusTask(customArgs) { + const commands = [ + "status", + "--porcelain", + "-b", + "-u", + "--null", + ...customArgs.filter((arg) => !ignoredOptions.includes(arg)) + ]; + return { + format: "utf-8", + commands, + parser(text) { + return parseStatusSummary(text); + } + }; +} +var ignoredOptions; +var init_status = __esm({ + "src/lib/tasks/status.ts"() { + init_StatusSummary(); + ignoredOptions = ["--null", "-z"]; + } +}); +function versionResponse(major = 0, minor = 0, patch = 0, agent = "", installed = true) { + return Object.defineProperty({ + major, + minor, + patch, + agent, + installed + }, "toString", { + value() { + return `${this.major}.${this.minor}.${this.patch}`; + }, + configurable: false, + enumerable: false + }); +} +function notInstalledResponse() { + return versionResponse(0, 0, 0, "", false); +} +function version_default() { + return { + version() { + return this._runTask({ + commands: ["--version"], + format: "utf-8", + parser: versionParser, + onError(result, error, done, fail) { + if (result.exitCode === -2) { + return done(Buffer.from(NOT_INSTALLED)); + } + fail(error); + } + }); + } + }; +} +function versionParser(stdOut) { + if (stdOut === NOT_INSTALLED) { + return notInstalledResponse(); + } + return parseStringResponse(versionResponse(0, 0, 0, stdOut), parsers7, stdOut); +} +var NOT_INSTALLED; +var parsers7; +var init_version = __esm({ + "src/lib/tasks/version.ts"() { + init_utils(); + NOT_INSTALLED = "installed=false"; + parsers7 = [ + new LineParser(/version (\d+)\.(\d+)\.(\d+)(?:\s*\((.+)\))?/, (result, [major, minor, patch, agent = ""]) => { + Object.assign(result, versionResponse(asNumber(major), asNumber(minor), asNumber(patch), agent)); + }), + new LineParser(/version (\d+)\.(\d+)\.(\D+)(.+)?$/, (result, [major, minor, patch, agent = ""]) => { + Object.assign(result, versionResponse(asNumber(major), asNumber(minor), patch, agent)); + }) + ]; + } +}); +var simple_git_api_exports = {}; +__export2(simple_git_api_exports, { + SimpleGitApi: () => SimpleGitApi +}); +var SimpleGitApi; +var init_simple_git_api = __esm({ + "src/lib/simple-git-api.ts"() { + init_task_callback(); + init_change_working_directory(); + init_checkout(); + init_commit(); + init_config(); + init_first_commit(); + init_grep(); + init_hash_object(); + init_init(); + init_log(); + init_merge(); + init_push(); + init_show(); + init_status(); + init_task(); + init_version(); + init_utils(); + SimpleGitApi = class { + constructor(_executor) { + this._executor = _executor; + } + _runTask(task, then) { + const chain = this._executor.chain(); + const promise = chain.push(task); + if (then) { + taskCallback(task, promise, then); + } + return Object.create(this, { + then: { value: promise.then.bind(promise) }, + catch: { value: promise.catch.bind(promise) }, + _executor: { value: chain } + }); + } + add(files) { + return this._runTask(straightThroughStringTask(["add", ...asArray(files)]), trailingFunctionArgument(arguments)); + } + cwd(directory) { + const next = trailingFunctionArgument(arguments); + if (typeof directory === "string") { + return this._runTask(changeWorkingDirectoryTask(directory, this._executor), next); + } + if (typeof (directory == null ? void 0 : directory.path) === "string") { + return this._runTask(changeWorkingDirectoryTask(directory.path, directory.root && this._executor || void 0), next); + } + return this._runTask(configurationErrorTask("Git.cwd: workingDirectory must be supplied as a string"), next); + } + hashObject(path, write) { + return this._runTask(hashObjectTask(path, write === true), trailingFunctionArgument(arguments)); + } + init(bare) { + return this._runTask(initTask(bare === true, this._executor.cwd, getTrailingOptions(arguments)), trailingFunctionArgument(arguments)); + } + merge() { + return this._runTask(mergeTask(getTrailingOptions(arguments)), trailingFunctionArgument(arguments)); + } + mergeFromTo(remote, branch) { + if (!(filterString(remote) && filterString(branch))) { + return this._runTask(configurationErrorTask(`Git.mergeFromTo requires that the 'remote' and 'branch' arguments are supplied as strings`)); + } + return this._runTask(mergeTask([remote, branch, ...getTrailingOptions(arguments)]), trailingFunctionArgument(arguments, false)); + } + outputHandler(handler) { + this._executor.outputHandler = handler; + return this; + } + push() { + const task = pushTask({ + remote: filterType(arguments[0], filterString), + branch: filterType(arguments[1], filterString) + }, getTrailingOptions(arguments)); + return this._runTask(task, trailingFunctionArgument(arguments)); + } + stash() { + return this._runTask(straightThroughStringTask(["stash", ...getTrailingOptions(arguments)]), trailingFunctionArgument(arguments)); + } + status() { + return this._runTask(statusTask(getTrailingOptions(arguments)), trailingFunctionArgument(arguments)); + } + }; + Object.assign(SimpleGitApi.prototype, checkout_default(), commit_default(), config_default(), first_commit_default(), grep_default(), log_default(), show_default(), version_default()); + } +}); +var scheduler_exports = {}; +__export2(scheduler_exports, { + Scheduler: () => Scheduler +}); +var createScheduledTask; +var Scheduler; +var init_scheduler = __esm({ + "src/lib/runners/scheduler.ts"() { + init_utils(); + init_git_logger(); + createScheduledTask = (() => { + let id = 0; + return () => { + id++; + const { promise, done } = (0, import_promise_deferred.createDeferred)(); + return { + promise, + done, + id + }; + }; + })(); + Scheduler = class { + constructor(concurrency = 2) { + this.concurrency = concurrency; + this.logger = createLogger("", "scheduler"); + this.pending = []; + this.running = []; + this.logger(`Constructed, concurrency=%s`, concurrency); + } + schedule() { + if (!this.pending.length || this.running.length >= this.concurrency) { + this.logger(`Schedule attempt ignored, pending=%s running=%s concurrency=%s`, this.pending.length, this.running.length, this.concurrency); + return; + } + const task = append(this.running, this.pending.shift()); + this.logger(`Attempting id=%s`, task.id); + task.done(() => { + this.logger(`Completing id=`, task.id); + remove(this.running, task); + this.schedule(); + }); + } + next() { + const { promise, id } = append(this.pending, createScheduledTask()); + this.logger(`Scheduling id=%s`, id); + this.schedule(); + return promise; + } + }; + } +}); +var apply_patch_exports = {}; +__export2(apply_patch_exports, { + applyPatchTask: () => applyPatchTask +}); +function applyPatchTask(patches, customArgs) { + return straightThroughStringTask(["apply", ...customArgs, ...patches]); +} +var init_apply_patch = __esm({ + "src/lib/tasks/apply-patch.ts"() { + init_task(); + } +}); +function branchDeletionSuccess(branch, hash) { + return { + branch, + hash, + success: true + }; +} +function branchDeletionFailure(branch) { + return { + branch, + hash: null, + success: false + }; +} +var BranchDeletionBatch; +var init_BranchDeleteSummary = __esm({ + "src/lib/responses/BranchDeleteSummary.ts"() { + BranchDeletionBatch = class { + constructor() { + this.all = []; + this.branches = {}; + this.errors = []; + } + get success() { + return !this.errors.length; + } + }; + } +}); +function hasBranchDeletionError(data, processExitCode) { + return processExitCode === 1 && deleteErrorRegex.test(data); +} +var deleteSuccessRegex; +var deleteErrorRegex; +var parsers8; +var parseBranchDeletions; +var init_parse_branch_delete = __esm({ + "src/lib/parsers/parse-branch-delete.ts"() { + init_BranchDeleteSummary(); + init_utils(); + deleteSuccessRegex = /(\S+)\s+\(\S+\s([^)]+)\)/; + deleteErrorRegex = /^error[^']+'([^']+)'/m; + parsers8 = [ + new LineParser(deleteSuccessRegex, (result, [branch, hash]) => { + const deletion = branchDeletionSuccess(branch, hash); + result.all.push(deletion); + result.branches[branch] = deletion; + }), + new LineParser(deleteErrorRegex, (result, [branch]) => { + const deletion = branchDeletionFailure(branch); + result.errors.push(deletion); + result.all.push(deletion); + result.branches[branch] = deletion; + }) + ]; + parseBranchDeletions = (stdOut, stdErr) => { + return parseStringResponse(new BranchDeletionBatch(), parsers8, [stdOut, stdErr]); + }; + } +}); +var BranchSummaryResult; +var init_BranchSummary = __esm({ + "src/lib/responses/BranchSummary.ts"() { + BranchSummaryResult = class { + constructor() { + this.all = []; + this.branches = {}; + this.current = ""; + this.detached = false; + } + push(status, detached, name, commit, label) { + if (status === "*") { + this.detached = detached; + this.current = name; + } + this.all.push(name); + this.branches[name] = { + current: status === "*", + linkedWorkTree: status === "+", + name, + commit, + label + }; + } + }; + } +}); +function branchStatus(input) { + return input ? input.charAt(0) : ""; +} +function parseBranchSummary(stdOut) { + return parseStringResponse(new BranchSummaryResult(), parsers9, stdOut); +} +var parsers9; +var init_parse_branch = __esm({ + "src/lib/parsers/parse-branch.ts"() { + init_BranchSummary(); + init_utils(); + parsers9 = [ + new LineParser(/^([*+]\s)?\((?:HEAD )?detached (?:from|at) (\S+)\)\s+([a-z0-9]+)\s(.*)$/, (result, [current, name, commit, label]) => { + result.push(branchStatus(current), true, name, commit, label); + }), + new LineParser(/^([*+]\s)?(\S+)\s+([a-z0-9]+)\s?(.*)$/s, (result, [current, name, commit, label]) => { + result.push(branchStatus(current), false, name, commit, label); + }) + ]; + } +}); +var branch_exports = {}; +__export2(branch_exports, { + branchLocalTask: () => branchLocalTask, + branchTask: () => branchTask, + containsDeleteBranchCommand: () => containsDeleteBranchCommand, + deleteBranchTask: () => deleteBranchTask, + deleteBranchesTask: () => deleteBranchesTask +}); +function containsDeleteBranchCommand(commands) { + const deleteCommands = ["-d", "-D", "--delete"]; + return commands.some((command) => deleteCommands.includes(command)); +} +function branchTask(customArgs) { + const isDelete = containsDeleteBranchCommand(customArgs); + const commands = ["branch", ...customArgs]; + if (commands.length === 1) { + commands.push("-a"); + } + if (!commands.includes("-v")) { + commands.splice(1, 0, "-v"); + } + return { + format: "utf-8", + commands, + parser(stdOut, stdErr) { + if (isDelete) { + return parseBranchDeletions(stdOut, stdErr).all[0]; + } + return parseBranchSummary(stdOut); + } + }; +} +function branchLocalTask() { + const parser3 = parseBranchSummary; + return { + format: "utf-8", + commands: ["branch", "-v"], + parser: parser3 + }; +} +function deleteBranchesTask(branches, forceDelete = false) { + return { + format: "utf-8", + commands: ["branch", "-v", forceDelete ? "-D" : "-d", ...branches], + parser(stdOut, stdErr) { + return parseBranchDeletions(stdOut, stdErr); + }, + onError({ exitCode, stdOut }, error, done, fail) { + if (!hasBranchDeletionError(String(error), exitCode)) { + return fail(error); + } + done(stdOut); + } + }; +} +function deleteBranchTask(branch, forceDelete = false) { + const task = { + format: "utf-8", + commands: ["branch", "-v", forceDelete ? "-D" : "-d", branch], + parser(stdOut, stdErr) { + return parseBranchDeletions(stdOut, stdErr).branches[branch]; + }, + onError({ exitCode, stdErr, stdOut }, error, _, fail) { + if (!hasBranchDeletionError(String(error), exitCode)) { + return fail(error); + } + throw new GitResponseError(task.parser(bufferToString(stdOut), bufferToString(stdErr)), String(error)); + } + }; + return task; +} +var init_branch = __esm({ + "src/lib/tasks/branch.ts"() { + init_git_response_error(); + init_parse_branch_delete(); + init_parse_branch(); + init_utils(); + } +}); +var parseCheckIgnore; +var init_CheckIgnore = __esm({ + "src/lib/responses/CheckIgnore.ts"() { + parseCheckIgnore = (text) => { + return text.split(/\n/g).map((line) => line.trim()).filter((file) => !!file); + }; + } +}); +var check_ignore_exports = {}; +__export2(check_ignore_exports, { + checkIgnoreTask: () => checkIgnoreTask +}); +function checkIgnoreTask(paths) { + return { + commands: ["check-ignore", ...paths], + format: "utf-8", + parser: parseCheckIgnore + }; +} +var init_check_ignore = __esm({ + "src/lib/tasks/check-ignore.ts"() { + init_CheckIgnore(); + } +}); +var clone_exports = {}; +__export2(clone_exports, { + cloneMirrorTask: () => cloneMirrorTask, + cloneTask: () => cloneTask +}); +function disallowedCommand(command) { + return /^--upload-pack(=|$)/.test(command); +} +function cloneTask(repo, directory, customArgs) { + const commands = ["clone", ...customArgs]; + filterString(repo) && commands.push(repo); + filterString(directory) && commands.push(directory); + const banned = commands.find(disallowedCommand); + if (banned) { + return configurationErrorTask(`git.fetch: potential exploit argument blocked.`); + } + return straightThroughStringTask(commands); +} +function cloneMirrorTask(repo, directory, customArgs) { + append(customArgs, "--mirror"); + return cloneTask(repo, directory, customArgs); +} +var init_clone = __esm({ + "src/lib/tasks/clone.ts"() { + init_task(); + init_utils(); + } +}); +function parseFetchResult(stdOut, stdErr) { + const result = { + raw: stdOut, + remote: null, + branches: [], + tags: [], + updated: [], + deleted: [] + }; + return parseStringResponse(result, parsers10, [stdOut, stdErr]); +} +var parsers10; +var init_parse_fetch = __esm({ + "src/lib/parsers/parse-fetch.ts"() { + init_utils(); + parsers10 = [ + new LineParser(/From (.+)$/, (result, [remote]) => { + result.remote = remote; + }), + new LineParser(/\* \[new branch]\s+(\S+)\s*-> (.+)$/, (result, [name, tracking]) => { + result.branches.push({ + name, + tracking + }); + }), + new LineParser(/\* \[new tag]\s+(\S+)\s*-> (.+)$/, (result, [name, tracking]) => { + result.tags.push({ + name, + tracking + }); + }), + new LineParser(/- \[deleted]\s+\S+\s*-> (.+)$/, (result, [tracking]) => { + result.deleted.push({ + tracking + }); + }), + new LineParser(/\s*([^.]+)\.\.(\S+)\s+(\S+)\s*-> (.+)$/, (result, [from, to, name, tracking]) => { + result.updated.push({ + name, + tracking, + to, + from + }); + }) + ]; + } +}); +var fetch_exports = {}; +__export2(fetch_exports, { + fetchTask: () => fetchTask +}); +function disallowedCommand2(command) { + return /^--upload-pack(=|$)/.test(command); +} +function fetchTask(remote, branch, customArgs) { + const commands = ["fetch", ...customArgs]; + if (remote && branch) { + commands.push(remote, branch); + } + const banned = commands.find(disallowedCommand2); + if (banned) { + return configurationErrorTask(`git.fetch: potential exploit argument blocked.`); + } + return { + commands, + format: "utf-8", + parser: parseFetchResult + }; +} +var init_fetch = __esm({ + "src/lib/tasks/fetch.ts"() { + init_parse_fetch(); + init_task(); + } +}); +function parseMoveResult(stdOut) { + return parseStringResponse({ moves: [] }, parsers11, stdOut); +} +var parsers11; +var init_parse_move = __esm({ + "src/lib/parsers/parse-move.ts"() { + init_utils(); + parsers11 = [ + new LineParser(/^Renaming (.+) to (.+)$/, (result, [from, to]) => { + result.moves.push({ from, to }); + }) + ]; + } +}); +var move_exports = {}; +__export2(move_exports, { + moveTask: () => moveTask +}); +function moveTask(from, to) { + return { + commands: ["mv", "-v", ...asArray(from), to], + format: "utf-8", + parser: parseMoveResult + }; +} +var init_move = __esm({ + "src/lib/tasks/move.ts"() { + init_parse_move(); + init_utils(); + } +}); +var pull_exports = {}; +__export2(pull_exports, { + pullTask: () => pullTask +}); +function pullTask(remote, branch, customArgs) { + const commands = ["pull", ...customArgs]; + if (remote && branch) { + commands.splice(1, 0, remote, branch); + } + return { + commands, + format: "utf-8", + parser(stdOut, stdErr) { + return parsePullResult(stdOut, stdErr); + }, + onError(result, _error, _done, fail) { + const pullError = parsePullErrorResult(bufferToString(result.stdOut), bufferToString(result.stdErr)); + if (pullError) { + return fail(new GitResponseError(pullError)); + } + fail(_error); + } + }; +} +var init_pull = __esm({ + "src/lib/tasks/pull.ts"() { + init_git_response_error(); + init_parse_pull(); + init_utils(); + } +}); +function parseGetRemotes(text) { + const remotes = {}; + forEach(text, ([name]) => remotes[name] = { name }); + return Object.values(remotes); +} +function parseGetRemotesVerbose(text) { + const remotes = {}; + forEach(text, ([name, url, purpose]) => { + if (!remotes.hasOwnProperty(name)) { + remotes[name] = { + name, + refs: { fetch: "", push: "" } + }; + } + if (purpose && url) { + remotes[name].refs[purpose.replace(/[^a-z]/g, "")] = url; + } + }); + return Object.values(remotes); +} +function forEach(text, handler) { + forEachLineWithContent(text, (line) => handler(line.split(/\s+/))); +} +var init_GetRemoteSummary = __esm({ + "src/lib/responses/GetRemoteSummary.ts"() { + init_utils(); + } +}); +var remote_exports = {}; +__export2(remote_exports, { + addRemoteTask: () => addRemoteTask, + getRemotesTask: () => getRemotesTask, + listRemotesTask: () => listRemotesTask, + remoteTask: () => remoteTask, + removeRemoteTask: () => removeRemoteTask +}); +function addRemoteTask(remoteName, remoteRepo, customArgs = []) { + return straightThroughStringTask(["remote", "add", ...customArgs, remoteName, remoteRepo]); +} +function getRemotesTask(verbose) { + const commands = ["remote"]; + if (verbose) { + commands.push("-v"); + } + return { + commands, + format: "utf-8", + parser: verbose ? parseGetRemotesVerbose : parseGetRemotes + }; +} +function listRemotesTask(customArgs = []) { + const commands = [...customArgs]; + if (commands[0] !== "ls-remote") { + commands.unshift("ls-remote"); + } + return straightThroughStringTask(commands); +} +function remoteTask(customArgs = []) { + const commands = [...customArgs]; + if (commands[0] !== "remote") { + commands.unshift("remote"); + } + return straightThroughStringTask(commands); +} +function removeRemoteTask(remoteName) { + return straightThroughStringTask(["remote", "remove", remoteName]); +} +var init_remote = __esm({ + "src/lib/tasks/remote.ts"() { + init_GetRemoteSummary(); + init_task(); + } +}); +var stash_list_exports = {}; +__export2(stash_list_exports, { + stashListTask: () => stashListTask +}); +function stashListTask(opt = {}, customArgs) { + const options = parseLogOptions(opt); + const commands = ["stash", "list", ...options.commands, ...customArgs]; + const parser3 = createListLogSummaryParser(options.splitter, options.fields, logFormatFromCommand(commands)); + return validateLogFormatConfig(commands) || { + commands, + format: "utf-8", + parser: parser3 + }; +} +var init_stash_list = __esm({ + "src/lib/tasks/stash-list.ts"() { + init_log_format(); + init_parse_list_log_summary(); + init_diff(); + init_log(); + } +}); +var sub_module_exports = {}; +__export2(sub_module_exports, { + addSubModuleTask: () => addSubModuleTask, + initSubModuleTask: () => initSubModuleTask, + subModuleTask: () => subModuleTask, + updateSubModuleTask: () => updateSubModuleTask +}); +function addSubModuleTask(repo, path) { + return subModuleTask(["add", repo, path]); +} +function initSubModuleTask(customArgs) { + return subModuleTask(["init", ...customArgs]); +} +function subModuleTask(customArgs) { + const commands = [...customArgs]; + if (commands[0] !== "submodule") { + commands.unshift("submodule"); + } + return straightThroughStringTask(commands); +} +function updateSubModuleTask(customArgs) { + return subModuleTask(["update", ...customArgs]); +} +var init_sub_module = __esm({ + "src/lib/tasks/sub-module.ts"() { + init_task(); + } +}); +function singleSorted(a, b) { + const aIsNum = isNaN(a); + const bIsNum = isNaN(b); + if (aIsNum !== bIsNum) { + return aIsNum ? 1 : -1; + } + return aIsNum ? sorted(a, b) : 0; +} +function sorted(a, b) { + return a === b ? 0 : a > b ? 1 : -1; +} +function trimmed(input) { + return input.trim(); +} +function toNumber(input) { + if (typeof input === "string") { + return parseInt(input.replace(/^\D+/g, ""), 10) || 0; + } + return 0; +} +var TagList; +var parseTagList; +var init_TagList = __esm({ + "src/lib/responses/TagList.ts"() { + TagList = class { + constructor(all, latest) { + this.all = all; + this.latest = latest; + } + }; + parseTagList = function(data, customSort = false) { + const tags = data.split("\n").map(trimmed).filter(Boolean); + if (!customSort) { + tags.sort(function(tagA, tagB) { + const partsA = tagA.split("."); + const partsB = tagB.split("."); + if (partsA.length === 1 || partsB.length === 1) { + return singleSorted(toNumber(partsA[0]), toNumber(partsB[0])); + } + for (let i = 0, l = Math.max(partsA.length, partsB.length); i < l; i++) { + const diff = sorted(toNumber(partsA[i]), toNumber(partsB[i])); + if (diff) { + return diff; + } + } + return 0; + }); + } + const latest = customSort ? tags[0] : [...tags].reverse().find((tag) => tag.indexOf(".") >= 0); + return new TagList(tags, latest); + }; + } +}); +var tag_exports = {}; +__export2(tag_exports, { + addAnnotatedTagTask: () => addAnnotatedTagTask, + addTagTask: () => addTagTask, + tagListTask: () => tagListTask +}); +function tagListTask(customArgs = []) { + const hasCustomSort = customArgs.some((option) => /^--sort=/.test(option)); + return { + format: "utf-8", + commands: ["tag", "-l", ...customArgs], + parser(text) { + return parseTagList(text, hasCustomSort); + } + }; +} +function addTagTask(name) { + return { + format: "utf-8", + commands: ["tag", name], + parser() { + return { name }; + } + }; +} +function addAnnotatedTagTask(name, tagMessage) { + return { + format: "utf-8", + commands: ["tag", "-a", "-m", tagMessage, name], + parser() { + return { name }; + } + }; +} +var init_tag = __esm({ + "src/lib/tasks/tag.ts"() { + init_TagList(); + } +}); +var require_git = __commonJS2({ + "src/git.js"(exports, module2) { + var { GitExecutor: GitExecutor2 } = (init_git_executor(), __toCommonJS2(git_executor_exports)); + var { SimpleGitApi: SimpleGitApi2 } = (init_simple_git_api(), __toCommonJS2(simple_git_api_exports)); + var { Scheduler: Scheduler2 } = (init_scheduler(), __toCommonJS2(scheduler_exports)); + var { configurationErrorTask: configurationErrorTask2 } = (init_task(), __toCommonJS2(task_exports)); + var { + asArray: asArray2, + filterArray: filterArray2, + filterPrimitives: filterPrimitives2, + filterString: filterString2, + filterStringOrStringArray: filterStringOrStringArray2, + filterType: filterType2, + getTrailingOptions: getTrailingOptions2, + trailingFunctionArgument: trailingFunctionArgument2, + trailingOptionsArgument: trailingOptionsArgument2 + } = (init_utils(), __toCommonJS2(utils_exports)); + var { applyPatchTask: applyPatchTask2 } = (init_apply_patch(), __toCommonJS2(apply_patch_exports)); + var { + branchTask: branchTask2, + branchLocalTask: branchLocalTask2, + deleteBranchesTask: deleteBranchesTask2, + deleteBranchTask: deleteBranchTask2 + } = (init_branch(), __toCommonJS2(branch_exports)); + var { checkIgnoreTask: checkIgnoreTask2 } = (init_check_ignore(), __toCommonJS2(check_ignore_exports)); + var { checkIsRepoTask: checkIsRepoTask2 } = (init_check_is_repo(), __toCommonJS2(check_is_repo_exports)); + var { cloneTask: cloneTask2, cloneMirrorTask: cloneMirrorTask2 } = (init_clone(), __toCommonJS2(clone_exports)); + var { cleanWithOptionsTask: cleanWithOptionsTask2, isCleanOptionsArray: isCleanOptionsArray2 } = (init_clean(), __toCommonJS2(clean_exports)); + var { diffSummaryTask: diffSummaryTask2 } = (init_diff(), __toCommonJS2(diff_exports)); + var { fetchTask: fetchTask2 } = (init_fetch(), __toCommonJS2(fetch_exports)); + var { moveTask: moveTask2 } = (init_move(), __toCommonJS2(move_exports)); + var { pullTask: pullTask2 } = (init_pull(), __toCommonJS2(pull_exports)); + var { pushTagsTask: pushTagsTask2 } = (init_push(), __toCommonJS2(push_exports)); + var { + addRemoteTask: addRemoteTask2, + getRemotesTask: getRemotesTask2, + listRemotesTask: listRemotesTask2, + remoteTask: remoteTask2, + removeRemoteTask: removeRemoteTask2 + } = (init_remote(), __toCommonJS2(remote_exports)); + var { getResetMode: getResetMode2, resetTask: resetTask2 } = (init_reset(), __toCommonJS2(reset_exports)); + var { stashListTask: stashListTask2 } = (init_stash_list(), __toCommonJS2(stash_list_exports)); + var { + addSubModuleTask: addSubModuleTask2, + initSubModuleTask: initSubModuleTask2, + subModuleTask: subModuleTask2, + updateSubModuleTask: updateSubModuleTask2 + } = (init_sub_module(), __toCommonJS2(sub_module_exports)); + var { addAnnotatedTagTask: addAnnotatedTagTask2, addTagTask: addTagTask2, tagListTask: tagListTask2 } = (init_tag(), __toCommonJS2(tag_exports)); + var { straightThroughBufferTask: straightThroughBufferTask2, straightThroughStringTask: straightThroughStringTask2 } = (init_task(), __toCommonJS2(task_exports)); + function Git2(options, plugins) { + this._executor = new GitExecutor2(options.binary, options.baseDir, new Scheduler2(options.maxConcurrentProcesses), plugins); + this._trimmed = options.trimmed; + } + (Git2.prototype = Object.create(SimpleGitApi2.prototype)).constructor = Git2; + Git2.prototype.customBinary = function(command) { + this._executor.binary = command; + return this; + }; + Git2.prototype.env = function(name, value) { + if (arguments.length === 1 && typeof name === "object") { + this._executor.env = name; + } else { + (this._executor.env = this._executor.env || {})[name] = value; + } + return this; + }; + Git2.prototype.stashList = function(options) { + return this._runTask(stashListTask2(trailingOptionsArgument2(arguments) || {}, filterArray2(options) && options || []), trailingFunctionArgument2(arguments)); + }; + function createCloneTask(api, task, repoPath, localPath) { + if (typeof repoPath !== "string") { + return configurationErrorTask2(`git.${api}() requires a string 'repoPath'`); + } + return task(repoPath, filterType2(localPath, filterString2), getTrailingOptions2(arguments)); + } + Git2.prototype.clone = function() { + return this._runTask(createCloneTask("clone", cloneTask2, ...arguments), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.mirror = function() { + return this._runTask(createCloneTask("mirror", cloneMirrorTask2, ...arguments), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.mv = function(from, to) { + return this._runTask(moveTask2(from, to), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.checkoutLatestTag = function(then) { + var git = this; + return this.pull(function() { + git.tags(function(err, tags) { + git.checkout(tags.latest, then); + }); + }); + }; + Git2.prototype.pull = function(remote, branch, options, then) { + return this._runTask(pullTask2(filterType2(remote, filterString2), filterType2(branch, filterString2), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.fetch = function(remote, branch) { + return this._runTask(fetchTask2(filterType2(remote, filterString2), filterType2(branch, filterString2), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.silent = function(silence) { + console.warn("simple-git deprecation notice: git.silent: logging should be configured using the `debug` library / `DEBUG` environment variable, this will be an error in version 3"); + return this; + }; + Git2.prototype.tags = function(options, then) { + return this._runTask(tagListTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.rebase = function() { + return this._runTask(straightThroughStringTask2(["rebase", ...getTrailingOptions2(arguments)]), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.reset = function(mode) { + return this._runTask(resetTask2(getResetMode2(mode), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.revert = function(commit) { + const next = trailingFunctionArgument2(arguments); + if (typeof commit !== "string") { + return this._runTask(configurationErrorTask2("Commit must be a string"), next); + } + return this._runTask(straightThroughStringTask2(["revert", ...getTrailingOptions2(arguments, 0, true), commit]), next); + }; + Git2.prototype.addTag = function(name) { + const task = typeof name === "string" ? addTagTask2(name) : configurationErrorTask2("Git.addTag requires a tag name"); + return this._runTask(task, trailingFunctionArgument2(arguments)); + }; + Git2.prototype.addAnnotatedTag = function(tagName, tagMessage) { + return this._runTask(addAnnotatedTagTask2(tagName, tagMessage), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.deleteLocalBranch = function(branchName, forceDelete, then) { + return this._runTask(deleteBranchTask2(branchName, typeof forceDelete === "boolean" ? forceDelete : false), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.deleteLocalBranches = function(branchNames, forceDelete, then) { + return this._runTask(deleteBranchesTask2(branchNames, typeof forceDelete === "boolean" ? forceDelete : false), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.branch = function(options, then) { + return this._runTask(branchTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.branchLocal = function(then) { + return this._runTask(branchLocalTask2(), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.raw = function(commands) { + const createRestCommands = !Array.isArray(commands); + const command = [].slice.call(createRestCommands ? arguments : commands, 0); + for (let i = 0; i < command.length && createRestCommands; i++) { + if (!filterPrimitives2(command[i])) { + command.splice(i, command.length - i); + break; + } + } + command.push(...getTrailingOptions2(arguments, 0, true)); + var next = trailingFunctionArgument2(arguments); + if (!command.length) { + return this._runTask(configurationErrorTask2("Raw: must supply one or more command to execute"), next); + } + return this._runTask(straightThroughStringTask2(command, this._trimmed), next); + }; + Git2.prototype.submoduleAdd = function(repo, path, then) { + return this._runTask(addSubModuleTask2(repo, path), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.submoduleUpdate = function(args, then) { + return this._runTask(updateSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.submoduleInit = function(args, then) { + return this._runTask(initSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.subModule = function(options, then) { + return this._runTask(subModuleTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.listRemote = function() { + return this._runTask(listRemotesTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.addRemote = function(remoteName, remoteRepo, then) { + return this._runTask(addRemoteTask2(remoteName, remoteRepo, getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.removeRemote = function(remoteName, then) { + return this._runTask(removeRemoteTask2(remoteName), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.getRemotes = function(verbose, then) { + return this._runTask(getRemotesTask2(verbose === true), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.remote = function(options, then) { + return this._runTask(remoteTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.tag = function(options, then) { + const command = getTrailingOptions2(arguments); + if (command[0] !== "tag") { + command.unshift("tag"); + } + return this._runTask(straightThroughStringTask2(command), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.updateServerInfo = function(then) { + return this._runTask(straightThroughStringTask2(["update-server-info"]), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.pushTags = function(remote, then) { + const task = pushTagsTask2({ remote: filterType2(remote, filterString2) }, getTrailingOptions2(arguments)); + return this._runTask(task, trailingFunctionArgument2(arguments)); + }; + Git2.prototype.rm = function(files) { + return this._runTask(straightThroughStringTask2(["rm", "-f", ...asArray2(files)]), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.rmKeepLocal = function(files) { + return this._runTask(straightThroughStringTask2(["rm", "--cached", ...asArray2(files)]), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.catFile = function(options, then) { + return this._catFile("utf-8", arguments); + }; + Git2.prototype.binaryCatFile = function() { + return this._catFile("buffer", arguments); + }; + Git2.prototype._catFile = function(format, args) { + var handler = trailingFunctionArgument2(args); + var command = ["cat-file"]; + var options = args[0]; + if (typeof options === "string") { + return this._runTask(configurationErrorTask2("Git.catFile: options must be supplied as an array of strings"), handler); + } + if (Array.isArray(options)) { + command.push.apply(command, options); + } + const task = format === "buffer" ? straightThroughBufferTask2(command) : straightThroughStringTask2(command); + return this._runTask(task, handler); + }; + Git2.prototype.diff = function(options, then) { + const task = filterString2(options) ? configurationErrorTask2("git.diff: supplying options as a single string is no longer supported, switch to an array of strings") : straightThroughStringTask2(["diff", ...getTrailingOptions2(arguments)]); + return this._runTask(task, trailingFunctionArgument2(arguments)); + }; + Git2.prototype.diffSummary = function() { + return this._runTask(diffSummaryTask2(getTrailingOptions2(arguments, 1)), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.applyPatch = function(patches) { + const task = !filterStringOrStringArray2(patches) ? configurationErrorTask2(`git.applyPatch requires one or more string patches as the first argument`) : applyPatchTask2(asArray2(patches), getTrailingOptions2([].slice.call(arguments, 1))); + return this._runTask(task, trailingFunctionArgument2(arguments)); + }; + Git2.prototype.revparse = function() { + const commands = ["rev-parse", ...getTrailingOptions2(arguments, true)]; + return this._runTask(straightThroughStringTask2(commands, true), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.clean = function(mode, options, then) { + const usingCleanOptionsArray = isCleanOptionsArray2(mode); + const cleanMode = usingCleanOptionsArray && mode.join("") || filterType2(mode, filterString2) || ""; + const customArgs = getTrailingOptions2([].slice.call(arguments, usingCleanOptionsArray ? 1 : 0)); + return this._runTask(cleanWithOptionsTask2(cleanMode, customArgs), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.exec = function(then) { + const task = { + commands: [], + format: "utf-8", + parser() { + if (typeof then === "function") { + then(); + } + } + }; + return this._runTask(task); + }; + Git2.prototype.clearQueue = function() { + return this; + }; + Git2.prototype.checkIgnore = function(pathnames, then) { + return this._runTask(checkIgnoreTask2(asArray2(filterType2(pathnames, filterStringOrStringArray2, []))), trailingFunctionArgument2(arguments)); + }; + Git2.prototype.checkIsRepo = function(checkType, then) { + return this._runTask(checkIsRepoTask2(filterType2(checkType, filterString2)), trailingFunctionArgument2(arguments)); + }; + module2.exports = Git2; + } +}); +init_pathspec(); +init_git_error(); +var GitConstructError = class extends GitError { + constructor(config, message) { + super(void 0, message); + this.config = config; + } +}; +init_git_error(); +init_git_error(); +var GitPluginError = class extends GitError { + constructor(task, plugin, message) { + super(task, message); + this.task = task; + this.plugin = plugin; + Object.setPrototypeOf(this, new.target.prototype); + } +}; +init_git_response_error(); +init_task_configuration_error(); +init_check_is_repo(); +init_clean(); +init_config(); +init_diff_name_status(); +init_grep(); +init_reset(); +function abortPlugin(signal) { + if (!signal) { + return; + } + const onSpawnAfter = { + type: "spawn.after", + action(_data, context) { + function kill() { + context.kill(new GitPluginError(void 0, "abort", "Abort signal received")); + } + signal.addEventListener("abort", kill); + context.spawned.on("close", () => signal.removeEventListener("abort", kill)); + } + }; + const onSpawnBefore = { + type: "spawn.before", + action(_data, context) { + if (signal.aborted) { + context.kill(new GitPluginError(void 0, "abort", "Abort already signaled")); + } + } + }; + return [onSpawnBefore, onSpawnAfter]; +} +function isConfigSwitch(arg) { + return typeof arg === "string" && arg.trim().toLowerCase() === "-c"; +} +function preventProtocolOverride(arg, next) { + if (!isConfigSwitch(arg)) { + return; + } + if (!/^\s*protocol(.[a-z]+)?.allow/.test(next)) { + return; + } + throw new GitPluginError(void 0, "unsafe", "Configuring protocol.allow is not permitted without enabling allowUnsafeExtProtocol"); +} +function preventUploadPack(arg, method) { + if (/^\s*--(upload|receive)-pack/.test(arg)) { + throw new GitPluginError(void 0, "unsafe", `Use of --upload-pack or --receive-pack is not permitted without enabling allowUnsafePack`); + } + if (method === "clone" && /^\s*-u\b/.test(arg)) { + throw new GitPluginError(void 0, "unsafe", `Use of clone with option -u is not permitted without enabling allowUnsafePack`); + } + if (method === "push" && /^\s*--exec\b/.test(arg)) { + throw new GitPluginError(void 0, "unsafe", `Use of push with option --exec is not permitted without enabling allowUnsafePack`); + } +} +function blockUnsafeOperationsPlugin({ + allowUnsafeProtocolOverride = false, + allowUnsafePack = false +} = {}) { + return { + type: "spawn.args", + action(args, context) { + args.forEach((current, index) => { + const next = index < args.length ? args[index + 1] : ""; + allowUnsafeProtocolOverride || preventProtocolOverride(current, next); + allowUnsafePack || preventUploadPack(current, context.method); + }); + return args; + } + }; +} +init_utils(); +function commandConfigPrefixingPlugin(configuration) { + const prefix = prefixedArray(configuration, "-c"); + return { + type: "spawn.args", + action(data) { + return [...prefix, ...data]; + } + }; +} +init_utils(); +var never = (0, import_promise_deferred2.deferred)().promise; +function completionDetectionPlugin({ + onClose = true, + onExit = 50 +} = {}) { + function createEvents() { + let exitCode = -1; + const events = { + close: (0, import_promise_deferred2.deferred)(), + closeTimeout: (0, import_promise_deferred2.deferred)(), + exit: (0, import_promise_deferred2.deferred)(), + exitTimeout: (0, import_promise_deferred2.deferred)() + }; + const result = Promise.race([ + onClose === false ? never : events.closeTimeout.promise, + onExit === false ? never : events.exitTimeout.promise + ]); + configureTimeout(onClose, events.close, events.closeTimeout); + configureTimeout(onExit, events.exit, events.exitTimeout); + return { + close(code) { + exitCode = code; + events.close.done(); + }, + exit(code) { + exitCode = code; + events.exit.done(); + }, + get exitCode() { + return exitCode; + }, + result + }; + } + function configureTimeout(flag, event, timeout) { + if (flag === false) { + return; + } + (flag === true ? event.promise : event.promise.then(() => delay(flag))).then(timeout.done); + } + return { + type: "spawn.after", + action(_0, _1) { + return __async(this, arguments, function* (_data, { spawned, close }) { + var _a2, _b; + const events = createEvents(); + let deferClose = true; + let quickClose = () => void (deferClose = false); + (_a2 = spawned.stdout) == null ? void 0 : _a2.on("data", quickClose); + (_b = spawned.stderr) == null ? void 0 : _b.on("data", quickClose); + spawned.on("error", quickClose); + spawned.on("close", (code) => events.close(code)); + spawned.on("exit", (code) => events.exit(code)); + try { + yield events.result; + if (deferClose) { + yield delay(50); + } + close(events.exitCode); + } catch (err) { + close(events.exitCode, err); + } + }); + } + }; +} +init_git_error(); +function isTaskError(result) { + return !!(result.exitCode && result.stdErr.length); +} +function getErrorMessage(result) { + return Buffer.concat([...result.stdOut, ...result.stdErr]); +} +function errorDetectionHandler(overwrite = false, isError = isTaskError, errorMessage = getErrorMessage) { + return (error, result) => { + if (!overwrite && error || !isError(result)) { + return error; + } + return errorMessage(result); + }; +} +function errorDetectionPlugin(config) { + return { + type: "task.error", + action(data, context) { + const error = config(data.error, { + stdErr: context.stdErr, + stdOut: context.stdOut, + exitCode: context.exitCode + }); + if (Buffer.isBuffer(error)) { + return { error: new GitError(void 0, error.toString("utf-8")) }; + } + return { + error + }; + } + }; +} +init_utils(); +var PluginStore = class { + constructor() { + this.plugins = /* @__PURE__ */ new Set(); + } + add(plugin) { + const plugins = []; + asArray(plugin).forEach((plugin2) => plugin2 && this.plugins.add(append(plugins, plugin2))); + return () => { + plugins.forEach((plugin2) => this.plugins.delete(plugin2)); + }; + } + exec(type, data, context) { + let output = data; + const contextual = Object.freeze(Object.create(context)); + for (const plugin of this.plugins) { + if (plugin.type === type) { + output = plugin.action(output, contextual); + } + } + return output; + } +}; +init_utils(); +function progressMonitorPlugin(progress) { + const progressCommand = "--progress"; + const progressMethods = ["checkout", "clone", "fetch", "pull", "push"]; + const onProgress = { + type: "spawn.after", + action(_data, context) { + var _a2; + if (!context.commands.includes(progressCommand)) { + return; + } + (_a2 = context.spawned.stderr) == null ? void 0 : _a2.on("data", (chunk) => { + const message = /^([\s\S]+?):\s*(\d+)% \((\d+)\/(\d+)\)/.exec(chunk.toString("utf8")); + if (!message) { + return; + } + progress({ + method: context.method, + stage: progressEventStage(message[1]), + progress: asNumber(message[2]), + processed: asNumber(message[3]), + total: asNumber(message[4]) + }); + }); + } + }; + const onArgs = { + type: "spawn.args", + action(args, context) { + if (!progressMethods.includes(context.method)) { + return args; + } + return including(args, progressCommand); + } + }; + return [onArgs, onProgress]; +} +function progressEventStage(input) { + return String(input.toLowerCase().split(" ", 1)) || "unknown"; +} +init_utils(); +function spawnOptionsPlugin(spawnOptions) { + const options = pick(spawnOptions, ["uid", "gid"]); + return { + type: "spawn.options", + action(data) { + return __spreadValues(__spreadValues({}, options), data); + } + }; +} +function timeoutPlugin({ + block, + stdErr = true, + stdOut = true +}) { + if (block > 0) { + return { + type: "spawn.after", + action(_data, context) { + var _a2, _b; + let timeout; + function wait() { + timeout && clearTimeout(timeout); + timeout = setTimeout(kill, block); + } + function stop() { + var _a3, _b2; + (_a3 = context.spawned.stdout) == null ? void 0 : _a3.off("data", wait); + (_b2 = context.spawned.stderr) == null ? void 0 : _b2.off("data", wait); + context.spawned.off("exit", stop); + context.spawned.off("close", stop); + timeout && clearTimeout(timeout); + } + function kill() { + stop(); + context.kill(new GitPluginError(void 0, "timeout", `block timeout reached`)); + } + stdOut && ((_a2 = context.spawned.stdout) == null ? void 0 : _a2.on("data", wait)); + stdErr && ((_b = context.spawned.stderr) == null ? void 0 : _b.on("data", wait)); + context.spawned.on("exit", stop); + context.spawned.on("close", stop); + wait(); + } + }; + } +} +init_pathspec(); +function suffixPathsPlugin() { + return { + type: "spawn.args", + action(data) { + const prefix = []; + let suffix; + function append2(args) { + (suffix = suffix || []).push(...args); + } + for (let i = 0; i < data.length; i++) { + const param = data[i]; + if (isPathSpec(param)) { + append2(toPaths(param)); + continue; + } + if (param === "--") { + append2(data.slice(i + 1).flatMap((item) => isPathSpec(item) && toPaths(item) || item)); + break; + } + prefix.push(param); + } + return !suffix ? prefix : [...prefix, "--", ...suffix.map(String)]; + } + }; +} +init_utils(); +var Git = require_git(); +function gitInstanceFactory(baseDir, options) { + const plugins = new PluginStore(); + const config = createInstanceConfig(baseDir && (typeof baseDir === "string" ? { baseDir } : baseDir) || {}, options); + if (!folderExists(config.baseDir)) { + throw new GitConstructError(config, `Cannot use simple-git on a directory that does not exist`); + } + if (Array.isArray(config.config)) { + plugins.add(commandConfigPrefixingPlugin(config.config)); + } + plugins.add(blockUnsafeOperationsPlugin(config.unsafe)); + plugins.add(suffixPathsPlugin()); + plugins.add(completionDetectionPlugin(config.completion)); + config.abort && plugins.add(abortPlugin(config.abort)); + config.progress && plugins.add(progressMonitorPlugin(config.progress)); + config.timeout && plugins.add(timeoutPlugin(config.timeout)); + config.spawnOptions && plugins.add(spawnOptionsPlugin(config.spawnOptions)); + plugins.add(errorDetectionPlugin(errorDetectionHandler(true))); + config.errors && plugins.add(errorDetectionPlugin(config.errors)); + return new Git(config, plugins); +} +init_git_response_error(); +var esm_default = gitInstanceFactory; + +// src/services/gitService.ts +var DEFAULT_REMOTE = "origin"; +var CURRENT_TIME = () => (0, import_dayjs.default)().format("YYYY-MM-DDTHH:mm"); +var COMMIT_MESSAGE = (deviceName) => `chore: vault backup from ${deviceName} at ${CURRENT_TIME()}`; +var SimpleGitService = class { + constructor(repoPath, settings) { + this.settings = settings; + __publicField(this, "gitProvider"); + logger_default.debug("Initializing SimpleGitService..."); + this.gitProvider = esm_default(repoPath); + logger_default.debug("SimpleGitService initialized."); + } + async gitCommit(message = COMMIT_MESSAGE(this.settings.deviceName)) { + logger_default.info(`Committing... ${message}`); + await this.gitProvider.commit(message); + } + async gitPullWithRebase() { + await this.gitProvider.pull(["--rebase"]); + } + async gitPull(branch = this.settings.branchName) { + await this.gitProvider.pull(DEFAULT_REMOTE, branch, ["--rebase"]); + } + async gitPushUpstream(branch = this.settings.branchName) { + await this.gitProvider.push(DEFAULT_REMOTE, branch, [ + "--set-upstream", + "--force" + ]); + logger_default.info(`Pushed branch upstream to ${DEFAULT_REMOTE}/${branch}.`); + } + async gitPush(forcePush = false, branch = this.settings.branchName) { + const options = forcePush ? ["-f"] : []; + await this.gitProvider.push(DEFAULT_REMOTE, branch, options); + logger_default.info(`Pushed changes to ${DEFAULT_REMOTE}/${branch}.`); + } + async gitStage(...files) { + await Promise.all(files.map((file) => this.gitProvider.add(file))); + } + async gitStageAll() { + await this.gitProvider.add("./*"); + } + async isLocalAhead() { + return this.gitProvider.status().then((status) => status.ahead > 0); + } + async isRebasing() { + return this.gitProvider.raw(["status"]).then((status) => status.includes("rebase")); + } + async isRemoteConfigured() { + let remoteConfigured = false; + try { + const remotes = await this.gitProvider.listRemote(["--get-url"]); + remoteConfigured = !!remotes; + } catch (e) { + remoteConfigured = false; + } + return remoteConfigured; + } + async isRepo() { + return this.gitProvider.checkIsRepo(); + } + async getConflictingFiles() { + return this.gitProvider.status().then((status) => status.conflicted); + } + async stopRebasing() { + process.env.GIT_EDITOR = "true"; + await this.gitStageAll(); + await this.gitProvider.rebase(["--continue"]); + await this.gitPush(); + process.env.GIT_EDITOR = void 0; + } + async unstagedChangesExist() { + return this.gitProvider.status().then( + (status) => status.files.length > 0 || status.not_added.length > 0 + ); + } +}; + +// src/services/gitignoreService.ts +var import_path = require("path"); +var GITIGNORE_FILE_NAME = ".gitignore"; +var GitignoreService = class { + constructor(basePath, gitService) { + this.gitService = gitService; + __publicField(this, "gitignorePath"); + logger_default.debug("Initializing GitignoreService..."); + this.gitignorePath = (0, import_path.resolve)(basePath, GITIGNORE_FILE_NAME); + logger_default.debug("GitignoreService initialized."); + } + async stageCommitAndPushGitignore(message) { + await this.gitService.gitStage(GITIGNORE_FILE_NAME); + await this.gitService.gitCommit(message); + await this.gitService.gitPush(); + } +}; + +// src/views/modals/unmergedFilesView.ts +var import_obsidian3 = require("obsidian"); +var UnmergedFilesView = class extends import_obsidian3.Modal { + constructor(app, gitService) { + super(app); + this.gitService = gitService; + } + onOpen() { + var _a2; + this.contentEl.empty(); + this.contentEl.createEl("h3", { + text: "Loading...", + cls: "sync-title" + }); + (_a2 = this.gitService) == null ? void 0 : _a2.getConflictingFiles().then((files) => { + this.contentEl.empty(); + if (files.length > 0) { + this.contentEl.createEl("h3", { + text: "Please resolve the conflicts in the following files:", + cls: "sync-title" + }); + const list = this.contentEl.createEl("ul"); + files.forEach( + (file) => list.createEl("li").createEl("strong", { + text: file, + cls: "sync-conflicting-files" + }) + ); + } else { + this.contentEl.createEl("h3", { + text: "No unmerged files to show!", + cls: "sync-title" + }); + } + }); + } + onClose() { + this.contentEl.empty(); + } +}; + +// src/views/settingsTab.ts +var import_obsidian4 = require("obsidian"); +var import_os = __toESM(require("os")); +var GITHUB_ISSUE_LINK = "https://github.com/adapole/cicada-sync/issues/new/choose"; +var SAMPLE_REPO = "git@github.com:adapole/obsidian-yaos.git"; +var DEFAULT_YAOS_SETTINGS = { + deviceName: import_os.default.hostname(), + remoteRepo: SAMPLE_REPO, + basePath: __dirname, + branchName: "main", + syncImages: false, + syncAudio: false, + syncVideos: false, + syncPdfs: false, + syncOtherFiles: false, + syncMainSettings: false, + syncAppearanceSettings: false, + syncThemesAndSnippets: false, + syncHotkeys: false, + syncCorePluginSettings: false, + syncCommunityPluginSettings: false +}; +var YaosSettingTab = class extends import_obsidian4.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + __publicField(this, "plugin"); + __publicField(this, "gitProvider"); + this.plugin = plugin; + this.gitProvider = esm_default(); + } + display() { + const { containerEl } = this; + containerEl.empty(); + this.addGeneralSection(containerEl); + this.addGitSetup(containerEl); + } + addGeneralSection(containerEl) { + new import_obsidian4.Setting(containerEl).setName("General").setHeading(); + this.addDeviceNameSetting(containerEl); + this.addCreateIssueSetting(containerEl); + } + addGitSetup(containerEl) { + new import_obsidian4.Setting(containerEl).setName("Setup Git").setHeading(); + this.addBranchName(containerEl); + this.addRemoteRepoURL(containerEl); + } + addDeviceNameSetting(el) { + new import_obsidian4.Setting(el).setName("Device name").setDesc( + "This name will be displayed in the commit messages to indicate the sync source. Leave empty to use the default name." + ).addText( + (text) => text.setPlaceholder(DEFAULT_YAOS_SETTINGS.deviceName).setValue(this.plugin.settings.deviceName).onChange(async (deviceName) => { + this.plugin.settings.deviceName = deviceName; + await this.plugin.saveSettings(); + }) + ); + } + addCreateIssueSetting(el) { + new import_obsidian4.Setting(el).setName("Contact support").setDesc( + "If you run into any issues working with this plugin, please let us know by creating an issue on our GitHub page." + ).addButton( + (button) => button.setButtonText("Create issue").setTooltip("Create an issue on GitHub").setCta().onClick( + () => self.open(GITHUB_ISSUE_LINK, "_blank", "norefferrer") + ) + ); + } + addRemoteRepoURL(el) { + new import_obsidian4.Setting(el).setName("Import repository").setDesc( + "If you want to import a vault from a remote repository, add the URL and Import to the directory you want." + ).addText( + (text) => text.setPlaceholder(SAMPLE_REPO).setValue(this.plugin.settings.remoteRepo).onChange(async (remoteRepo) => { + this.plugin.settings.remoteRepo = remoteRepo; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian4.Setting(el).setDesc("The local vault directory to link the remote repository.").addText( + (text) => text.setPlaceholder("C:/Users/").setValue(this.plugin.settings.basePath).onChange(async (basePath) => { + this.plugin.settings.basePath = basePath; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian4.Setting(el).addButton( + (button) => button.setButtonText("Import").setTooltip("Import a remote repository").setCta().onClick(async () => { + try { + const remoteRepo = `${this.plugin.settings.remoteRepo}`; + await this.gitProvider.clone( + remoteRepo, + `${this.plugin.settings.basePath}` + ).fetch(); + } catch (error) { + console.error(error); + } + }) + ); + } + addBranchName(el) { + new import_obsidian4.Setting(el).setName("Select branch").setDesc("Set the working branch.").addText( + (text) => text.setPlaceholder("main").setValue(this.plugin.settings.branchName).onChange(async (branchName) => { + this.plugin.settings.branchName = branchName; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian4.Setting(el).addButton( + (button) => button.setButtonText("Switch").setTooltip("Switch to this branch").setCta().onClick(async () => { + let git = esm_default(this.plugin.settings.basePath); + try { + await git.checkoutBranch( + `${this.plugin.settings.branchName}`, + "HEAD" + ); + } catch (error) { + await git.checkout( + `${this.plugin.settings.branchName}` + ); + } + }) + ); + } +}; + +// src/main.ts +var import_obsidian5 = require("obsidian"); +var PLUGIN_ICON = "sync"; +var CicadaPlugin = class extends import_obsidian5.Plugin { + constructor() { + super(...arguments); + __publicField(this, "gitService"); + __publicField(this, "gitignoreService"); + __publicField(this, "syncController"); + __publicField(this, "settings", DEFAULT_YAOS_SETTINGS); + } + async onload() { + logger_default.debug("Initializing plugin..."); + try { + await this.loadSettings(); + logger_default.info("Loaded settings."); + } catch (e) { + logger_default.error("Failed to load settings."); + } + const adapter = this.app.vault.adapter; + if (adapter instanceof import_obsidian5.FileSystemAdapter) { + const basePath = adapter.getBasePath(); + this.gitService = new SimpleGitService(basePath, this.settings); + this.gitignoreService = new GitignoreService( + basePath, + this.gitService + ); + this.syncController = new SyncController( + this.gitService, + this.gitignoreService + ); + this.addCommand({ + id: "show-unmerged", + name: "Show unmerged/conflicting files", + callback: () => new UnmergedFilesView(this.app, this.gitService).open() + }); + this.addCommand({ + id: "sync", + name: "Sync your vault", + callback: async () => { + await this.syncVault(); + } + }); + this.addRibbonIcon( + PLUGIN_ICON, + PLUGIN_NAME, + this.syncVault.bind(this) + ); + this.addSettingTab(new YaosSettingTab(this.app, this)); + logger_default.debug("Plugin initialized."); + } else { + notifyUserAboutFailure("Adapter type is not recognized."); + logger_default.fatal("Logger type was not FileSystemAdapter."); + } + } + async loadSettings() { + this.settings = Object.assign( + {}, + DEFAULT_YAOS_SETTINGS, + await this.loadData() + ); + if (this.settings.deviceName === "") + this.settings.deviceName = DEFAULT_YAOS_SETTINGS.deviceName; + } + async saveSettings(settings = this.settings) { + await this.saveData(settings); + } + async syncVault(_evt) { + if (!this.gitService || !this.gitignoreService) { + logger_default.fatal("Services were not initialized."); + } else if (!this.syncController) { + logger_default.fatal("Sync controller was not initialized."); + } else { + try { + await this.syncController.sync(); + } catch (e) { + new import_obsidian5.Notice("Unknown error occurred. Please create an issue."); + logger_default.fatal("Unknown error:", e); + } + } + } +}; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["node_modules/dayjs/dayjs.min.js", "node_modules/ms/index.js", "node_modules/debug/src/common.js", "node_modules/debug/src/browser.js", "node_modules/@kwsites/file-exists/src/index.ts", "node_modules/@kwsites/file-exists/index.ts", "node_modules/@kwsites/promise-deferred/src/index.ts", "src/main.ts", "src/utils/constants.ts", "node_modules/consola/dist/core.mjs", "node_modules/consola/dist/browser.mjs", "src/utils/logger.ts", "src/utils/notifier.ts", "src/controllers/syncController.ts", "src/services/gitService.ts", "node_modules/simple-git/src/lib/args/pathspec.ts", "node_modules/simple-git/src/lib/errors/git-error.ts", "node_modules/simple-git/src/lib/errors/git-response-error.ts", "node_modules/simple-git/src/lib/errors/task-configuration-error.ts", "node_modules/simple-git/src/lib/utils/util.ts", "node_modules/simple-git/src/lib/utils/argument-filters.ts", "node_modules/simple-git/src/lib/utils/exit-codes.ts", "node_modules/simple-git/src/lib/utils/git-output-streams.ts", "node_modules/simple-git/src/lib/utils/line-parser.ts", "node_modules/simple-git/src/lib/utils/simple-git-options.ts", "node_modules/simple-git/src/lib/utils/task-options.ts", "node_modules/simple-git/src/lib/utils/task-parser.ts", "node_modules/simple-git/src/lib/utils/index.ts", "node_modules/simple-git/src/lib/tasks/check-is-repo.ts", "node_modules/simple-git/src/lib/responses/CleanSummary.ts", "node_modules/simple-git/src/lib/tasks/task.ts", "node_modules/simple-git/src/lib/tasks/clean.ts", "node_modules/simple-git/src/lib/responses/ConfigList.ts", "node_modules/simple-git/src/lib/tasks/config.ts", "node_modules/simple-git/src/lib/tasks/diff-name-status.ts", "node_modules/simple-git/src/lib/tasks/grep.ts", "node_modules/simple-git/src/lib/tasks/reset.ts", "node_modules/simple-git/src/lib/git-logger.ts", "node_modules/simple-git/src/lib/runners/tasks-pending-queue.ts", "node_modules/simple-git/src/lib/runners/git-executor-chain.ts", "node_modules/simple-git/src/lib/runners/git-executor.ts", "node_modules/simple-git/src/lib/task-callback.ts", "node_modules/simple-git/src/lib/tasks/change-working-directory.ts", "node_modules/simple-git/src/lib/tasks/checkout.ts", "node_modules/simple-git/src/lib/parsers/parse-commit.ts", "node_modules/simple-git/src/lib/tasks/commit.ts", "node_modules/simple-git/src/lib/tasks/first-commit.ts", "node_modules/simple-git/src/lib/tasks/hash-object.ts", "node_modules/simple-git/src/lib/responses/InitSummary.ts", "node_modules/simple-git/src/lib/tasks/init.ts", "node_modules/simple-git/src/lib/args/log-format.ts", "node_modules/simple-git/src/lib/responses/DiffSummary.ts", "node_modules/simple-git/src/lib/parsers/parse-diff-summary.ts", "node_modules/simple-git/src/lib/parsers/parse-list-log-summary.ts", "node_modules/simple-git/src/lib/tasks/diff.ts", "node_modules/simple-git/src/lib/tasks/log.ts", "node_modules/simple-git/src/lib/responses/MergeSummary.ts", "node_modules/simple-git/src/lib/responses/PullSummary.ts", "node_modules/simple-git/src/lib/parsers/parse-remote-objects.ts", "node_modules/simple-git/src/lib/parsers/parse-remote-messages.ts", "node_modules/simple-git/src/lib/parsers/parse-pull.ts", "node_modules/simple-git/src/lib/parsers/parse-merge.ts", "node_modules/simple-git/src/lib/tasks/merge.ts", "node_modules/simple-git/src/lib/parsers/parse-push.ts", "node_modules/simple-git/src/lib/tasks/push.ts", "node_modules/simple-git/src/lib/tasks/show.ts", "node_modules/simple-git/src/lib/responses/FileStatusSummary.ts", "node_modules/simple-git/src/lib/responses/StatusSummary.ts", "node_modules/simple-git/src/lib/tasks/status.ts", "node_modules/simple-git/src/lib/tasks/version.ts", "node_modules/simple-git/src/lib/simple-git-api.ts", "node_modules/simple-git/src/lib/runners/scheduler.ts", "node_modules/simple-git/src/lib/tasks/apply-patch.ts", "node_modules/simple-git/src/lib/responses/BranchDeleteSummary.ts", "node_modules/simple-git/src/lib/parsers/parse-branch-delete.ts", "node_modules/simple-git/src/lib/responses/BranchSummary.ts", "node_modules/simple-git/src/lib/parsers/parse-branch.ts", "node_modules/simple-git/src/lib/tasks/branch.ts", "node_modules/simple-git/src/lib/responses/CheckIgnore.ts", "node_modules/simple-git/src/lib/tasks/check-ignore.ts", "node_modules/simple-git/src/lib/tasks/clone.ts", "node_modules/simple-git/src/lib/parsers/parse-fetch.ts", "node_modules/simple-git/src/lib/tasks/fetch.ts", "node_modules/simple-git/src/lib/parsers/parse-move.ts", "node_modules/simple-git/src/lib/tasks/move.ts", "node_modules/simple-git/src/lib/tasks/pull.ts", "node_modules/simple-git/src/lib/responses/GetRemoteSummary.ts", "node_modules/simple-git/src/lib/tasks/remote.ts", "node_modules/simple-git/src/lib/tasks/stash-list.ts", "node_modules/simple-git/src/lib/tasks/sub-module.ts", "node_modules/simple-git/src/lib/responses/TagList.ts", "node_modules/simple-git/src/lib/tasks/tag.ts", "node_modules/simple-git/src/git.js", "node_modules/simple-git/src/lib/api.ts", "node_modules/simple-git/src/lib/errors/git-construct-error.ts", "node_modules/simple-git/src/lib/errors/git-plugin-error.ts", "node_modules/simple-git/src/lib/plugins/abort-plugin.ts", "node_modules/simple-git/src/lib/plugins/block-unsafe-operations-plugin.ts", "node_modules/simple-git/src/lib/plugins/command-config-prefixing-plugin.ts", "node_modules/simple-git/src/lib/plugins/completion-detection.plugin.ts", "node_modules/simple-git/src/lib/plugins/error-detection.plugin.ts", "node_modules/simple-git/src/lib/plugins/plugin-store.ts", "node_modules/simple-git/src/lib/plugins/progress-monitor-plugin.ts", "node_modules/simple-git/src/lib/plugins/spawn-options-plugin.ts", "node_modules/simple-git/src/lib/plugins/timout-plugin.ts", "node_modules/simple-git/src/lib/plugins/suffix-paths.plugin.ts", "node_modules/simple-git/src/lib/git-factory.ts", "node_modules/simple-git/src/lib/runners/promise-wrapped.ts", "node_modules/simple-git/src/esm.mjs", "src/services/gitignoreService.ts", "src/views/modals/unmergedFilesView.ts", "src/views/settingsTab.ts"],
  "sourcesContent": ["!function(t,e){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=e():\"function\"==typeof define&&define.amd?define(e):(t=\"undefined\"!=typeof globalThis?globalThis:t||self).dayjs=e()}(this,(function(){\"use strict\";var t=1e3,e=6e4,n=36e5,r=\"millisecond\",i=\"second\",s=\"minute\",u=\"hour\",a=\"day\",o=\"week\",c=\"month\",f=\"quarter\",h=\"year\",d=\"date\",l=\"Invalid Date\",$=/^(\\d{4})[-/]?(\\d{1,2})?[-/]?(\\d{0,2})[Tt\\s]*(\\d{1,2})?:?(\\d{1,2})?:?(\\d{1,2})?[.:]?(\\d+)?$/,y=/\\[([^\\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:\"en\",weekdays:\"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday\".split(\"_\"),months:\"January_February_March_April_May_June_July_August_September_October_November_December\".split(\"_\"),ordinal:function(t){var e=[\"th\",\"st\",\"nd\",\"rd\"],n=t%100;return\"[\"+t+(e[(n-20)%10]||e[n]||e[0])+\"]\"}},m=function(t,e,n){var r=String(t);return!r||r.length>=e?t:\"\"+Array(e+1-r.length).join(n)+t},v={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return(e<=0?\"+\":\"-\")+m(r,2,\"0\")+\":\"+m(i,2,\"0\")},m:function t(e,n){if(e.date()<n.date())return-t(n,e);var r=12*(n.year()-e.year())+(n.month()-e.month()),i=e.clone().add(r,c),s=n-i<0,u=e.clone().add(r+(s?-1:1),c);return+(-(r+(n-i)/(s?i-u:u-i))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(t){return{M:c,y:h,w:o,d:a,D:d,h:u,m:s,s:i,ms:r,Q:f}[t]||String(t||\"\").toLowerCase().replace(/s$/,\"\")},u:function(t){return void 0===t}},g=\"en\",D={};D[g]=M;var p=\"$isDayjsObject\",S=function(t){return t instanceof _||!(!t||!t[p])},w=function t(e,n,r){var i;if(!e)return g;if(\"string\"==typeof e){var s=e.toLowerCase();D[s]&&(i=s),n&&(D[s]=n,i=s);var u=e.split(\"-\");if(!i&&u.length>1)return t(u[0])}else{var a=e.name;D[a]=e,i=a}return!r&&i&&(g=i),i||!r&&g},O=function(t,e){if(S(t))return t.clone();var n=\"object\"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},b=v;b.l=w,b.i=S,b.w=function(t,e){return O(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=w(t.locale,null,!0),this.parse(t),this.$x=this.$x||t.x||{},this[p]=!0}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(b.u(e))return new Date;if(e instanceof Date)return new Date(e);if(\"string\"==typeof e&&!/Z$/i.test(e)){var r=e.match($);if(r){var i=r[2]-1||0,s=(r[7]||\"0\").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.init()},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds()},m.$utils=function(){return b},m.isValid=function(){return!(this.$d.toString()===l)},m.isSame=function(t,e){var n=O(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return O(t)<this.startOf(e)},m.isBefore=function(t,e){return this.endOf(e)<O(t)},m.$g=function(t,e,n){return b.u(t)?this[e]:this.set(n,t)},m.unix=function(){return Math.floor(this.valueOf()/1e3)},m.valueOf=function(){return this.$d.getTime()},m.startOf=function(t,e){var n=this,r=!!b.u(e)||e,f=b.p(t),l=function(t,e){var i=b.w(n.$u?Date.UTC(n.$y,e,t):new Date(n.$y,e,t),n);return r?i:i.endOf(a)},$=function(t,e){return b.w(n.toDate()[t].apply(n.toDate(\"s\"),(r?[0,0,0,0]:[23,59,59,999]).slice(e)),n)},y=this.$W,M=this.$M,m=this.$D,v=\"set\"+(this.$u?\"UTC\":\"\");switch(f){case h:return r?l(1,0):l(31,11);case c:return r?l(1,M):l(0,M+1);case o:var g=this.$locale().weekStart||0,D=(y<g?y+7:y)-g;return l(r?m-D:m+(6-D),M);case a:case d:return $(v+\"Hours\",0);case u:return $(v+\"Minutes\",1);case s:return $(v+\"Seconds\",2);case i:return $(v+\"Milliseconds\",3);default:return this.clone()}},m.endOf=function(t){return this.startOf(t,!1)},m.$set=function(t,e){var n,o=b.p(t),f=\"set\"+(this.$u?\"UTC\":\"\"),l=(n={},n[a]=f+\"Date\",n[d]=f+\"Date\",n[c]=f+\"Month\",n[h]=f+\"FullYear\",n[u]=f+\"Hours\",n[s]=f+\"Minutes\",n[i]=f+\"Seconds\",n[r]=f+\"Milliseconds\",n)[o],$=o===a?this.$D+(e-this.$W):e;if(o===c||o===h){var y=this.clone().set(d,1);y.$d[l]($),y.init(),this.$d=y.set(d,Math.min(this.$D,y.daysInMonth())).$d}else l&&this.$d[l]($);return this.init(),this},m.set=function(t,e){return this.clone().$set(t,e)},m.get=function(t){return this[b.p(t)]()},m.add=function(r,f){var d,l=this;r=Number(r);var $=b.p(f),y=function(t){var e=O(l);return b.w(e.date(e.date()+Math.round(t*r)),l)};if($===c)return this.set(c,this.$M+r);if($===h)return this.set(h,this.$y+r);if($===a)return y(1);if($===o)return y(7);var M=(d={},d[s]=e,d[u]=n,d[i]=t,d)[$]||1,m=this.$d.getTime()+r*M;return b.w(m,this)},m.subtract=function(t,e){return this.add(-1*t,e)},m.format=function(t){var e=this,n=this.$locale();if(!this.isValid())return n.invalidDate||l;var r=t||\"YYYY-MM-DDTHH:mm:ssZ\",i=b.z(this),s=this.$H,u=this.$m,a=this.$M,o=n.weekdays,c=n.months,f=n.meridiem,h=function(t,n,i,s){return t&&(t[n]||t(e,r))||i[n].slice(0,s)},d=function(t){return b.s(s%12||12,t,\"0\")},$=f||function(t,e,n){var r=t<12?\"AM\":\"PM\";return n?r.toLowerCase():r};return r.replace(y,(function(t,r){return r||function(t){switch(t){case\"YY\":return String(e.$y).slice(-2);case\"YYYY\":return b.s(e.$y,4,\"0\");case\"M\":return a+1;case\"MM\":return b.s(a+1,2,\"0\");case\"MMM\":return h(n.monthsShort,a,c,3);case\"MMMM\":return h(c,a);case\"D\":return e.$D;case\"DD\":return b.s(e.$D,2,\"0\");case\"d\":return String(e.$W);case\"dd\":return h(n.weekdaysMin,e.$W,o,2);case\"ddd\":return h(n.weekdaysShort,e.$W,o,3);case\"dddd\":return o[e.$W];case\"H\":return String(s);case\"HH\":return b.s(s,2,\"0\");case\"h\":return d(1);case\"hh\":return d(2);case\"a\":return $(s,u,!0);case\"A\":return $(s,u,!1);case\"m\":return String(u);case\"mm\":return b.s(u,2,\"0\");case\"s\":return String(e.$s);case\"ss\":return b.s(e.$s,2,\"0\");case\"SSS\":return b.s(e.$ms,3,\"0\");case\"Z\":return i}return null}(t)||i.replace(\":\",\"\")}))},m.utcOffset=function(){return 15*-Math.round(this.$d.getTimezoneOffset()/15)},m.diff=function(r,d,l){var $,y=this,M=b.p(d),m=O(r),v=(m.utcOffset()-this.utcOffset())*e,g=this-m,D=function(){return b.m(y,m)};switch(M){case h:$=D()/12;break;case c:$=D();break;case f:$=D()/3;break;case o:$=(g-v)/6048e5;break;case a:$=(g-v)/864e5;break;case u:$=g/n;break;case s:$=g/e;break;case i:$=g/t;break;default:$=g}return l?$:b.a($)},m.daysInMonth=function(){return this.endOf(c).$D},m.$locale=function(){return D[this.$L]},m.locale=function(t,e){if(!t)return this.$L;var n=this.clone(),r=w(t,e,!0);return r&&(n.$L=r),n},m.clone=function(){return b.w(this.$d,this)},m.toDate=function(){return new Date(this.valueOf())},m.toJSON=function(){return this.isValid()?this.toISOString():null},m.toISOString=function(){return this.$d.toISOString()},m.toString=function(){return this.$d.toUTCString()},M}(),k=_.prototype;return O.prototype=k,[[\"$ms\",r],[\"$s\",i],[\"$m\",s],[\"$H\",u],[\"$W\",a],[\"$M\",c],[\"$y\",h],[\"$D\",d]].forEach((function(t){k[t[1]]=function(e){return this.$g(e,t[0],t[1])}})),O.extend=function(t,e){return t.$i||(t(e,_,O),t.$i=!0),O},O.locale=w,O.isDayjs=S,O.unix=function(t){return O(1e3*t)},O.en=D[g],O.Ls=D,O.p={},O}));", "/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar w = d * 7;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options) {\n  options = options || {};\n  var type = typeof val;\n  if (type === 'string' && val.length > 0) {\n    return parse(val);\n  } else if (type === 'number' && isFinite(val)) {\n    return options.long ? fmtLong(val) : fmtShort(val);\n  }\n  throw new Error(\n    'val is not a non-empty string or a valid number. val=' +\n      JSON.stringify(val)\n  );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str);\n  if (str.length > 100) {\n    return;\n  }\n  var match = /^(-?(?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(\n    str\n  );\n  if (!match) {\n    return;\n  }\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'weeks':\n    case 'week':\n    case 'w':\n      return n * w;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return Math.round(ms / d) + 'd';\n  }\n  if (msAbs >= h) {\n    return Math.round(ms / h) + 'h';\n  }\n  if (msAbs >= m) {\n    return Math.round(ms / m) + 'm';\n  }\n  if (msAbs >= s) {\n    return Math.round(ms / s) + 's';\n  }\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return plural(ms, msAbs, d, 'day');\n  }\n  if (msAbs >= h) {\n    return plural(ms, msAbs, h, 'hour');\n  }\n  if (msAbs >= m) {\n    return plural(ms, msAbs, m, 'minute');\n  }\n  if (msAbs >= s) {\n    return plural(ms, msAbs, s, 'second');\n  }\n  return ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, msAbs, n, name) {\n  var isPlural = msAbs >= n * 1.5;\n  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');\n}\n", "\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n */\n\nfunction setup(env) {\n\tcreateDebug.debug = createDebug;\n\tcreateDebug.default = createDebug;\n\tcreateDebug.coerce = coerce;\n\tcreateDebug.disable = disable;\n\tcreateDebug.enable = enable;\n\tcreateDebug.enabled = enabled;\n\tcreateDebug.humanize = require('ms');\n\tcreateDebug.destroy = destroy;\n\n\tObject.keys(env).forEach(key => {\n\t\tcreateDebug[key] = env[key];\n\t});\n\n\t/**\n\t* The currently active debug mode names, and names to skip.\n\t*/\n\n\tcreateDebug.names = [];\n\tcreateDebug.skips = [];\n\n\t/**\n\t* Map of special \"%n\" handling functions, for the debug \"format\" argument.\n\t*\n\t* Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n\t*/\n\tcreateDebug.formatters = {};\n\n\t/**\n\t* Selects a color for a debug namespace\n\t* @param {String} namespace The namespace string for the debug instance to be colored\n\t* @return {Number|String} An ANSI color code for the given namespace\n\t* @api private\n\t*/\n\tfunction selectColor(namespace) {\n\t\tlet hash = 0;\n\n\t\tfor (let i = 0; i < namespace.length; i++) {\n\t\t\thash = ((hash << 5) - hash) + namespace.charCodeAt(i);\n\t\t\thash |= 0; // Convert to 32bit integer\n\t\t}\n\n\t\treturn createDebug.colors[Math.abs(hash) % createDebug.colors.length];\n\t}\n\tcreateDebug.selectColor = selectColor;\n\n\t/**\n\t* Create a debugger with the given `namespace`.\n\t*\n\t* @param {String} namespace\n\t* @return {Function}\n\t* @api public\n\t*/\n\tfunction createDebug(namespace) {\n\t\tlet prevTime;\n\t\tlet enableOverride = null;\n\t\tlet namespacesCache;\n\t\tlet enabledCache;\n\n\t\tfunction debug(...args) {\n\t\t\t// Disabled?\n\t\t\tif (!debug.enabled) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst self = debug;\n\n\t\t\t// Set `diff` timestamp\n\t\t\tconst curr = Number(new Date());\n\t\t\tconst ms = curr - (prevTime || curr);\n\t\t\tself.diff = ms;\n\t\t\tself.prev = prevTime;\n\t\t\tself.curr = curr;\n\t\t\tprevTime = curr;\n\n\t\t\targs[0] = createDebug.coerce(args[0]);\n\n\t\t\tif (typeof args[0] !== 'string') {\n\t\t\t\t// Anything else let's inspect with %O\n\t\t\t\targs.unshift('%O');\n\t\t\t}\n\n\t\t\t// Apply any `formatters` transformations\n\t\t\tlet index = 0;\n\t\t\targs[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {\n\t\t\t\t// If we encounter an escaped % then don't increase the array index\n\t\t\t\tif (match === '%%') {\n\t\t\t\t\treturn '%';\n\t\t\t\t}\n\t\t\t\tindex++;\n\t\t\t\tconst formatter = createDebug.formatters[format];\n\t\t\t\tif (typeof formatter === 'function') {\n\t\t\t\t\tconst val = args[index];\n\t\t\t\t\tmatch = formatter.call(self, val);\n\n\t\t\t\t\t// Now we need to remove `args[index]` since it's inlined in the `format`\n\t\t\t\t\targs.splice(index, 1);\n\t\t\t\t\tindex--;\n\t\t\t\t}\n\t\t\t\treturn match;\n\t\t\t});\n\n\t\t\t// Apply env-specific formatting (colors, etc.)\n\t\t\tcreateDebug.formatArgs.call(self, args);\n\n\t\t\tconst logFn = self.log || createDebug.log;\n\t\t\tlogFn.apply(self, args);\n\t\t}\n\n\t\tdebug.namespace = namespace;\n\t\tdebug.useColors = createDebug.useColors();\n\t\tdebug.color = createDebug.selectColor(namespace);\n\t\tdebug.extend = extend;\n\t\tdebug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.\n\n\t\tObject.defineProperty(debug, 'enabled', {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: false,\n\t\t\tget: () => {\n\t\t\t\tif (enableOverride !== null) {\n\t\t\t\t\treturn enableOverride;\n\t\t\t\t}\n\t\t\t\tif (namespacesCache !== createDebug.namespaces) {\n\t\t\t\t\tnamespacesCache = createDebug.namespaces;\n\t\t\t\t\tenabledCache = createDebug.enabled(namespace);\n\t\t\t\t}\n\n\t\t\t\treturn enabledCache;\n\t\t\t},\n\t\t\tset: v => {\n\t\t\t\tenableOverride = v;\n\t\t\t}\n\t\t});\n\n\t\t// Env-specific initialization logic for debug instances\n\t\tif (typeof createDebug.init === 'function') {\n\t\t\tcreateDebug.init(debug);\n\t\t}\n\n\t\treturn debug;\n\t}\n\n\tfunction extend(namespace, delimiter) {\n\t\tconst newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);\n\t\tnewDebug.log = this.log;\n\t\treturn newDebug;\n\t}\n\n\t/**\n\t* Enables a debug mode by namespaces. This can include modes\n\t* separated by a colon and wildcards.\n\t*\n\t* @param {String} namespaces\n\t* @api public\n\t*/\n\tfunction enable(namespaces) {\n\t\tcreateDebug.save(namespaces);\n\t\tcreateDebug.namespaces = namespaces;\n\n\t\tcreateDebug.names = [];\n\t\tcreateDebug.skips = [];\n\n\t\tlet i;\n\t\tconst split = (typeof namespaces === 'string' ? namespaces : '').split(/[\\s,]+/);\n\t\tconst len = split.length;\n\n\t\tfor (i = 0; i < len; i++) {\n\t\t\tif (!split[i]) {\n\t\t\t\t// ignore empty strings\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tnamespaces = split[i].replace(/\\*/g, '.*?');\n\n\t\t\tif (namespaces[0] === '-') {\n\t\t\t\tcreateDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));\n\t\t\t} else {\n\t\t\t\tcreateDebug.names.push(new RegExp('^' + namespaces + '$'));\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t* Disable debug output.\n\t*\n\t* @return {String} namespaces\n\t* @api public\n\t*/\n\tfunction disable() {\n\t\tconst namespaces = [\n\t\t\t...createDebug.names.map(toNamespace),\n\t\t\t...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)\n\t\t].join(',');\n\t\tcreateDebug.enable('');\n\t\treturn namespaces;\n\t}\n\n\t/**\n\t* Returns true if the given mode name is enabled, false otherwise.\n\t*\n\t* @param {String} name\n\t* @return {Boolean}\n\t* @api public\n\t*/\n\tfunction enabled(name) {\n\t\tif (name[name.length - 1] === '*') {\n\t\t\treturn true;\n\t\t}\n\n\t\tlet i;\n\t\tlet len;\n\n\t\tfor (i = 0, len = createDebug.skips.length; i < len; i++) {\n\t\t\tif (createDebug.skips[i].test(name)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\tfor (i = 0, len = createDebug.names.length; i < len; i++) {\n\t\t\tif (createDebug.names[i].test(name)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t* Convert regexp to namespace\n\t*\n\t* @param {RegExp} regxep\n\t* @return {String} namespace\n\t* @api private\n\t*/\n\tfunction toNamespace(regexp) {\n\t\treturn regexp.toString()\n\t\t\t.substring(2, regexp.toString().length - 2)\n\t\t\t.replace(/\\.\\*\\?$/, '*');\n\t}\n\n\t/**\n\t* Coerce `val`.\n\t*\n\t* @param {Mixed} val\n\t* @return {Mixed}\n\t* @api private\n\t*/\n\tfunction coerce(val) {\n\t\tif (val instanceof Error) {\n\t\t\treturn val.stack || val.message;\n\t\t}\n\t\treturn val;\n\t}\n\n\t/**\n\t* XXX DO NOT USE. This is a temporary stub function.\n\t* XXX It WILL be removed in the next major release.\n\t*/\n\tfunction destroy() {\n\t\tconsole.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');\n\t}\n\n\tcreateDebug.enable(createDebug.load());\n\n\treturn createDebug;\n}\n\nmodule.exports = setup;\n", "/* eslint-env browser */\n\n/**\n * This is the web browser implementation of `debug()`.\n */\n\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = localstorage();\nexports.destroy = (() => {\n\tlet warned = false;\n\n\treturn () => {\n\t\tif (!warned) {\n\t\t\twarned = true;\n\t\t\tconsole.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');\n\t\t}\n\t};\n})();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n\t'#0000CC',\n\t'#0000FF',\n\t'#0033CC',\n\t'#0033FF',\n\t'#0066CC',\n\t'#0066FF',\n\t'#0099CC',\n\t'#0099FF',\n\t'#00CC00',\n\t'#00CC33',\n\t'#00CC66',\n\t'#00CC99',\n\t'#00CCCC',\n\t'#00CCFF',\n\t'#3300CC',\n\t'#3300FF',\n\t'#3333CC',\n\t'#3333FF',\n\t'#3366CC',\n\t'#3366FF',\n\t'#3399CC',\n\t'#3399FF',\n\t'#33CC00',\n\t'#33CC33',\n\t'#33CC66',\n\t'#33CC99',\n\t'#33CCCC',\n\t'#33CCFF',\n\t'#6600CC',\n\t'#6600FF',\n\t'#6633CC',\n\t'#6633FF',\n\t'#66CC00',\n\t'#66CC33',\n\t'#9900CC',\n\t'#9900FF',\n\t'#9933CC',\n\t'#9933FF',\n\t'#99CC00',\n\t'#99CC33',\n\t'#CC0000',\n\t'#CC0033',\n\t'#CC0066',\n\t'#CC0099',\n\t'#CC00CC',\n\t'#CC00FF',\n\t'#CC3300',\n\t'#CC3333',\n\t'#CC3366',\n\t'#CC3399',\n\t'#CC33CC',\n\t'#CC33FF',\n\t'#CC6600',\n\t'#CC6633',\n\t'#CC9900',\n\t'#CC9933',\n\t'#CCCC00',\n\t'#CCCC33',\n\t'#FF0000',\n\t'#FF0033',\n\t'#FF0066',\n\t'#FF0099',\n\t'#FF00CC',\n\t'#FF00FF',\n\t'#FF3300',\n\t'#FF3333',\n\t'#FF3366',\n\t'#FF3399',\n\t'#FF33CC',\n\t'#FF33FF',\n\t'#FF6600',\n\t'#FF6633',\n\t'#FF9900',\n\t'#FF9933',\n\t'#FFCC00',\n\t'#FFCC33'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\n// eslint-disable-next-line complexity\nfunction useColors() {\n\t// NB: In an Electron preload script, document will be defined but not fully\n\t// initialized. Since we know we're in Chrome, we'll just detect this case\n\t// explicitly\n\tif (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {\n\t\treturn true;\n\t}\n\n\t// Internet Explorer and Edge do not support colors.\n\tif (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\\/(\\d+)/)) {\n\t\treturn false;\n\t}\n\n\t// Is webkit? http://stackoverflow.com/a/16459606/376773\n\t// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n\treturn (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||\n\t\t// Is firebug? http://stackoverflow.com/a/398120/376773\n\t\t(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||\n\t\t// Is firefox >= v31?\n\t\t// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n\t\t// Double check webkit in userAgent just in case we are in a worker\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n\targs[0] = (this.useColors ? '%c' : '') +\n\t\tthis.namespace +\n\t\t(this.useColors ? ' %c' : ' ') +\n\t\targs[0] +\n\t\t(this.useColors ? '%c ' : ' ') +\n\t\t'+' + module.exports.humanize(this.diff);\n\n\tif (!this.useColors) {\n\t\treturn;\n\t}\n\n\tconst c = 'color: ' + this.color;\n\targs.splice(1, 0, c, 'color: inherit');\n\n\t// The final \"%c\" is somewhat tricky, because there could be other\n\t// arguments passed either before or after the %c, so we need to\n\t// figure out the correct index to insert the CSS into\n\tlet index = 0;\n\tlet lastC = 0;\n\targs[0].replace(/%[a-zA-Z%]/g, match => {\n\t\tif (match === '%%') {\n\t\t\treturn;\n\t\t}\n\t\tindex++;\n\t\tif (match === '%c') {\n\t\t\t// We only are interested in the *last* %c\n\t\t\t// (the user may have provided their own)\n\t\t\tlastC = index;\n\t\t}\n\t});\n\n\targs.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.debug()` when available.\n * No-op when `console.debug` is not a \"function\".\n * If `console.debug` is not available, falls back\n * to `console.log`.\n *\n * @api public\n */\nexports.log = console.debug || console.log || (() => {});\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\nfunction save(namespaces) {\n\ttry {\n\t\tif (namespaces) {\n\t\t\texports.storage.setItem('debug', namespaces);\n\t\t} else {\n\t\t\texports.storage.removeItem('debug');\n\t\t}\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\nfunction load() {\n\tlet r;\n\ttry {\n\t\tr = exports.storage.getItem('debug');\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n\n\t// If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n\tif (!r && typeof process !== 'undefined' && 'env' in process) {\n\t\tr = process.env.DEBUG;\n\t}\n\n\treturn r;\n}\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n\ttry {\n\t\t// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context\n\t\t// The Browser also has localStorage in the global context.\n\t\treturn localStorage;\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\nmodule.exports = require('./common')(exports);\n\nconst {formatters} = module.exports;\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nformatters.j = function (v) {\n\ttry {\n\t\treturn JSON.stringify(v);\n\t} catch (error) {\n\t\treturn '[UnexpectedJSONParseError]: ' + error.message;\n\t}\n};\n", null, null, null, "import SyncController from \"@/controllers/syncController\";\r\nimport { GitService, SimpleGitService } from \"@/services/gitService\";\r\nimport { GitignoreService } from \"@/services/gitignoreService\";\r\n\r\nimport { PLUGIN_NAME } from \"@/utils/constants\";\r\nimport logger from \"@/utils/logger\";\r\nimport { notifyUserAboutFailure } from \"@/utils/notifier\";\r\n\r\nimport UnmergedFilesView from \"@/views/modals/unmergedFilesView\";\r\nimport YaosSettingTab, {\r\n\tDEFAULT_YAOS_SETTINGS,\r\n\tYaosSettings,\r\n} from \"@/views/settingsTab\";\r\n\r\nimport { FileSystemAdapter, Notice, Plugin } from \"obsidian\";\r\n\r\nconst PLUGIN_ICON = \"sync\";\r\n\r\nexport default class CicadaPlugin extends Plugin {\r\n\tprivate gitService?: GitService;\r\n\tprivate gitignoreService?: GitignoreService;\r\n\tprivate syncController?: SyncController;\r\n\r\n\tsettings: YaosSettings = DEFAULT_YAOS_SETTINGS;\r\n\r\n\tasync onload() {\r\n\t\tlogger.debug(\"Initializing plugin...\");\r\n\r\n\t\ttry {\r\n\t\t\tawait this.loadSettings();\r\n\r\n\t\t\tlogger.info(\"Loaded settings.\");\r\n\t\t} catch {\r\n\t\t\tlogger.error(\"Failed to load settings.\");\r\n\t\t}\r\n\r\n\t\tconst adapter = this.app.vault.adapter;\r\n\r\n\t\tif (adapter instanceof FileSystemAdapter) {\r\n\t\t\tconst basePath = adapter.getBasePath();\r\n\r\n\t\t\tthis.gitService = new SimpleGitService(basePath, this.settings);\r\n\t\t\tthis.gitignoreService = new GitignoreService(\r\n\t\t\t\tbasePath,\r\n\t\t\t\tthis.gitService\r\n\t\t\t);\r\n\t\t\tthis.syncController = new SyncController(\r\n\t\t\t\tthis.gitService,\r\n\t\t\t\tthis.gitignoreService\r\n\t\t\t);\r\n\r\n\t\t\tthis.addCommand({\r\n\t\t\t\tid: \"show-unmerged\",\r\n\t\t\t\tname: \"Show unmerged/conflicting files\",\r\n\t\t\t\tcallback: () =>\r\n\t\t\t\t\tnew UnmergedFilesView(this.app, this.gitService).open(),\r\n\t\t\t});\r\n\t\t\tthis.addCommand({\r\n\t\t\t\tid: \"sync\",\r\n\t\t\t\tname: \"Sync your vault\",\r\n\t\t\t\tcallback: async () => {\r\n\t\t\t\t\tawait this.syncVault();\r\n\t\t\t\t},\r\n\t\t\t});\r\n\t\t\tthis.addRibbonIcon(\r\n\t\t\t\tPLUGIN_ICON,\r\n\t\t\t\tPLUGIN_NAME,\r\n\t\t\t\tthis.syncVault.bind(this)\r\n\t\t\t);\r\n\t\t\tthis.addSettingTab(new YaosSettingTab(this.app, this));\r\n\r\n\t\t\tlogger.debug(\"Plugin initialized.\");\r\n\t\t} else {\r\n\t\t\tnotifyUserAboutFailure(\"Adapter type is not recognized.\");\r\n\r\n\t\t\tlogger.fatal(\"Logger type was not FileSystemAdapter.\");\r\n\t\t}\r\n\t}\r\n\r\n\tasync loadSettings() {\r\n\t\tthis.settings = Object.assign(\r\n\t\t\t{},\r\n\t\t\tDEFAULT_YAOS_SETTINGS,\r\n\t\t\tawait this.loadData()\r\n\t\t);\r\n\r\n\t\tif (this.settings.deviceName === \"\")\r\n\t\t\tthis.settings.deviceName = DEFAULT_YAOS_SETTINGS.deviceName;\r\n\t}\r\n\r\n\tasync saveSettings(settings = this.settings) {\r\n\t\tawait this.saveData(settings);\r\n\t}\r\n\r\n\tprivate async syncVault(_evt?: MouseEvent) {\r\n\t\tif (!this.gitService || !this.gitignoreService) {\r\n\t\t\tlogger.fatal(\"Services were not initialized.\");\r\n\t\t} else if (!this.syncController) {\r\n\t\t\tlogger.fatal(\"Sync controller was not initialized.\");\r\n\t\t} else {\r\n\t\t\ttry {\r\n\t\t\t\tawait this.syncController.sync();\r\n\t\t\t} catch (e) {\r\n\t\t\t\tnew Notice(\"Unknown error occurred. Please create an issue.\");\r\n\r\n\t\t\t\tlogger.fatal(\"Unknown error:\", e);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n}\r\n", "export const PLUGIN_NAME = \"CI-SYNC\";\r\n", "const LogLevels = {\n  silent: Number.NEGATIVE_INFINITY,\n  fatal: 0,\n  error: 0,\n  warn: 1,\n  log: 2,\n  info: 3,\n  success: 3,\n  fail: 3,\n  ready: 3,\n  start: 3,\n  box: 3,\n  debug: 4,\n  trace: 5,\n  verbose: Number.POSITIVE_INFINITY\n};\nconst LogTypes = {\n  // Silent\n  silent: {\n    level: -1\n  },\n  // Level 0\n  fatal: {\n    level: LogLevels.fatal\n  },\n  error: {\n    level: LogLevels.error\n  },\n  // Level 1\n  warn: {\n    level: LogLevels.warn\n  },\n  // Level 2\n  log: {\n    level: LogLevels.log\n  },\n  // Level 3\n  info: {\n    level: LogLevels.info\n  },\n  success: {\n    level: LogLevels.success\n  },\n  fail: {\n    level: LogLevels.fail\n  },\n  ready: {\n    level: LogLevels.info\n  },\n  start: {\n    level: LogLevels.info\n  },\n  box: {\n    level: LogLevels.info\n  },\n  // Level 4\n  debug: {\n    level: LogLevels.debug\n  },\n  // Level 5\n  trace: {\n    level: LogLevels.trace\n  },\n  // Verbose\n  verbose: {\n    level: LogLevels.verbose\n  }\n};\n\nfunction isObject(value) {\n  return value !== null && typeof value === \"object\";\n}\nfunction _defu(baseObject, defaults, namespace = \".\", merger) {\n  if (!isObject(defaults)) {\n    return _defu(baseObject, {}, namespace, merger);\n  }\n  const object = Object.assign({}, defaults);\n  for (const key in baseObject) {\n    if (key === \"__proto__\" || key === \"constructor\") {\n      continue;\n    }\n    const value = baseObject[key];\n    if (value === null || value === void 0) {\n      continue;\n    }\n    if (merger && merger(object, key, value, namespace)) {\n      continue;\n    }\n    if (Array.isArray(value) && Array.isArray(object[key])) {\n      object[key] = [...value, ...object[key]];\n    } else if (isObject(value) && isObject(object[key])) {\n      object[key] = _defu(\n        value,\n        object[key],\n        (namespace ? `${namespace}.` : \"\") + key.toString(),\n        merger\n      );\n    } else {\n      object[key] = value;\n    }\n  }\n  return object;\n}\nfunction createDefu(merger) {\n  return (...arguments_) => (\n    // eslint-disable-next-line unicorn/no-array-reduce\n    arguments_.reduce((p, c) => _defu(p, c, \"\", merger), {})\n  );\n}\nconst defu = createDefu();\n\nfunction isPlainObject(obj) {\n  return Object.prototype.toString.call(obj) === \"[object Object]\";\n}\nfunction isLogObj(arg) {\n  if (!isPlainObject(arg)) {\n    return false;\n  }\n  if (!arg.message && !arg.args) {\n    return false;\n  }\n  if (arg.stack) {\n    return false;\n  }\n  return true;\n}\n\nlet paused = false;\nconst queue = [];\nclass Consola {\n  constructor(options = {}) {\n    const types = options.types || LogTypes;\n    this.options = defu(\n      {\n        ...options,\n        defaults: { ...options.defaults },\n        level: _normalizeLogLevel(options.level, types),\n        reporters: [...options.reporters || []]\n      },\n      {\n        types: LogTypes,\n        throttle: 1e3,\n        throttleMin: 5,\n        formatOptions: {\n          date: true,\n          colors: false,\n          compact: true\n        }\n      }\n    );\n    for (const type in types) {\n      const defaults = {\n        type,\n        ...this.options.defaults,\n        ...types[type]\n      };\n      this[type] = this._wrapLogFn(defaults);\n      this[type].raw = this._wrapLogFn(\n        defaults,\n        true\n      );\n    }\n    if (this.options.mockFn) {\n      this.mockTypes();\n    }\n    this._lastLog = {};\n  }\n  get level() {\n    return this.options.level;\n  }\n  set level(level) {\n    this.options.level = _normalizeLogLevel(\n      level,\n      this.options.types,\n      this.options.level\n    );\n  }\n  prompt(message, opts) {\n    if (!this.options.prompt) {\n      throw new Error(\"prompt is not supported!\");\n    }\n    return this.options.prompt(message, opts);\n  }\n  create(options) {\n    const instance = new Consola({\n      ...this.options,\n      ...options\n    });\n    if (this._mockFn) {\n      instance.mockTypes(this._mockFn);\n    }\n    return instance;\n  }\n  withDefaults(defaults) {\n    return this.create({\n      ...this.options,\n      defaults: {\n        ...this.options.defaults,\n        ...defaults\n      }\n    });\n  }\n  withTag(tag) {\n    return this.withDefaults({\n      tag: this.options.defaults.tag ? this.options.defaults.tag + \":\" + tag : tag\n    });\n  }\n  addReporter(reporter) {\n    this.options.reporters.push(reporter);\n    return this;\n  }\n  removeReporter(reporter) {\n    if (reporter) {\n      const i = this.options.reporters.indexOf(reporter);\n      if (i >= 0) {\n        return this.options.reporters.splice(i, 1);\n      }\n    } else {\n      this.options.reporters.splice(0);\n    }\n    return this;\n  }\n  setReporters(reporters) {\n    this.options.reporters = Array.isArray(reporters) ? reporters : [reporters];\n    return this;\n  }\n  wrapAll() {\n    this.wrapConsole();\n    this.wrapStd();\n  }\n  restoreAll() {\n    this.restoreConsole();\n    this.restoreStd();\n  }\n  wrapConsole() {\n    for (const type in this.options.types) {\n      if (!console[\"__\" + type]) {\n        console[\"__\" + type] = console[type];\n      }\n      console[type] = this[type].raw;\n    }\n  }\n  restoreConsole() {\n    for (const type in this.options.types) {\n      if (console[\"__\" + type]) {\n        console[type] = console[\"__\" + type];\n        delete console[\"__\" + type];\n      }\n    }\n  }\n  wrapStd() {\n    this._wrapStream(this.options.stdout, \"log\");\n    this._wrapStream(this.options.stderr, \"log\");\n  }\n  _wrapStream(stream, type) {\n    if (!stream) {\n      return;\n    }\n    if (!stream.__write) {\n      stream.__write = stream.write;\n    }\n    stream.write = (data) => {\n      this[type].raw(String(data).trim());\n    };\n  }\n  restoreStd() {\n    this._restoreStream(this.options.stdout);\n    this._restoreStream(this.options.stderr);\n  }\n  _restoreStream(stream) {\n    if (!stream) {\n      return;\n    }\n    if (stream.__write) {\n      stream.write = stream.__write;\n      delete stream.__write;\n    }\n  }\n  pauseLogs() {\n    paused = true;\n  }\n  resumeLogs() {\n    paused = false;\n    const _queue = queue.splice(0);\n    for (const item of _queue) {\n      item[0]._logFn(item[1], item[2]);\n    }\n  }\n  mockTypes(mockFn) {\n    const _mockFn = mockFn || this.options.mockFn;\n    this._mockFn = _mockFn;\n    if (typeof _mockFn !== \"function\") {\n      return;\n    }\n    for (const type in this.options.types) {\n      this[type] = _mockFn(type, this.options.types[type]) || this[type];\n      this[type].raw = this[type];\n    }\n  }\n  _wrapLogFn(defaults, isRaw) {\n    return (...args) => {\n      if (paused) {\n        queue.push([this, defaults, args, isRaw]);\n        return;\n      }\n      return this._logFn(defaults, args, isRaw);\n    };\n  }\n  _logFn(defaults, args, isRaw) {\n    if ((defaults.level || 0) > this.level) {\n      return false;\n    }\n    const logObj = {\n      date: /* @__PURE__ */ new Date(),\n      args: [],\n      ...defaults,\n      level: _normalizeLogLevel(defaults.level, this.options.types)\n    };\n    if (!isRaw && args.length === 1 && isLogObj(args[0])) {\n      Object.assign(logObj, args[0]);\n    } else {\n      logObj.args = [...args];\n    }\n    if (logObj.message) {\n      logObj.args.unshift(logObj.message);\n      delete logObj.message;\n    }\n    if (logObj.additional) {\n      if (!Array.isArray(logObj.additional)) {\n        logObj.additional = logObj.additional.split(\"\\n\");\n      }\n      logObj.args.push(\"\\n\" + logObj.additional.join(\"\\n\"));\n      delete logObj.additional;\n    }\n    logObj.type = typeof logObj.type === \"string\" ? logObj.type.toLowerCase() : \"log\";\n    logObj.tag = typeof logObj.tag === \"string\" ? logObj.tag : \"\";\n    const resolveLog = (newLog = false) => {\n      const repeated = (this._lastLog.count || 0) - this.options.throttleMin;\n      if (this._lastLog.object && repeated > 0) {\n        const args2 = [...this._lastLog.object.args];\n        if (repeated > 1) {\n          args2.push(`(repeated ${repeated} times)`);\n        }\n        this._log({ ...this._lastLog.object, args: args2 });\n        this._lastLog.count = 1;\n      }\n      if (newLog) {\n        this._lastLog.object = logObj;\n        this._log(logObj);\n      }\n    };\n    clearTimeout(this._lastLog.timeout);\n    const diffTime = this._lastLog.time && logObj.date ? logObj.date.getTime() - this._lastLog.time.getTime() : 0;\n    this._lastLog.time = logObj.date;\n    if (diffTime < this.options.throttle) {\n      try {\n        const serializedLog = JSON.stringify([\n          logObj.type,\n          logObj.tag,\n          logObj.args\n        ]);\n        const isSameLog = this._lastLog.serialized === serializedLog;\n        this._lastLog.serialized = serializedLog;\n        if (isSameLog) {\n          this._lastLog.count = (this._lastLog.count || 0) + 1;\n          if (this._lastLog.count > this.options.throttleMin) {\n            this._lastLog.timeout = setTimeout(\n              resolveLog,\n              this.options.throttle\n            );\n            return;\n          }\n        }\n      } catch {\n      }\n    }\n    resolveLog(true);\n  }\n  _log(logObj) {\n    for (const reporter of this.options.reporters) {\n      reporter.log(logObj, {\n        options: this.options\n      });\n    }\n  }\n}\nfunction _normalizeLogLevel(input, types = {}, defaultLevel = 3) {\n  if (input === void 0) {\n    return defaultLevel;\n  }\n  if (typeof input === \"number\") {\n    return input;\n  }\n  if (types[input] && types[input].level !== void 0) {\n    return types[input].level;\n  }\n  return defaultLevel;\n}\nConsola.prototype.add = Consola.prototype.addReporter;\nConsola.prototype.remove = Consola.prototype.removeReporter;\nConsola.prototype.clear = Consola.prototype.removeReporter;\nConsola.prototype.withScope = Consola.prototype.withTag;\nConsola.prototype.mock = Consola.prototype.mockTypes;\nConsola.prototype.pause = Consola.prototype.pauseLogs;\nConsola.prototype.resume = Consola.prototype.resumeLogs;\nfunction createConsola(options = {}) {\n  return new Consola(options);\n}\n\nexport { Consola, LogLevels, LogTypes, createConsola };\n", "import { createConsola as createConsola$1 } from './core.mjs';\nexport { Consola, LogLevels, LogTypes } from './core.mjs';\n\nclass BrowserReporter {\n  constructor(options) {\n    this.options = { ...options };\n    this.defaultColor = \"#7f8c8d\";\n    this.levelColorMap = {\n      0: \"#c0392b\",\n      // Red\n      1: \"#f39c12\",\n      // Yellow\n      3: \"#00BCD4\"\n      // Cyan\n    };\n    this.typeColorMap = {\n      success: \"#2ecc71\"\n      // Green\n    };\n  }\n  _getLogFn(level) {\n    if (level < 1) {\n      return console.__error || console.error;\n    }\n    if (level === 1) {\n      return console.__warn || console.warn;\n    }\n    return console.__log || console.log;\n  }\n  log(logObj) {\n    const consoleLogFn = this._getLogFn(logObj.level);\n    const type = logObj.type === \"log\" ? \"\" : logObj.type;\n    const tag = logObj.tag || \"\";\n    const color = this.typeColorMap[logObj.type] || this.levelColorMap[logObj.level] || this.defaultColor;\n    const style = `\n      background: ${color};\n      border-radius: 0.5em;\n      color: white;\n      font-weight: bold;\n      padding: 2px 0.5em;\n    `;\n    const badge = `%c${[tag, type].filter(Boolean).join(\":\")}`;\n    if (typeof logObj.args[0] === \"string\") {\n      consoleLogFn(\n        `${badge}%c ${logObj.args[0]}`,\n        style,\n        // Empty string as style resets to default console style\n        \"\",\n        ...logObj.args.slice(1)\n      );\n    } else {\n      consoleLogFn(badge, style, ...logObj.args);\n    }\n  }\n}\n\nfunction createConsola(options = {}) {\n  const consola2 = createConsola$1({\n    reporters: options.reporters || [new BrowserReporter({})],\n    prompt(message, options2 = {}) {\n      if (options2.type === \"confirm\") {\n        return Promise.resolve(confirm(message));\n      }\n      return Promise.resolve(prompt(message));\n    },\n    ...options\n  });\n  return consola2;\n}\nconst consola = createConsola();\n\nexport { consola, createConsola, consola as default };\n", "import { PLUGIN_NAME } from \"@/utils/constants\";\r\n\r\nimport { LogLevels, consola } from \"consola\";\r\n\r\nconst logger = consola.create({ level: LogLevels.debug }).withTag(PLUGIN_NAME);\r\n\r\nexport default logger;\r\n", "import { Notice } from \"obsidian\";\r\n\r\nexport const notifyUserAboutFailure = (message: string) =>\r\n\tnew Notice(`FATAL: ${message}`);\r\n", "import { GitService } from \"@/services/gitService\";\r\nimport { GitignoreService } from \"@/services/gitignoreService\";\r\nimport logger from \"@/utils/logger\";\r\nimport { notifyUserAboutFailure } from \"@/utils/notifier\";\r\n\r\nimport { Notice } from \"obsidian\";\r\n\r\nexport default class SyncController {\r\n\tconstructor(\r\n\t\tprivate gitService: GitService,\r\n\t\tprivate gitignoreService: GitignoreService\r\n\t) {\r\n\t\tlogger.debug(\"Initialized sync controller.\");\r\n\t}\r\n\r\n\tprivate async createVaultBackup() {\r\n\t\tif (await this.gitService.unstagedChangesExist()) {\r\n\t\t\tawait this.handleUnstagedChanges();\r\n\t\t} else {\r\n\t\t\tlogger.info(\"No changes in vault detected for backup/sync.\");\r\n\t\t\ttry {\r\n\t\t\t\tawait this.gitService.gitPushUpstream();\r\n\t\t\t\ttry {\r\n\t\t\t\t\tawait this.gitService.gitPull();\r\n\t\t\t\t} catch {\r\n\t\t\t\t\t// notifyUserAboutFailure(\"Failed to sync with remote\");\r\n\r\n\t\t\t\t\tlogger.error(\"Pull failed.\");\r\n\t\t\t\t}\r\n\t\t\t} catch (error) {\r\n\t\t\t\tlogger.warn(\"Failed to push branch upstream\");\r\n\t\t\t\ttry {\r\n\t\t\t\t\tawait this.gitService.gitPull();\r\n\t\t\t\t\tawait this.gitService.gitPushUpstream();\r\n\r\n\t\t\t\t\t// this.notifyUserAboutBackup();\r\n\r\n\t\t\t\t\tlogger.success(\"Synced local and remote.\");\r\n\t\t\t\t} catch {\r\n\t\t\t\t\tnotifyUserAboutFailure(\"Failed to sync with remote\");\r\n\r\n\t\t\t\t\tlogger.error(\"Pull and upstream failed.\");\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (await this.gitService.isLocalAhead()) {\r\n\t\t\tawait this.handleLocalAhead();\r\n\t\t}\r\n\t}\r\n\r\n\tprivate async handleLocalAhead() {\r\n\t\ttry {\r\n\t\t\tawait this.gitService.gitPush();\r\n\r\n\t\t\tthis.notifyUserAboutBackup();\r\n\t\t} catch {\r\n\t\t\tlogger.warn(\"Remote and local have conflicting changes!\");\r\n\t\t\tlogger.info(\"Starting rebase process...\");\r\n\r\n\t\t\ttry {\r\n\t\t\t\tawait this.gitService.gitPullWithRebase();\r\n\t\t\t\tawait this.gitService.gitPush();\r\n\r\n\t\t\t\tthis.notifyUserAboutBackup();\r\n\r\n\t\t\t\tlogger.success(\"Created vault sync.\");\r\n\t\t\t} catch {\r\n\t\t\t\tthis.notifyUserAboutConflicts();\r\n\r\n\t\t\t\tlogger.error(\"Automatic rebasing failed.\");\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tprivate async handleUnstagedChanges() {\r\n\t\tlogger.info(\"Unstaged changes detected. Syncronizing...\");\r\n\r\n\t\tawait this.gitService.gitStageAll();\r\n\t\tawait this.gitService.gitCommit();\r\n\t}\r\n\r\n\tprivate notifyUserAboutBackup() {\r\n\t\tnew Notice(\"Successfully synced up vault!\");\r\n\t}\r\n\r\n\tprivate notifyUserAboutConflicts() {\r\n\t\tnew Notice(\r\n\t\t\t\"Your local and remote repositories had conflicting changes.\"\r\n\t\t);\r\n\t\tnew Notice(\r\n\t\t\t\"Please fix the changes and then click the sync button again.\"\r\n\t\t);\r\n\t}\r\n\r\n\tasync sync() {\r\n\t\tif (await this.gitService.isRepo()) {\r\n\t\t\tlogger.debug(\"Vault is initialized as a Git repository.\");\r\n\t\t} else {\r\n\t\t\tlogger.fatal(\"Vault is not initialized as a Git repository.\");\r\n\t\t\tnotifyUserAboutFailure(\"Vault is not a Git repository.\");\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tif (await this.gitService.isRemoteConfigured()) {\r\n\t\t\tlogger.debug(\"Remote repository is configured.\");\r\n\t\t} else {\r\n\t\t\tlogger.fatal(\"Remote repository is not configured.\");\r\n\t\t\tnotifyUserAboutFailure(\"Remote repository is not configured.\");\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tif (await this.gitService.isRebasing()) {\r\n\t\t\tlogger.debug(\"Stopping in progress rebase.\");\r\n\r\n\t\t\tawait this.gitService.stopRebasing();\r\n\t\t}\r\n\r\n\t\tawait this.createVaultBackup();\r\n\t}\r\n}\r\n", "import logger from \"@/utils/logger\";\r\nimport { YaosSettings } from \"@/views/settingsTab\";\r\n\r\nimport dayjs from \"dayjs\";\r\nimport simpleGit, { SimpleGit } from \"simple-git\";\r\n\r\nconst DEFAULT_REMOTE = \"origin\";\r\n\r\nconst CURRENT_TIME = () => dayjs().format(\"YYYY-MM-DDTHH:mm\");\r\nconst COMMIT_MESSAGE = (deviceName: string) =>\r\n\t`chore: vault backup from ${deviceName} at ${CURRENT_TIME()}`;\r\n\r\nexport interface GitService {\r\n\tsettings: YaosSettings;\r\n\r\n\tgitCommit(message?: string): Promise<void>;\r\n\tgitPullWithRebase(): Promise<void>;\r\n\tgitPull(branch?: string): Promise<void>;\r\n\tgitPushUpstream(branch?: string): Promise<void>;\r\n\tgitPush(forcePush?: boolean, branch?: string): Promise<void>;\r\n\tgitStage(...files: string[]): Promise<void>;\r\n\tgitStageAll(): Promise<void>;\r\n\r\n\tisLocalAhead(): Promise<boolean>;\r\n\tisRebasing(): Promise<boolean>;\r\n\tisRemoteConfigured(): Promise<boolean>;\r\n\tisRepo(): Promise<boolean>;\r\n\r\n\tgetConflictingFiles(): Promise<string[]>;\r\n\tstopRebasing(): Promise<void>;\r\n\tunstagedChangesExist(): Promise<boolean>;\r\n}\r\n\r\nexport class SimpleGitService implements GitService {\r\n\tprivate gitProvider: SimpleGit;\r\n\r\n\tconstructor(repoPath: string, public settings: YaosSettings) {\r\n\t\tlogger.debug(\"Initializing SimpleGitService...\");\r\n\t\tthis.gitProvider = simpleGit(repoPath);\r\n\t\tlogger.debug(\"SimpleGitService initialized.\");\r\n\t}\r\n\r\n\tasync gitCommit(message = COMMIT_MESSAGE(this.settings.deviceName)) {\r\n\t\tlogger.info(`Committing... ${message}`);\r\n\r\n\t\tawait this.gitProvider.commit(message);\r\n\t}\r\n\r\n\tasync gitPullWithRebase() {\r\n\t\tawait this.gitProvider.pull([\"--rebase\"]);\r\n\t}\r\n\r\n\tasync gitPull(branch = this.settings.branchName) {\r\n\t\tawait this.gitProvider.pull(DEFAULT_REMOTE, branch, [\"--rebase\"]);\r\n\t}\r\n\r\n\tasync gitPushUpstream(branch = this.settings.branchName) {\r\n\t\tawait this.gitProvider.push(DEFAULT_REMOTE, branch, [\r\n\t\t\t\"--set-upstream\",\r\n\t\t\t\"--force\",\r\n\t\t]);\r\n\r\n\t\tlogger.info(`Pushed branch upstream to ${DEFAULT_REMOTE}/${branch}.`);\r\n\t}\r\n\r\n\tasync gitPush(forcePush = false, branch = this.settings.branchName) {\r\n\t\tconst options = forcePush ? [\"-f\"] : [];\r\n\r\n\t\tawait this.gitProvider.push(DEFAULT_REMOTE, branch, options);\r\n\r\n\t\tlogger.info(`Pushed changes to ${DEFAULT_REMOTE}/${branch}.`);\r\n\t}\r\n\r\n\tasync gitStage(...files: string[]) {\r\n\t\tawait Promise.all(files.map((file) => this.gitProvider.add(file)));\r\n\t}\r\n\r\n\tasync gitStageAll() {\r\n\t\tawait this.gitProvider.add(\"./*\");\r\n\t}\r\n\r\n\tasync isLocalAhead() {\r\n\t\treturn this.gitProvider.status().then((status) => status.ahead > 0);\r\n\t}\r\n\r\n\tasync isRebasing() {\r\n\t\treturn this.gitProvider\r\n\t\t\t.raw([\"status\"])\r\n\t\t\t.then((status) => status.includes(\"rebase\"));\r\n\t}\r\n\r\n\tasync isRemoteConfigured() {\r\n\t\tlet remoteConfigured = false;\r\n\r\n\t\ttry {\r\n\t\t\tconst remotes = await this.gitProvider.listRemote([\"--get-url\"]);\r\n\t\t\tremoteConfigured = !!remotes;\r\n\t\t} catch {\r\n\t\t\tremoteConfigured = false;\r\n\t\t}\r\n\r\n\t\treturn remoteConfigured;\r\n\t}\r\n\r\n\tasync isRepo() {\r\n\t\treturn this.gitProvider.checkIsRepo();\r\n\t}\r\n\r\n\tasync getConflictingFiles() {\r\n\t\treturn this.gitProvider.status().then((status) => status.conflicted);\r\n\t}\r\n\r\n\tasync stopRebasing() {\r\n\t\tprocess.env.GIT_EDITOR = \"true\";\r\n\r\n\t\tawait this.gitStageAll();\r\n\t\tawait this.gitProvider.rebase([\"--continue\"]);\r\n\t\tawait this.gitPush();\r\n\r\n\t\tprocess.env.GIT_EDITOR = undefined;\r\n\t}\r\n\r\n\tasync unstagedChangesExist() {\r\n\t\treturn this.gitProvider\r\n\t\t\t.status()\r\n\t\t\t.then(\r\n\t\t\t\t(status) =>\r\n\t\t\t\t\tstatus.files.length > 0 || status.not_added.length > 0\r\n\t\t\t);\r\n\t}\r\n}\r\n", "const cache = new WeakMap<String, string[]>();\n\nexport function pathspec(...paths: string[]) {\n   const key = new String(paths);\n   cache.set(key, paths);\n\n   return key as string;\n}\n\nexport function isPathSpec(path: string | unknown): path is string {\n   return path instanceof String && cache.has(path);\n}\n\nexport function toPaths(pathSpec: string): string[] {\n   return cache.get(pathSpec) || [];\n}\n", "import type { SimpleGitTask } from '../types';\n\n/**\n * The `GitError` is thrown when the underlying `git` process throws a\n * fatal exception (eg an `ENOENT` exception when attempting to use a\n * non-writable directory as the root for your repo), and acts as the\n * base class for more specific errors thrown by the parsing of the\n * git response or errors in the configuration of the task about to\n * be run.\n *\n * When an exception is thrown, pending tasks in the same instance will\n * not be executed. The recommended way to run a series of tasks that\n * can independently fail without needing to prevent future tasks from\n * running is to catch them individually:\n *\n * ```typescript\n import { gitP, SimpleGit, GitError, PullResult } from 'simple-git';\n\n function catchTask (e: GitError) {\n   return e.\n }\n\n const git = gitP(repoWorkingDir);\n const pulled: PullResult | GitError = await git.pull().catch(catchTask);\n const pushed: string | GitError = await git.pushTags().catch(catchTask);\n ```\n */\nexport class GitError extends Error {\n   constructor(\n      public task?: SimpleGitTask<any>,\n      message?: string\n   ) {\n      super(message);\n      Object.setPrototypeOf(this, new.target.prototype);\n   }\n}\n", "import { GitError } from './git-error';\n\n/**\n * The `GitResponseError` is the wrapper for a parsed response that is treated as\n * a fatal error, for example attempting a `merge` can leave the repo in a corrupted\n * state when there are conflicts so the task will reject rather than resolve.\n *\n * For example, catching the merge conflict exception:\n *\n * ```typescript\n import { gitP, SimpleGit, GitResponseError, MergeSummary } from 'simple-git';\n\n const git = gitP(repoRoot);\n const mergeOptions: string[] = ['--no-ff', 'other-branch'];\n const mergeSummary: MergeSummary = await git.merge(mergeOptions)\n      .catch((e: GitResponseError<MergeSummary>) => e.git);\n\n if (mergeSummary.failed) {\n   // deal with the error\n }\n ```\n */\nexport class GitResponseError<T = any> extends GitError {\n   constructor(\n      /**\n       * `.git` access the parsed response that is treated as being an error\n       */\n      public readonly git: T,\n      message?: string\n   ) {\n      super(undefined, message || String(git));\n   }\n}\n", "import { GitError } from './git-error';\n\n/**\n * The `TaskConfigurationError` is thrown when a command was incorrectly\n * configured. An error of this kind means that no attempt was made to\n * run your command through the underlying `git` binary.\n *\n * Check the `.message` property for more detail on why your configuration\n * resulted in an error.\n */\nexport class TaskConfigurationError extends GitError {\n   constructor(message?: string) {\n      super(undefined, message);\n   }\n}\n", "import { exists, FOLDER } from '@kwsites/file-exists';\nimport { Maybe } from '../types';\n\nexport const NULL = '\\0';\n\nexport const NOOP: (...args: any[]) => void = () => {};\n\n/**\n * Returns either the source argument when it is a `Function`, or the default\n * `NOOP` function constant\n */\nexport function asFunction<T extends () => any>(source: T | any): T {\n   return typeof source === 'function' ? source : NOOP;\n}\n\n/**\n * Determines whether the supplied argument is both a function, and is not\n * the `NOOP` function.\n */\nexport function isUserFunction<T extends Function>(source: T | any): source is T {\n   return typeof source === 'function' && source !== NOOP;\n}\n\nexport function splitOn(input: string, char: string): [string, string] {\n   const index = input.indexOf(char);\n   if (index <= 0) {\n      return [input, ''];\n   }\n\n   return [input.substr(0, index), input.substr(index + 1)];\n}\n\nexport function first<T extends any[]>(input: T, offset?: number): Maybe<T[number]>;\nexport function first<T extends IArguments>(input: T, offset?: number): Maybe<unknown>;\nexport function first(input: any[] | IArguments, offset = 0): Maybe<unknown> {\n   return isArrayLike(input) && input.length > offset ? input[offset] : undefined;\n}\n\nexport function last<T extends any[]>(input: T, offset?: number): Maybe<T[number]>;\nexport function last<T extends IArguments>(input: T, offset?: number): Maybe<unknown>;\nexport function last<T>(input: T, offset?: number): Maybe<unknown>;\nexport function last(input: unknown, offset = 0) {\n   if (isArrayLike(input) && input.length > offset) {\n      return input[input.length - 1 - offset];\n   }\n}\n\ntype ArrayLike<T = any> = T[] | IArguments | { [index: number]: T; length: number };\n\nfunction isArrayLike(input: any): input is ArrayLike {\n   return !!(input && typeof input.length === 'number');\n}\n\nexport function toLinesWithContent(input = '', trimmed = true, separator = '\\n'): string[] {\n   return input.split(separator).reduce((output, line) => {\n      const lineContent = trimmed ? line.trim() : line;\n      if (lineContent) {\n         output.push(lineContent);\n      }\n      return output;\n   }, [] as string[]);\n}\n\ntype LineWithContentCallback<T = void> = (line: string) => T;\n\nexport function forEachLineWithContent<T>(\n   input: string,\n   callback: LineWithContentCallback<T>\n): T[] {\n   return toLinesWithContent(input, true).map((line) => callback(line));\n}\n\nexport function folderExists(path: string): boolean {\n   return exists(path, FOLDER);\n}\n\n/**\n * Adds `item` into the `target` `Array` or `Set` when it is not already present and returns the `item`.\n */\nexport function append<T>(target: T[] | Set<T>, item: T): typeof item {\n   if (Array.isArray(target)) {\n      if (!target.includes(item)) {\n         target.push(item);\n      }\n   } else {\n      target.add(item);\n   }\n   return item;\n}\n\n/**\n * Adds `item` into the `target` `Array` when it is not already present and returns the `target`.\n */\nexport function including<T>(target: T[], item: T): typeof target {\n   if (Array.isArray(target) && !target.includes(item)) {\n      target.push(item);\n   }\n\n   return target;\n}\n\nexport function remove<T>(target: Set<T> | T[], item: T): T {\n   if (Array.isArray(target)) {\n      const index = target.indexOf(item);\n      if (index >= 0) {\n         target.splice(index, 1);\n      }\n   } else {\n      target.delete(item);\n   }\n   return item;\n}\n\nexport const objectToString = Object.prototype.toString.call.bind(Object.prototype.toString) as (\n   input: any\n) => string;\n\nexport function asArray<T>(source: T | T[]): T[] {\n   return Array.isArray(source) ? source : [source];\n}\n\nexport function asStringArray<T>(source: T | T[]): string[] {\n   return asArray(source).map(String);\n}\n\nexport function asNumber(source: string | null | undefined, onNaN = 0) {\n   if (source == null) {\n      return onNaN;\n   }\n\n   const num = parseInt(source, 10);\n   return isNaN(num) ? onNaN : num;\n}\n\nexport function prefixedArray<T>(input: T[], prefix: T): T[] {\n   const output: T[] = [];\n   for (let i = 0, max = input.length; i < max; i++) {\n      output.push(prefix, input[i]);\n   }\n   return output;\n}\n\nexport function bufferToString(input: Buffer | Buffer[]): string {\n   return (Array.isArray(input) ? Buffer.concat(input) : input).toString('utf-8');\n}\n\n/**\n * Get a new object from a source object with only the listed properties.\n */\nexport function pick(source: Record<string, any>, properties: string[]) {\n   return Object.assign(\n      {},\n      ...properties.map((property) => (property in source ? { [property]: source[property] } : {}))\n   );\n}\n\nexport function delay(duration = 0): Promise<void> {\n   return new Promise((done) => setTimeout(done, duration));\n}\n\nexport function orVoid<T>(input: T | false) {\n   if (input === false) {\n      return undefined;\n   }\n   return input;\n}\n", "import { Maybe, Options, Primitives } from '../types';\nimport { objectToString } from './util';\nimport { isPathSpec } from '../args/pathspec';\n\nexport interface ArgumentFilterPredicate<T> {\n   (input: any): input is T;\n}\n\nexport function filterType<T, K>(\n   input: K,\n   filter: ArgumentFilterPredicate<T>\n): K extends T ? T : undefined;\nexport function filterType<T, K>(input: K, filter: ArgumentFilterPredicate<T>, def: T): T;\nexport function filterType<T, K>(input: K, filter: ArgumentFilterPredicate<T>, def?: T): Maybe<T> {\n   if (filter(input)) {\n      return input;\n   }\n   return arguments.length > 2 ? def : undefined;\n}\n\nexport const filterArray: ArgumentFilterPredicate<Array<any>> = (input): input is Array<any> => {\n   return Array.isArray(input);\n};\n\nexport function filterPrimitives(\n   input: unknown,\n   omit?: Array<'boolean' | 'string' | 'number'>\n): input is Primitives {\n   const type = isPathSpec(input) ? 'string' : typeof input;\n\n   return (\n      /number|string|boolean/.test(type) &&\n      (!omit || !omit.includes(type as 'boolean' | 'string' | 'number'))\n   );\n}\n\nexport const filterString: ArgumentFilterPredicate<string> = (input): input is string => {\n   return typeof input === 'string';\n};\n\nexport const filterStringArray: ArgumentFilterPredicate<string[]> = (input): input is string[] => {\n   return Array.isArray(input) && input.every(filterString);\n};\n\nexport const filterStringOrStringArray: ArgumentFilterPredicate<string | string[]> = (\n   input\n): input is string | string[] => {\n   return filterString(input) || (Array.isArray(input) && input.every(filterString));\n};\n\nexport function filterPlainObject<T extends Options>(input: T | unknown): input is T;\nexport function filterPlainObject<T extends Object>(input: T | unknown): input is T {\n   return !!input && objectToString(input) === '[object Object]';\n}\n\nexport function filterFunction(input: unknown): input is Function {\n   return typeof input === 'function';\n}\n\nexport const filterHasLength: ArgumentFilterPredicate<{ length: number }> = (\n   input\n): input is { length: number } => {\n   if (input == null || 'number|boolean|function'.includes(typeof input)) {\n      return false;\n   }\n   return Array.isArray(input) || typeof input === 'string' || typeof input.length === 'number';\n};\n", "/**\n * Known process exit codes used by the task parsers to determine whether an error\n * was one they can automatically handle\n */\nexport enum ExitCodes {\n   SUCCESS,\n   ERROR,\n   NOT_FOUND = -2,\n   UNCLEAN = 128,\n}\n", "import { TaskResponseFormat } from '../types';\n\nexport class GitOutputStreams<T extends TaskResponseFormat = Buffer> {\n   constructor(\n      public readonly stdOut: T,\n      public readonly stdErr: T\n   ) {}\n\n   asStrings(): GitOutputStreams<string> {\n      return new GitOutputStreams(this.stdOut.toString('utf8'), this.stdErr.toString('utf8'));\n   }\n}\n", "export class LineParser<T> {\n   protected matches: string[] = [];\n\n   private _regExp: RegExp[];\n\n   constructor(\n      regExp: RegExp | RegExp[],\n      useMatches?: (target: T, match: string[]) => boolean | void\n   ) {\n      this._regExp = Array.isArray(regExp) ? regExp : [regExp];\n      if (useMatches) {\n         this.useMatches = useMatches;\n      }\n   }\n\n   parse = (line: (offset: number) => string | undefined, target: T): boolean => {\n      this.resetMatches();\n\n      if (!this._regExp.every((reg, index) => this.addMatch(reg, index, line(index)))) {\n         return false;\n      }\n\n      return this.useMatches(target, this.prepareMatches()) !== false;\n   };\n\n   // @ts-ignore\n   protected useMatches(target: T, match: string[]): boolean | void {\n      throw new Error(`LineParser:useMatches not implemented`);\n   }\n\n   protected resetMatches() {\n      this.matches.length = 0;\n   }\n\n   protected prepareMatches() {\n      return this.matches;\n   }\n\n   protected addMatch(reg: RegExp, index: number, line?: string) {\n      const matched = line && reg.exec(line);\n      if (matched) {\n         this.pushMatch(index, matched);\n      }\n\n      return !!matched;\n   }\n\n   protected pushMatch(_index: number, matched: string[]) {\n      this.matches.push(...matched.slice(1));\n   }\n}\n\nexport class RemoteLineParser<T> extends LineParser<T> {\n   protected addMatch(reg: RegExp, index: number, line?: string): boolean {\n      return /^remote:\\s/.test(String(line)) && super.addMatch(reg, index, line);\n   }\n\n   protected pushMatch(index: number, matched: string[]) {\n      if (index > 0 || matched.length > 1) {\n         super.pushMatch(index, matched);\n      }\n   }\n}\n", "import { SimpleGitOptions } from '../types';\n\nconst defaultOptions: Omit<SimpleGitOptions, 'baseDir'> = {\n   binary: 'git',\n   maxConcurrentProcesses: 5,\n   config: [],\n   trimmed: false,\n};\n\nexport function createInstanceConfig(\n   ...options: Array<Partial<SimpleGitOptions> | undefined>\n): SimpleGitOptions {\n   const baseDir = process.cwd();\n   const config: SimpleGitOptions = Object.assign(\n      { baseDir, ...defaultOptions },\n      ...options.filter((o) => typeof o === 'object' && o)\n   );\n\n   config.baseDir = config.baseDir || baseDir;\n   config.trimmed = config.trimmed === true;\n\n   return config;\n}\n", "import {\n   filterArray,\n   filterFunction,\n   filterPlainObject,\n   filterPrimitives,\n   filterType,\n} from './argument-filters';\nimport { asFunction, isUserFunction, last } from './util';\nimport { Maybe, Options, OptionsValues } from '../types';\nimport { isPathSpec } from '../args/pathspec';\n\nexport function appendTaskOptions<T extends Options = Options>(\n   options: Maybe<T>,\n   commands: string[] = []\n): string[] {\n   if (!filterPlainObject<Options>(options)) {\n      return commands;\n   }\n\n   return Object.keys(options).reduce((commands: string[], key: string) => {\n      const value: OptionsValues = options[key];\n\n      if (isPathSpec(value)) {\n         commands.push(value);\n      } else if (filterPrimitives(value, ['boolean'])) {\n         commands.push(key + '=' + value);\n      } else {\n         commands.push(key);\n      }\n\n      return commands;\n   }, commands);\n}\n\nexport function getTrailingOptions(\n   args: IArguments,\n   initialPrimitive = 0,\n   objectOnly = false\n): string[] {\n   const command: string[] = [];\n\n   for (let i = 0, max = initialPrimitive < 0 ? args.length : initialPrimitive; i < max; i++) {\n      if ('string|number'.includes(typeof args[i])) {\n         command.push(String(args[i]));\n      }\n   }\n\n   appendTaskOptions(trailingOptionsArgument(args), command);\n   if (!objectOnly) {\n      command.push(...trailingArrayArgument(args));\n   }\n\n   return command;\n}\n\nfunction trailingArrayArgument(args: IArguments) {\n   const hasTrailingCallback = typeof last(args) === 'function';\n   return filterType(last(args, hasTrailingCallback ? 1 : 0), filterArray, []);\n}\n\n/**\n * Given any number of arguments, returns the trailing options argument, ignoring a trailing function argument\n * if there is one. When not found, the return value is null.\n */\nexport function trailingOptionsArgument(args: IArguments): Maybe<Options> {\n   const hasTrailingCallback = filterFunction(last(args));\n   return filterType(last(args, hasTrailingCallback ? 1 : 0), filterPlainObject);\n}\n\n/**\n * Returns either the source argument when it is a `Function`, or the default\n * `NOOP` function constant\n */\nexport function trailingFunctionArgument(\n   args: unknown[] | IArguments | unknown,\n   includeNoop = true\n): Maybe<(...args: any[]) => unknown> {\n   const callback = asFunction(last(args));\n   return includeNoop || isUserFunction(callback) ? callback : undefined;\n}\n", "import type { MaybeArray, TaskParser, TaskResponseFormat } from '../types';\nimport { GitOutputStreams } from './git-output-streams';\nimport { LineParser } from './line-parser';\nimport { asArray, toLinesWithContent } from './util';\n\nexport function callTaskParser<INPUT extends TaskResponseFormat, RESPONSE>(\n   parser: TaskParser<INPUT, RESPONSE>,\n   streams: GitOutputStreams<INPUT>\n) {\n   return parser(streams.stdOut, streams.stdErr);\n}\n\nexport function parseStringResponse<T>(\n   result: T,\n   parsers: LineParser<T>[],\n   texts: MaybeArray<string>,\n   trim = true\n): T {\n   asArray(texts).forEach((text) => {\n      for (let lines = toLinesWithContent(text, trim), i = 0, max = lines.length; i < max; i++) {\n         const line = (offset = 0) => {\n            if (i + offset >= max) {\n               return;\n            }\n            return lines[i + offset];\n         };\n\n         parsers.some(({ parse }) => parse(line, result));\n      }\n   });\n\n   return result;\n}\n", "export * from './argument-filters';\nexport * from './exit-codes';\nexport * from './git-output-streams';\nexport * from './line-parser';\nexport * from './simple-git-options';\nexport * from './task-options';\nexport * from './task-parser';\nexport * from './util';\n", "import { ExitCodes } from '../utils';\nimport { Maybe, StringTask } from '../types';\n\nexport enum CheckRepoActions {\n   BARE = 'bare',\n   IN_TREE = 'tree',\n   IS_REPO_ROOT = 'root',\n}\n\nconst onError: StringTask<boolean>['onError'] = ({ exitCode }, error, done, fail) => {\n   if (exitCode === ExitCodes.UNCLEAN && isNotRepoMessage(error)) {\n      return done(Buffer.from('false'));\n   }\n\n   fail(error);\n};\n\nconst parser: StringTask<boolean>['parser'] = (text) => {\n   return text.trim() === 'true';\n};\n\nexport function checkIsRepoTask(action: Maybe<CheckRepoActions>): StringTask<boolean> {\n   switch (action) {\n      case CheckRepoActions.BARE:\n         return checkIsBareRepoTask();\n      case CheckRepoActions.IS_REPO_ROOT:\n         return checkIsRepoRootTask();\n   }\n\n   const commands = ['rev-parse', '--is-inside-work-tree'];\n\n   return {\n      commands,\n      format: 'utf-8',\n      onError,\n      parser,\n   };\n}\n\nexport function checkIsRepoRootTask(): StringTask<boolean> {\n   const commands = ['rev-parse', '--git-dir'];\n\n   return {\n      commands,\n      format: 'utf-8',\n      onError,\n      parser(path) {\n         return /^\\.(git)?$/.test(path.trim());\n      },\n   };\n}\n\nexport function checkIsBareRepoTask(): StringTask<boolean> {\n   const commands = ['rev-parse', '--is-bare-repository'];\n\n   return {\n      commands,\n      format: 'utf-8',\n      onError,\n      parser,\n   };\n}\n\nfunction isNotRepoMessage(error: Error): boolean {\n   return /(Not a git repository|Kein Git-Repository)/i.test(String(error));\n}\n", "import { CleanSummary } from '../../../typings';\nimport { toLinesWithContent } from '../utils';\n\nexport class CleanResponse implements CleanSummary {\n   public paths: string[] = [];\n   public files: string[] = [];\n   public folders: string[] = [];\n\n   constructor(public readonly dryRun: boolean) {}\n}\n\nconst removalRegexp = /^[a-z]+\\s*/i;\nconst dryRunRemovalRegexp = /^[a-z]+\\s+[a-z]+\\s*/i;\nconst isFolderRegexp = /\\/$/;\n\nexport function cleanSummaryParser(dryRun: boolean, text: string): CleanSummary {\n   const summary = new CleanResponse(dryRun);\n   const regexp = dryRun ? dryRunRemovalRegexp : removalRegexp;\n\n   toLinesWithContent(text).forEach((line) => {\n      const removed = line.replace(regexp, '');\n\n      summary.paths.push(removed);\n      (isFolderRegexp.test(removed) ? summary.folders : summary.files).push(removed);\n   });\n\n   return summary;\n}\n", "import { TaskConfigurationError } from '../errors/task-configuration-error';\nimport type { BufferTask, EmptyTaskParser, SimpleGitTask, StringTask } from '../types';\n\nexport const EMPTY_COMMANDS: [] = [];\n\nexport type EmptyTask = {\n   commands: typeof EMPTY_COMMANDS;\n   format: 'empty';\n   parser: EmptyTaskParser;\n   onError?: undefined;\n};\n\nexport function adhocExecTask(parser: EmptyTaskParser): EmptyTask {\n   return {\n      commands: EMPTY_COMMANDS,\n      format: 'empty',\n      parser,\n   };\n}\n\nexport function configurationErrorTask(error: Error | string): EmptyTask {\n   return {\n      commands: EMPTY_COMMANDS,\n      format: 'empty',\n      parser() {\n         throw typeof error === 'string' ? new TaskConfigurationError(error) : error;\n      },\n   };\n}\n\nexport function straightThroughStringTask(commands: string[], trimmed = false): StringTask<string> {\n   return {\n      commands,\n      format: 'utf-8',\n      parser(text) {\n         return trimmed ? String(text).trim() : text;\n      },\n   };\n}\n\nexport function straightThroughBufferTask(commands: string[]): BufferTask<any> {\n   return {\n      commands,\n      format: 'buffer',\n      parser(buffer) {\n         return buffer;\n      },\n   };\n}\n\nexport function isBufferTask<R>(task: SimpleGitTask<R>): task is BufferTask<R> {\n   return task.format === 'buffer';\n}\n\nexport function isEmptyTask<R>(task: SimpleGitTask<R>): task is EmptyTask {\n   return task.format === 'empty' || !task.commands.length;\n}\n", "import { CleanSummary } from '../../../typings';\nimport { cleanSummaryParser } from '../responses/CleanSummary';\nimport { Maybe, StringTask } from '../types';\nimport { asStringArray } from '../utils';\nimport { configurationErrorTask } from './task';\n\nexport const CONFIG_ERROR_INTERACTIVE_MODE = 'Git clean interactive mode is not supported';\nexport const CONFIG_ERROR_MODE_REQUIRED = 'Git clean mode parameter (\"n\" or \"f\") is required';\nexport const CONFIG_ERROR_UNKNOWN_OPTION = 'Git clean unknown option found in: ';\n\n/**\n * All supported option switches available for use in a `git.clean` operation\n */\nexport enum CleanOptions {\n   DRY_RUN = 'n',\n   FORCE = 'f',\n   IGNORED_INCLUDED = 'x',\n   IGNORED_ONLY = 'X',\n   EXCLUDING = 'e',\n   QUIET = 'q',\n   RECURSIVE = 'd',\n}\n\n/**\n * The two modes `git.clean` can run in - one of these must be supplied in order\n * for the command to not throw a `TaskConfigurationError`\n */\nexport type CleanMode = CleanOptions.FORCE | CleanOptions.DRY_RUN;\n\nconst CleanOptionValues: Set<string> = new Set([\n   'i',\n   ...asStringArray(Object.values(CleanOptions as any)),\n]);\n\nexport function cleanWithOptionsTask(mode: CleanMode | string, customArgs: string[]) {\n   const { cleanMode, options, valid } = getCleanOptions(mode);\n\n   if (!cleanMode) {\n      return configurationErrorTask(CONFIG_ERROR_MODE_REQUIRED);\n   }\n\n   if (!valid.options) {\n      return configurationErrorTask(CONFIG_ERROR_UNKNOWN_OPTION + JSON.stringify(mode));\n   }\n\n   options.push(...customArgs);\n\n   if (options.some(isInteractiveMode)) {\n      return configurationErrorTask(CONFIG_ERROR_INTERACTIVE_MODE);\n   }\n\n   return cleanTask(cleanMode, options);\n}\n\nexport function cleanTask(mode: CleanMode, customArgs: string[]): StringTask<CleanSummary> {\n   const commands: string[] = ['clean', `-${mode}`, ...customArgs];\n\n   return {\n      commands,\n      format: 'utf-8',\n      parser(text: string): CleanSummary {\n         return cleanSummaryParser(mode === CleanOptions.DRY_RUN, text);\n      },\n   };\n}\n\nexport function isCleanOptionsArray(input: string[]): input is CleanOptions[] {\n   return Array.isArray(input) && input.every((test) => CleanOptionValues.has(test));\n}\n\nfunction getCleanOptions(input: string) {\n   let cleanMode: Maybe<CleanMode>;\n   let options: string[] = [];\n   let valid = { cleanMode: false, options: true };\n\n   input\n      .replace(/[^a-z]i/g, '')\n      .split('')\n      .forEach((char) => {\n         if (isCleanMode(char)) {\n            cleanMode = char;\n            valid.cleanMode = true;\n         } else {\n            valid.options = valid.options && isKnownOption((options[options.length] = `-${char}`));\n         }\n      });\n\n   return {\n      cleanMode,\n      options,\n      valid,\n   };\n}\n\nfunction isCleanMode(cleanMode?: string): cleanMode is CleanMode {\n   return cleanMode === CleanOptions.FORCE || cleanMode === CleanOptions.DRY_RUN;\n}\n\nfunction isKnownOption(option: string): boolean {\n   return /^-[a-z]$/i.test(option) && CleanOptionValues.has(option.charAt(1));\n}\n\nfunction isInteractiveMode(option: string): boolean {\n   if (/^-[^\\-]/.test(option)) {\n      return option.indexOf('i') > 0;\n   }\n\n   return option === '--interactive';\n}\n", "import { ConfigGetResult, ConfigListSummary, ConfigValues } from '../../../typings';\nimport { last, splitOn } from '../utils';\n\nexport class ConfigList implements ConfigListSummary {\n   public files: string[] = [];\n   public values: { [fileName: string]: ConfigValues } = Object.create(null);\n\n   private _all: ConfigValues | undefined;\n\n   public get all(): ConfigValues {\n      if (!this._all) {\n         this._all = this.files.reduce((all: ConfigValues, file: string) => {\n            return Object.assign(all, this.values[file]);\n         }, {});\n      }\n\n      return this._all;\n   }\n\n   public addFile(file: string): ConfigValues {\n      if (!(file in this.values)) {\n         const latest = last(this.files);\n         this.values[file] = latest ? Object.create(this.values[latest]) : {};\n\n         this.files.push(file);\n      }\n\n      return this.values[file];\n   }\n\n   public addValue(file: string, key: string, value: string) {\n      const values = this.addFile(file);\n\n      if (!values.hasOwnProperty(key)) {\n         values[key] = value;\n      } else if (Array.isArray(values[key])) {\n         (values[key] as string[]).push(value);\n      } else {\n         values[key] = [values[key] as string, value];\n      }\n\n      this._all = undefined;\n   }\n}\n\nexport function configListParser(text: string): ConfigList {\n   const config = new ConfigList();\n\n   for (const item of configParser(text)) {\n      config.addValue(item.file, String(item.key), item.value);\n   }\n\n   return config;\n}\n\nexport function configGetParser(text: string, key: string): ConfigGetResult {\n   let value: string | null = null;\n   const values: string[] = [];\n   const scopes: Map<string, string[]> = new Map();\n\n   for (const item of configParser(text, key)) {\n      if (item.key !== key) {\n         continue;\n      }\n\n      values.push((value = item.value));\n\n      if (!scopes.has(item.file)) {\n         scopes.set(item.file, []);\n      }\n\n      scopes.get(item.file)!.push(value);\n   }\n\n   return {\n      key,\n      paths: Array.from(scopes.keys()),\n      scopes,\n      value,\n      values,\n   };\n}\n\nfunction configFilePath(filePath: string): string {\n   return filePath.replace(/^(file):/, '');\n}\n\nfunction* configParser(text: string, requestedKey: string | null = null) {\n   const lines = text.split('\\0');\n\n   for (let i = 0, max = lines.length - 1; i < max; ) {\n      const file = configFilePath(lines[i++]);\n\n      let value = lines[i++];\n      let key = requestedKey;\n\n      if (value.includes('\\n')) {\n         const line = splitOn(value, '\\n');\n         key = line[0];\n         value = line[1];\n      }\n\n      yield { file, key, value };\n   }\n}\n", "import type { ConfigGetResult, ConfigListSummary, SimpleGit } from '../../../typings';\nimport { configGetParser, configListParser } from '../responses/ConfigList';\nimport type { SimpleGitApi } from '../simple-git-api';\nimport type { StringTask } from '../types';\nimport { trailingFunctionArgument } from '../utils';\n\nexport enum GitConfigScope {\n   system = 'system',\n   global = 'global',\n   local = 'local',\n   worktree = 'worktree',\n}\n\nfunction asConfigScope<T extends GitConfigScope | undefined>(\n   scope: GitConfigScope | unknown,\n   fallback: T\n): GitConfigScope | T {\n   if (typeof scope === 'string' && GitConfigScope.hasOwnProperty(scope)) {\n      return scope as GitConfigScope;\n   }\n   return fallback;\n}\n\nfunction addConfigTask(\n   key: string,\n   value: string,\n   append: boolean,\n   scope: GitConfigScope\n): StringTask<string> {\n   const commands: string[] = ['config', `--${scope}`];\n\n   if (append) {\n      commands.push('--add');\n   }\n\n   commands.push(key, value);\n\n   return {\n      commands,\n      format: 'utf-8',\n      parser(text: string): string {\n         return text;\n      },\n   };\n}\n\nfunction getConfigTask(key: string, scope?: GitConfigScope): StringTask<ConfigGetResult> {\n   const commands: string[] = ['config', '--null', '--show-origin', '--get-all', key];\n\n   if (scope) {\n      commands.splice(1, 0, `--${scope}`);\n   }\n\n   return {\n      commands,\n      format: 'utf-8',\n      parser(text) {\n         return configGetParser(text, key);\n      },\n   };\n}\n\nfunction listConfigTask(scope?: GitConfigScope): StringTask<ConfigListSummary> {\n   const commands = ['config', '--list', '--show-origin', '--null'];\n\n   if (scope) {\n      commands.push(`--${scope}`);\n   }\n\n   return {\n      commands,\n      format: 'utf-8',\n      parser(text: string) {\n         return configListParser(text);\n      },\n   };\n}\n\nexport default function (): Pick<SimpleGit, 'addConfig' | 'getConfig' | 'listConfig'> {\n   return {\n      addConfig(this: SimpleGitApi, key: string, value: string, ...rest: unknown[]) {\n         return this._runTask(\n            addConfigTask(\n               key,\n               value,\n               rest[0] === true,\n               asConfigScope(rest[1], GitConfigScope.local)\n            ),\n            trailingFunctionArgument(arguments)\n         );\n      },\n\n      getConfig(this: SimpleGitApi, key: string, scope?: GitConfigScope) {\n         return this._runTask(\n            getConfigTask(key, asConfigScope(scope, undefined)),\n            trailingFunctionArgument(arguments)\n         );\n      },\n\n      listConfig(this: SimpleGitApi, ...rest: unknown[]) {\n         return this._runTask(\n            listConfigTask(asConfigScope(rest[0], undefined)),\n            trailingFunctionArgument(arguments)\n         );\n      },\n   };\n}\n", "export enum DiffNameStatus {\n   ADDED = 'A',\n   COPIED = 'C',\n   DELETED = 'D',\n   MODIFIED = 'M',\n   RENAMED = 'R',\n   CHANGED = 'T',\n   UNMERGED = 'U',\n   UNKNOWN = 'X',\n   BROKEN = 'B',\n}\n\nconst diffNameStatus = new Set(Object.values(DiffNameStatus));\n\nexport function isDiffNameStatus(input: string): input is DiffNameStatus {\n   return diffNameStatus.has(input as DiffNameStatus);\n}\n", "import { GrepResult, SimpleGit } from '../../../typings';\nimport { SimpleGitApi } from '../simple-git-api';\nimport {\n   asNumber,\n   forEachLineWithContent,\n   getTrailingOptions,\n   NULL,\n   prefixedArray,\n   trailingFunctionArgument,\n} from '../utils';\n\nimport { configurationErrorTask } from './task';\n\nconst disallowedOptions = ['-h'];\n\nconst Query = Symbol('grepQuery');\n\nexport interface GitGrepQuery extends Iterable<string> {\n   /** Adds one or more terms to be grouped as an \"and\" to any other terms */\n   and(...and: string[]): this;\n\n   /** Adds one or more search terms - git.grep will \"or\" this to other terms */\n   param(...param: string[]): this;\n}\n\nclass GrepQuery implements GitGrepQuery {\n   private [Query]: string[] = [];\n\n   *[Symbol.iterator]() {\n      for (const query of this[Query]) {\n         yield query;\n      }\n   }\n\n   and(...and: string[]) {\n      and.length && this[Query].push('--and', '(', ...prefixedArray(and, '-e'), ')');\n      return this;\n   }\n\n   param(...param: string[]) {\n      this[Query].push(...prefixedArray(param, '-e'));\n      return this;\n   }\n}\n\n/**\n * Creates a new builder for a `git.grep` query with optional params\n */\nexport function grepQueryBuilder(...params: string[]): GitGrepQuery {\n   return new GrepQuery().param(...params);\n}\n\nfunction parseGrep(grep: string): GrepResult {\n   const paths: GrepResult['paths'] = new Set<string>();\n   const results: GrepResult['results'] = {};\n\n   forEachLineWithContent(grep, (input) => {\n      const [path, line, preview] = input.split(NULL);\n      paths.add(path);\n      (results[path] = results[path] || []).push({\n         line: asNumber(line),\n         path,\n         preview,\n      });\n   });\n\n   return {\n      paths,\n      results,\n   };\n}\n\nexport default function (): Pick<SimpleGit, 'grep'> {\n   return {\n      grep(this: SimpleGitApi, searchTerm: string | GitGrepQuery) {\n         const then = trailingFunctionArgument(arguments);\n         const options = getTrailingOptions(arguments);\n\n         for (const option of disallowedOptions) {\n            if (options.includes(option)) {\n               return this._runTask(\n                  configurationErrorTask(`git.grep: use of \"${option}\" is not supported.`),\n                  then\n               );\n            }\n         }\n\n         if (typeof searchTerm === 'string') {\n            searchTerm = grepQueryBuilder().param(searchTerm);\n         }\n\n         const commands = ['grep', '--null', '-n', '--full-name', ...options, ...searchTerm];\n\n         return this._runTask(\n            {\n               commands,\n               format: 'utf-8',\n               parser(stdOut) {\n                  return parseGrep(stdOut);\n               },\n            },\n            then\n         );\n      },\n   };\n}\n", "import { straightThroughStringTask } from './task';\nimport { Maybe, OptionFlags, Options } from '../types';\n\nexport enum ResetMode {\n   MIXED = 'mixed',\n   SOFT = 'soft',\n   HARD = 'hard',\n   MERGE = 'merge',\n   KEEP = 'keep',\n}\n\nconst ResetModes = Array.from(Object.values(ResetMode));\n\nexport type ResetOptions = Options &\n   OptionFlags<'-q' | '--quiet' | '--no-quiet' | '--pathspec-from-nul'> &\n   OptionFlags<'--pathspec-from-file', string>;\n\nexport function resetTask(mode: Maybe<ResetMode>, customArgs: string[]) {\n   const commands: string[] = ['reset'];\n   if (isValidResetMode(mode)) {\n      commands.push(`--${mode}`);\n   }\n   commands.push(...customArgs);\n\n   return straightThroughStringTask(commands);\n}\n\nexport function getResetMode(mode: ResetMode | any): Maybe<ResetMode> {\n   if (isValidResetMode(mode)) {\n      return mode;\n   }\n\n   switch (typeof mode) {\n      case 'string':\n      case 'undefined':\n         return ResetMode.SOFT;\n   }\n\n   return;\n}\n\nfunction isValidResetMode(mode: ResetMode | any): mode is ResetMode {\n   return ResetModes.includes(mode);\n}\n", "import debug, { Debugger } from 'debug';\nimport {\n   append,\n   filterHasLength,\n   filterString,\n   filterType,\n   NOOP,\n   objectToString,\n   remove,\n} from './utils';\nimport { Maybe } from './types';\n\ndebug.formatters.L = (value: any) => String(filterHasLength(value) ? value.length : '-');\ndebug.formatters.B = (value: Buffer) => {\n   if (Buffer.isBuffer(value)) {\n      return value.toString('utf8');\n   }\n   return objectToString(value);\n};\n\ntype OutputLoggingHandler = (message: string, ...args: any[]) => void;\n\nfunction createLog() {\n   return debug('simple-git');\n}\n\nexport interface OutputLogger extends OutputLoggingHandler {\n   readonly label: string;\n\n   info: OutputLoggingHandler;\n   step(nextStep?: string): OutputLogger;\n   sibling(name: string): OutputLogger;\n}\n\nfunction prefixedLogger(\n   to: Debugger,\n   prefix: string,\n   forward?: OutputLoggingHandler\n): OutputLoggingHandler {\n   if (!prefix || !String(prefix).replace(/\\s*/, '')) {\n      return !forward\n         ? to\n         : (message, ...args) => {\n              to(message, ...args);\n              forward(message, ...args);\n           };\n   }\n\n   return (message, ...args) => {\n      to(`%s ${message}`, prefix, ...args);\n      if (forward) {\n         forward(message, ...args);\n      }\n   };\n}\n\nfunction childLoggerName(\n   name: Maybe<string>,\n   childDebugger: Maybe<Debugger>,\n   { namespace: parentNamespace }: Debugger\n): string {\n   if (typeof name === 'string') {\n      return name;\n   }\n   const childNamespace = (childDebugger && childDebugger.namespace) || '';\n\n   if (childNamespace.startsWith(parentNamespace)) {\n      return childNamespace.substr(parentNamespace.length + 1);\n   }\n\n   return childNamespace || parentNamespace;\n}\n\nexport function createLogger(\n   label: string,\n   verbose?: string | Debugger,\n   initialStep?: string,\n   infoDebugger = createLog()\n): OutputLogger {\n   const labelPrefix = (label && `[${label}]`) || '';\n\n   const spawned: OutputLogger[] = [];\n   const debugDebugger: Maybe<Debugger> =\n      typeof verbose === 'string' ? infoDebugger.extend(verbose) : verbose;\n   const key = childLoggerName(filterType(verbose, filterString), debugDebugger, infoDebugger);\n\n   return step(initialStep);\n\n   function sibling(name: string, initial?: string) {\n      return append(\n         spawned,\n         createLogger(label, key.replace(/^[^:]+/, name), initial, infoDebugger)\n      );\n   }\n\n   function step(phase?: string) {\n      const stepPrefix = (phase && `[${phase}]`) || '';\n      const debug = (debugDebugger && prefixedLogger(debugDebugger, stepPrefix)) || NOOP;\n      const info = prefixedLogger(infoDebugger, `${labelPrefix} ${stepPrefix}`, debug);\n\n      return Object.assign(debugDebugger ? debug : info, {\n         label,\n         sibling,\n         info,\n         step,\n      });\n   }\n}\n\n/**\n * The `GitLogger` is used by the main `SimpleGit` runner to handle logging\n * any warnings or errors.\n */\nexport class GitLogger {\n   public error: OutputLoggingHandler;\n\n   public warn: OutputLoggingHandler;\n\n   constructor(private _out: Debugger = createLog()) {\n      this.error = prefixedLogger(_out, '[ERROR]');\n      this.warn = prefixedLogger(_out, '[WARN]');\n   }\n\n   silent(silence = false) {\n      if (silence !== this._out.enabled) {\n         return;\n      }\n\n      const { namespace } = this._out;\n      const env = (process.env.DEBUG || '').split(',').filter((s) => !!s);\n      const hasOn = env.includes(namespace);\n      const hasOff = env.includes(`-${namespace}`);\n\n      // enabling the log\n      if (!silence) {\n         if (hasOff) {\n            remove(env, `-${namespace}`);\n         } else {\n            env.push(namespace);\n         }\n      } else {\n         if (hasOn) {\n            remove(env, namespace);\n         } else {\n            env.push(`-${namespace}`);\n         }\n      }\n\n      debug.enable(env.join(','));\n   }\n}\n", "import { SimpleGitTask } from '../types';\nimport { GitError } from '../errors/git-error';\nimport { createLogger, OutputLogger } from '../git-logger';\n\ntype AnySimpleGitTask = SimpleGitTask<any>;\n\ntype TaskInProgress = {\n   name: string;\n   logger: OutputLogger;\n   task: AnySimpleGitTask;\n};\n\nexport class TasksPendingQueue {\n   private _queue: Map<AnySimpleGitTask, TaskInProgress> = new Map();\n\n   constructor(private logLabel = 'GitExecutor') {}\n\n   private withProgress(task: AnySimpleGitTask) {\n      return this._queue.get(task);\n   }\n\n   private createProgress(task: AnySimpleGitTask): TaskInProgress {\n      const name = TasksPendingQueue.getName(task.commands[0]);\n      const logger = createLogger(this.logLabel, name);\n\n      return {\n         task,\n         logger,\n         name,\n      };\n   }\n\n   push(task: AnySimpleGitTask): TaskInProgress {\n      const progress = this.createProgress(task);\n      progress.logger('Adding task to the queue, commands = %o', task.commands);\n\n      this._queue.set(task, progress);\n\n      return progress;\n   }\n\n   fatal(err: GitError) {\n      for (const [task, { logger }] of Array.from(this._queue.entries())) {\n         if (task === err.task) {\n            logger.info(`Failed %o`, err);\n            logger(\n               `Fatal exception, any as-yet un-started tasks run through this executor will not be attempted`\n            );\n         } else {\n            logger.info(\n               `A fatal exception occurred in a previous task, the queue has been purged: %o`,\n               err.message\n            );\n         }\n\n         this.complete(task);\n      }\n\n      if (this._queue.size !== 0) {\n         throw new Error(`Queue size should be zero after fatal: ${this._queue.size}`);\n      }\n   }\n\n   complete(task: AnySimpleGitTask) {\n      const progress = this.withProgress(task);\n      if (progress) {\n         this._queue.delete(task);\n      }\n   }\n\n   attempt(task: AnySimpleGitTask): TaskInProgress {\n      const progress = this.withProgress(task);\n      if (!progress) {\n         throw new GitError(undefined, 'TasksPendingQueue: attempt called for an unknown task');\n      }\n      progress.logger('Starting task');\n\n      return progress;\n   }\n\n   static getName(name = 'empty') {\n      return `task:${name}:${++TasksPendingQueue.counter}`;\n   }\n\n   private static counter = 0;\n}\n", "import { spawn, SpawnOptions } from 'child_process';\nimport { GitError } from '../errors/git-error';\nimport { OutputLogger } from '../git-logger';\nimport { PluginStore } from '../plugins';\nimport { EmptyTask, isBufferTask, isEmptyTask } from '../tasks/task';\nimport {\n   GitExecutorResult,\n   Maybe,\n   outputHandler,\n   RunnableTask,\n   SimpleGitExecutor,\n   SimpleGitTask,\n} from '../types';\nimport { callTaskParser, first, GitOutputStreams, objectToString } from '../utils';\nimport { Scheduler } from './scheduler';\nimport { TasksPendingQueue } from './tasks-pending-queue';\n\nexport class GitExecutorChain implements SimpleGitExecutor {\n   private _chain: Promise<any> = Promise.resolve();\n   private _queue = new TasksPendingQueue();\n   private _cwd: string | undefined;\n\n   public get binary() {\n      return this._executor.binary;\n   }\n\n   public get cwd() {\n      return this._cwd || this._executor.cwd;\n   }\n\n   public set cwd(cwd: string) {\n      this._cwd = cwd;\n   }\n\n   public get env() {\n      return this._executor.env;\n   }\n\n   public get outputHandler() {\n      return this._executor.outputHandler;\n   }\n\n   constructor(\n      private _executor: SimpleGitExecutor,\n      private _scheduler: Scheduler,\n      private _plugins: PluginStore\n   ) {}\n\n   public chain() {\n      return this;\n   }\n\n   public push<R>(task: SimpleGitTask<R>): Promise<R> {\n      this._queue.push(task);\n\n      return (this._chain = this._chain.then(() => this.attemptTask(task)));\n   }\n\n   private async attemptTask<R>(task: SimpleGitTask<R>): Promise<void | R> {\n      const onScheduleComplete = await this._scheduler.next();\n      const onQueueComplete = () => this._queue.complete(task);\n\n      try {\n         const { logger } = this._queue.attempt(task);\n         return (await (isEmptyTask(task)\n            ? this.attemptEmptyTask(task, logger)\n            : this.attemptRemoteTask(task, logger))) as R;\n      } catch (e) {\n         throw this.onFatalException(task, e as Error);\n      } finally {\n         onQueueComplete();\n         onScheduleComplete();\n      }\n   }\n\n   private onFatalException<R>(task: SimpleGitTask<R>, e: Error) {\n      const gitError =\n         e instanceof GitError ? Object.assign(e, { task }) : new GitError(task, e && String(e));\n\n      this._chain = Promise.resolve();\n      this._queue.fatal(gitError);\n\n      return gitError;\n   }\n\n   private async attemptRemoteTask<R>(task: RunnableTask<R>, logger: OutputLogger) {\n      const args = this._plugins.exec(\n         'spawn.args',\n         [...task.commands],\n         pluginContext(task, task.commands)\n      );\n\n      const raw = await this.gitResponse(\n         task,\n         this.binary,\n         args,\n         this.outputHandler,\n         logger.step('SPAWN')\n      );\n      const outputStreams = await this.handleTaskData(task, args, raw, logger.step('HANDLE'));\n\n      logger(`passing response to task's parser as a %s`, task.format);\n\n      if (isBufferTask(task)) {\n         return callTaskParser(task.parser, outputStreams);\n      }\n\n      return callTaskParser(task.parser, outputStreams.asStrings());\n   }\n\n   private async attemptEmptyTask(task: EmptyTask, logger: OutputLogger) {\n      logger(`empty task bypassing child process to call to task's parser`);\n      return task.parser(this);\n   }\n\n   private handleTaskData<R>(\n      task: SimpleGitTask<R>,\n      args: string[],\n      result: GitExecutorResult,\n      logger: OutputLogger\n   ): Promise<GitOutputStreams> {\n      const { exitCode, rejection, stdOut, stdErr } = result;\n\n      return new Promise((done, fail) => {\n         logger(`Preparing to handle process response exitCode=%d stdOut=`, exitCode);\n\n         const { error } = this._plugins.exec(\n            'task.error',\n            { error: rejection },\n            {\n               ...pluginContext(task, args),\n               ...result,\n            }\n         );\n\n         if (error && task.onError) {\n            logger.info(`exitCode=%s handling with custom error handler`);\n\n            return task.onError(\n               result,\n               error,\n               (newStdOut) => {\n                  logger.info(`custom error handler treated as success`);\n                  logger(`custom error returned a %s`, objectToString(newStdOut));\n\n                  done(\n                     new GitOutputStreams(\n                        Array.isArray(newStdOut) ? Buffer.concat(newStdOut) : newStdOut,\n                        Buffer.concat(stdErr)\n                     )\n                  );\n               },\n               fail\n            );\n         }\n\n         if (error) {\n            logger.info(\n               `handling as error: exitCode=%s stdErr=%s rejection=%o`,\n               exitCode,\n               stdErr.length,\n               rejection\n            );\n            return fail(error);\n         }\n\n         logger.info(`retrieving task output complete`);\n         done(new GitOutputStreams(Buffer.concat(stdOut), Buffer.concat(stdErr)));\n      });\n   }\n\n   private async gitResponse<R>(\n      task: SimpleGitTask<R>,\n      command: string,\n      args: string[],\n      outputHandler: Maybe<outputHandler>,\n      logger: OutputLogger\n   ): Promise<GitExecutorResult> {\n      const outputLogger = logger.sibling('output');\n      const spawnOptions: SpawnOptions = this._plugins.exec(\n         'spawn.options',\n         {\n            cwd: this.cwd,\n            env: this.env,\n            windowsHide: true,\n         },\n         pluginContext(task, task.commands)\n      );\n\n      return new Promise((done) => {\n         const stdOut: Buffer[] = [];\n         const stdErr: Buffer[] = [];\n\n         logger.info(`%s %o`, command, args);\n         logger('%O', spawnOptions);\n\n         let rejection = this._beforeSpawn(task, args);\n         if (rejection) {\n            return done({\n               stdOut,\n               stdErr,\n               exitCode: 9901,\n               rejection,\n            });\n         }\n\n         this._plugins.exec('spawn.before', undefined, {\n            ...pluginContext(task, args),\n            kill(reason) {\n               rejection = reason || rejection;\n            },\n         });\n\n         const spawned = spawn(command, args, spawnOptions);\n\n         spawned.stdout!.on(\n            'data',\n            onDataReceived(stdOut, 'stdOut', logger, outputLogger.step('stdOut'))\n         );\n         spawned.stderr!.on(\n            'data',\n            onDataReceived(stdErr, 'stdErr', logger, outputLogger.step('stdErr'))\n         );\n\n         spawned.on('error', onErrorReceived(stdErr, logger));\n\n         if (outputHandler) {\n            logger(`Passing child process stdOut/stdErr to custom outputHandler`);\n            outputHandler(command, spawned.stdout!, spawned.stderr!, [...args]);\n         }\n\n         this._plugins.exec('spawn.after', undefined, {\n            ...pluginContext(task, args),\n            spawned,\n            close(exitCode: number, reason?: Error) {\n               done({\n                  stdOut,\n                  stdErr,\n                  exitCode,\n                  rejection: rejection || reason,\n               });\n            },\n            kill(reason: Error) {\n               if (spawned.killed) {\n                  return;\n               }\n\n               rejection = reason;\n               spawned.kill('SIGINT');\n            },\n         });\n      });\n   }\n\n   private _beforeSpawn<R>(task: SimpleGitTask<R>, args: string[]) {\n      let rejection: Maybe<Error>;\n      this._plugins.exec('spawn.before', undefined, {\n         ...pluginContext(task, args),\n         kill(reason) {\n            rejection = reason || rejection;\n         },\n      });\n\n      return rejection;\n   }\n}\n\nfunction pluginContext<R>(task: SimpleGitTask<R>, commands: string[]) {\n   return {\n      method: first(task.commands) || '',\n      commands,\n   };\n}\n\nfunction onErrorReceived(target: Buffer[], logger: OutputLogger) {\n   return (err: Error) => {\n      logger(`[ERROR] child process exception %o`, err);\n      target.push(Buffer.from(String(err.stack), 'ascii'));\n   };\n}\n\nfunction onDataReceived(\n   target: Buffer[],\n   name: string,\n   logger: OutputLogger,\n   output: OutputLogger\n) {\n   return (buffer: Buffer) => {\n      logger(`%s received %L bytes`, name, buffer);\n      output(`%B`, buffer);\n      target.push(buffer);\n   };\n}\n", "import type { PluginStore } from '../plugins';\nimport type { GitExecutorEnv, outputHandler, SimpleGitExecutor, SimpleGitTask } from '../types';\n\nimport { GitExecutorChain } from './git-executor-chain';\nimport { Scheduler } from './scheduler';\n\nexport class GitExecutor implements SimpleGitExecutor {\n   private _chain = new GitExecutorChain(this, this._scheduler, this._plugins);\n\n   public env: GitExecutorEnv;\n   public outputHandler?: outputHandler;\n\n   constructor(\n      public binary: string = 'git',\n      public cwd: string,\n      private _scheduler: Scheduler,\n      private _plugins: PluginStore\n   ) {}\n\n   chain(): SimpleGitExecutor {\n      return new GitExecutorChain(this, this._scheduler, this._plugins);\n   }\n\n   push<R>(task: SimpleGitTask<R>): Promise<R> {\n      return this._chain.push(task);\n   }\n}\n", "import { GitError } from './errors/git-error';\nimport { GitResponseError } from './errors/git-response-error';\nimport { SimpleGitTask, SimpleGitTaskCallback } from './types';\nimport { NOOP } from './utils';\n\nexport function taskCallback<R>(\n   task: SimpleGitTask<R>,\n   response: Promise<R>,\n   callback: SimpleGitTaskCallback<R> = NOOP\n) {\n   const onSuccess = (data: R) => {\n      callback(null, data);\n   };\n\n   const onError = (err: GitError | GitResponseError) => {\n      if (err?.task === task) {\n         callback(\n            err instanceof GitResponseError ? addDeprecationNoticeToError(err) : err,\n            undefined as any\n         );\n      }\n   };\n\n   response.then(onSuccess, onError);\n}\n\nfunction addDeprecationNoticeToError(err: GitResponseError) {\n   let log = (name: string) => {\n      console.warn(\n         `simple-git deprecation notice: accessing GitResponseError.${name} should be GitResponseError.git.${name}, this will no longer be available in version 3`\n      );\n      log = NOOP;\n   };\n\n   return Object.create(err, Object.getOwnPropertyNames(err.git).reduce(descriptorReducer, {}));\n\n   function descriptorReducer(all: PropertyDescriptorMap, name: string): typeof all {\n      if (name in err) {\n         return all;\n      }\n\n      all[name] = {\n         enumerable: false,\n         configurable: false,\n         get() {\n            log(name);\n            return err.git[name];\n         },\n      };\n\n      return all;\n   }\n}\n", "import { folderExists } from '../utils';\nimport { SimpleGitExecutor } from '../types';\nimport { adhocExecTask } from './task';\n\nexport function changeWorkingDirectoryTask(directory: string, root?: SimpleGitExecutor) {\n   return adhocExecTask((instance: SimpleGitExecutor) => {\n      if (!folderExists(directory)) {\n         throw new Error(`Git.cwd: cannot change to non-directory \"${directory}\"`);\n      }\n\n      return ((root || instance).cwd = directory);\n   });\n}\n", "import type { SimpleGit } from '../../../typings';\nimport type { SimpleGitApi } from '../simple-git-api';\nimport { getTrailingOptions, remove, trailingFunctionArgument } from '../utils';\nimport { straightThroughStringTask } from './task';\n\nfunction checkoutTask(args: string[]) {\n   const commands = ['checkout', ...args];\n   if (commands[1] === '-b' && commands.includes('-B')) {\n      commands[1] = remove(commands, '-B');\n   }\n\n   return straightThroughStringTask(commands);\n}\n\nexport default function (): Pick<SimpleGit, 'checkout' | 'checkoutBranch' | 'checkoutLocalBranch'> {\n   return {\n      checkout(this: SimpleGitApi) {\n         return this._runTask(\n            checkoutTask(getTrailingOptions(arguments, 1)),\n            trailingFunctionArgument(arguments)\n         );\n      },\n\n      checkoutBranch(this: SimpleGitApi, branchName, startPoint) {\n         return this._runTask(\n            checkoutTask(['-b', branchName, startPoint, ...getTrailingOptions(arguments)]),\n            trailingFunctionArgument(arguments)\n         );\n      },\n\n      checkoutLocalBranch(this: SimpleGitApi, branchName) {\n         return this._runTask(\n            checkoutTask(['-b', branchName, ...getTrailingOptions(arguments)]),\n            trailingFunctionArgument(arguments)\n         );\n      },\n   };\n}\n", "import { CommitResult } from '../../../typings';\nimport { LineParser, parseStringResponse } from '../utils';\n\nconst parsers: LineParser<CommitResult>[] = [\n   new LineParser(/^\\[([^\\s]+)( \\([^)]+\\))? ([^\\]]+)/, (result, [branch, root, commit]) => {\n      result.branch = branch;\n      result.commit = commit;\n      result.root = !!root;\n   }),\n   new LineParser(/\\s*Author:\\s(.+)/i, (result, [author]) => {\n      const parts = author.split('<');\n      const email = parts.pop();\n\n      if (!email || !email.includes('@')) {\n         return;\n      }\n\n      result.author = {\n         email: email.substr(0, email.length - 1),\n         name: parts.join('<').trim(),\n      };\n   }),\n   new LineParser(\n      /(\\d+)[^,]*(?:,\\s*(\\d+)[^,]*)(?:,\\s*(\\d+))/g,\n      (result, [changes, insertions, deletions]) => {\n         result.summary.changes = parseInt(changes, 10) || 0;\n         result.summary.insertions = parseInt(insertions, 10) || 0;\n         result.summary.deletions = parseInt(deletions, 10) || 0;\n      }\n   ),\n   new LineParser(\n      /^(\\d+)[^,]*(?:,\\s*(\\d+)[^(]+\\(([+-]))?/,\n      (result, [changes, lines, direction]) => {\n         result.summary.changes = parseInt(changes, 10) || 0;\n         const count = parseInt(lines, 10) || 0;\n         if (direction === '-') {\n            result.summary.deletions = count;\n         } else if (direction === '+') {\n            result.summary.insertions = count;\n         }\n      }\n   ),\n];\n\nexport function parseCommitResult(stdOut: string): CommitResult {\n   const result: CommitResult = {\n      author: null,\n      branch: '',\n      commit: '',\n      root: false,\n      summary: {\n         changes: 0,\n         insertions: 0,\n         deletions: 0,\n      },\n   };\n   return parseStringResponse(result, parsers, stdOut);\n}\n", "import type { CommitResult, SimpleGit } from '../../../typings';\nimport type { SimpleGitApi } from '../simple-git-api';\nimport type { StringTask } from '../types';\nimport { parseCommitResult } from '../parsers/parse-commit';\nimport {\n   asArray,\n   filterArray,\n   filterStringOrStringArray,\n   filterType,\n   getTrailingOptions,\n   prefixedArray,\n   trailingFunctionArgument,\n} from '../utils';\nimport { configurationErrorTask } from './task';\n\nexport function commitTask(\n   message: string[],\n   files: string[],\n   customArgs: string[]\n): StringTask<CommitResult> {\n   const commands: string[] = [\n      '-c',\n      'core.abbrev=40',\n      'commit',\n      ...prefixedArray(message, '-m'),\n      ...files,\n      ...customArgs,\n   ];\n\n   return {\n      commands,\n      format: 'utf-8',\n      parser: parseCommitResult,\n   };\n}\n\nexport default function (): Pick<SimpleGit, 'commit'> {\n   return {\n      commit(this: SimpleGitApi, message: string | string[], ...rest: unknown[]) {\n         const next = trailingFunctionArgument(arguments);\n         const task =\n            rejectDeprecatedSignatures(message) ||\n            commitTask(\n               asArray(message),\n               asArray(filterType(rest[0], filterStringOrStringArray, [])),\n               [...filterType(rest[1], filterArray, []), ...getTrailingOptions(arguments, 0, true)]\n            );\n\n         return this._runTask(task, next);\n      },\n   };\n\n   function rejectDeprecatedSignatures(message?: unknown) {\n      return (\n         !filterStringOrStringArray(message) &&\n         configurationErrorTask(\n            `git.commit: requires the commit message to be supplied as a string/string[]`\n         )\n      );\n   }\n}\n", "import { Response, SimpleGit } from '../../../typings';\nimport { SimpleGitApi } from '../simple-git-api';\nimport { trailingFunctionArgument } from '../utils';\nimport { straightThroughStringTask } from './task';\n\nexport default function (): Pick<SimpleGit, 'firstCommit'> {\n   return {\n      firstCommit(this: SimpleGitApi): Response<string> {\n         return this._runTask(\n            straightThroughStringTask(['rev-list', '--max-parents=0', 'HEAD'], true),\n            trailingFunctionArgument(arguments)\n         );\n      },\n   };\n}\n", "import { straightThroughStringTask } from './task';\nimport { StringTask } from '../types';\n\n/**\n * Task used by `git.hashObject`\n */\nexport function hashObjectTask(filePath: string, write: boolean): StringTask<string> {\n   const commands = ['hash-object', filePath];\n   if (write) {\n      commands.push('-w');\n   }\n\n   return straightThroughStringTask(commands, true);\n}\n", "import { InitResult } from '../../../typings';\n\nexport class InitSummary implements InitResult {\n   constructor(\n      public readonly bare: boolean,\n      public readonly path: string,\n      public readonly existing: boolean,\n      public readonly gitDir: string\n   ) {}\n}\n\nconst initResponseRegex = /^Init.+ repository in (.+)$/;\nconst reInitResponseRegex = /^Rein.+ in (.+)$/;\n\nexport function parseInit(bare: boolean, path: string, text: string) {\n   const response = String(text).trim();\n   let result;\n\n   if ((result = initResponseRegex.exec(response))) {\n      return new InitSummary(bare, path, false, result[1]);\n   }\n\n   if ((result = reInitResponseRegex.exec(response))) {\n      return new InitSummary(bare, path, true, result[1]);\n   }\n\n   let gitDir = '';\n   const tokens = response.split(' ');\n   while (tokens.length) {\n      const token = tokens.shift();\n      if (token === 'in') {\n         gitDir = tokens.join(' ');\n         break;\n      }\n   }\n\n   return new InitSummary(bare, path, /^re/i.test(response), gitDir);\n}\n", "import { InitResult } from '../../../typings';\nimport { parseInit } from '../responses/InitSummary';\nimport { StringTask } from '../types';\n\nconst bareCommand = '--bare';\n\nfunction hasBareCommand(command: string[]) {\n   return command.includes(bareCommand);\n}\n\nexport function initTask(bare = false, path: string, customArgs: string[]): StringTask<InitResult> {\n   const commands = ['init', ...customArgs];\n   if (bare && !hasBareCommand(commands)) {\n      commands.splice(1, 0, bareCommand);\n   }\n\n   return {\n      commands,\n      format: 'utf-8',\n      parser(text: string): InitResult {\n         return parseInit(commands.includes('--bare'), path, text);\n      },\n   };\n}\n", "export enum LogFormat {\n   NONE = '',\n   STAT = '--stat',\n   NUM_STAT = '--numstat',\n   NAME_ONLY = '--name-only',\n   NAME_STATUS = '--name-status',\n}\n\nconst logFormatRegex = /^--(stat|numstat|name-only|name-status)(=|$)/;\n\nexport function logFormatFromCommand(customArgs: string[]) {\n   for (let i = 0; i < customArgs.length; i++) {\n      const format = logFormatRegex.exec(customArgs[i]);\n      if (format) {\n         return `--${format[1]}` as LogFormat;\n      }\n   }\n\n   return LogFormat.NONE;\n}\n\nexport function isLogFormat(customArg: string | unknown) {\n   return logFormatRegex.test(customArg as string);\n}\n", "import { DiffResult, DiffResultBinaryFile, DiffResultTextFile } from '../../../typings';\n\n/***\n * The DiffSummary is returned as a response to getting `git().status()`\n */\nexport class DiffSummary implements DiffResult {\n   changed = 0;\n   deletions = 0;\n   insertions = 0;\n\n   files: Array<DiffResultTextFile | DiffResultBinaryFile> = [];\n}\n", "import { DiffResult } from '../../../typings';\nimport { LogFormat } from '../args/log-format';\nimport { DiffSummary } from '../responses/DiffSummary';\nimport { isDiffNameStatus } from '../tasks/diff-name-status';\nimport { asNumber, LineParser, orVoid, parseStringResponse } from '../utils';\n\nconst statParser = [\n   new LineParser<DiffResult>(\n      /(.+)\\s+\\|\\s+(\\d+)(\\s+[+\\-]+)?$/,\n      (result, [file, changes, alterations = '']) => {\n         result.files.push({\n            file: file.trim(),\n            changes: asNumber(changes),\n            insertions: alterations.replace(/[^+]/g, '').length,\n            deletions: alterations.replace(/[^-]/g, '').length,\n            binary: false,\n         });\n      }\n   ),\n   new LineParser<DiffResult>(\n      /(.+) \\|\\s+Bin ([0-9.]+) -> ([0-9.]+) ([a-z]+)/,\n      (result, [file, before, after]) => {\n         result.files.push({\n            file: file.trim(),\n            before: asNumber(before),\n            after: asNumber(after),\n            binary: true,\n         });\n      }\n   ),\n   new LineParser<DiffResult>(\n      /(\\d+) files? changed\\s*((?:, \\d+ [^,]+){0,2})/,\n      (result, [changed, summary]) => {\n         const inserted = /(\\d+) i/.exec(summary);\n         const deleted = /(\\d+) d/.exec(summary);\n\n         result.changed = asNumber(changed);\n         result.insertions = asNumber(inserted?.[1]);\n         result.deletions = asNumber(deleted?.[1]);\n      }\n   ),\n];\n\nconst numStatParser = [\n   new LineParser<DiffResult>(\n      /(\\d+)\\t(\\d+)\\t(.+)$/,\n      (result, [changesInsert, changesDelete, file]) => {\n         const insertions = asNumber(changesInsert);\n         const deletions = asNumber(changesDelete);\n\n         result.changed++;\n         result.insertions += insertions;\n         result.deletions += deletions;\n\n         result.files.push({\n            file,\n            changes: insertions + deletions,\n            insertions,\n            deletions,\n            binary: false,\n         });\n      }\n   ),\n   new LineParser<DiffResult>(/-\\t-\\t(.+)$/, (result, [file]) => {\n      result.changed++;\n\n      result.files.push({\n         file,\n         after: 0,\n         before: 0,\n         binary: true,\n      });\n   }),\n];\n\nconst nameOnlyParser = [\n   new LineParser<DiffResult>(/(.+)$/, (result, [file]) => {\n      result.changed++;\n      result.files.push({\n         file,\n         changes: 0,\n         insertions: 0,\n         deletions: 0,\n         binary: false,\n      });\n   }),\n];\n\nconst nameStatusParser = [\n   new LineParser<DiffResult>(\n      /([ACDMRTUXB])([0-9]{0,3})\\t(.[^\\t]*)(\\t(.[^\\t]*))?$/,\n      (result, [status, _similarity, from, _to, to]) => {\n         result.changed++;\n         result.files.push({\n            file: to ?? from,\n            changes: 0,\n            status: orVoid(isDiffNameStatus(status) && status),\n            insertions: 0,\n            deletions: 0,\n            binary: false,\n         });\n      }\n   ),\n];\n\nconst diffSummaryParsers: Record<LogFormat, LineParser<DiffResult>[]> = {\n   [LogFormat.NONE]: statParser,\n   [LogFormat.STAT]: statParser,\n   [LogFormat.NUM_STAT]: numStatParser,\n   [LogFormat.NAME_STATUS]: nameStatusParser,\n   [LogFormat.NAME_ONLY]: nameOnlyParser,\n};\n\nexport function getDiffParser(format = LogFormat.NONE) {\n   const parser = diffSummaryParsers[format];\n\n   return (stdOut: string) => parseStringResponse(new DiffSummary(), parser, stdOut, false);\n}\n", "import { ListLogLine, LogResult } from '../../../typings';\nimport { toLinesWithContent } from '../utils';\nimport { getDiffParser } from './parse-diff-summary';\nimport { LogFormat } from '../args/log-format';\n\nexport const START_BOUNDARY = '\u00F2\u00F2\u00F2\u00F2\u00F2\u00F2 ';\n\nexport const COMMIT_BOUNDARY = ' \u00F2\u00F2';\n\nexport const SPLITTER = ' \u00F2 ';\n\nconst defaultFieldNames = ['hash', 'date', 'message', 'refs', 'author_name', 'author_email'];\n\nfunction lineBuilder(tokens: string[], fields: string[]): any {\n   return fields.reduce(\n      (line, field, index) => {\n         line[field] = tokens[index] || '';\n         return line;\n      },\n      Object.create({ diff: null }) as any\n   );\n}\n\nexport function createListLogSummaryParser<T = any>(\n   splitter = SPLITTER,\n   fields = defaultFieldNames,\n   logFormat = LogFormat.NONE\n) {\n   const parseDiffResult = getDiffParser(logFormat);\n\n   return function (stdOut: string): LogResult<T> {\n      const all: ReadonlyArray<T & ListLogLine> = toLinesWithContent(\n         stdOut,\n         true,\n         START_BOUNDARY\n      ).map(function (item) {\n         const lineDetail = item.trim().split(COMMIT_BOUNDARY);\n         const listLogLine: T & ListLogLine = lineBuilder(\n            lineDetail[0].trim().split(splitter),\n            fields\n         );\n\n         if (lineDetail.length > 1 && !!lineDetail[1].trim()) {\n            listLogLine.diff = parseDiffResult(lineDetail[1]);\n         }\n\n         return listLogLine;\n      });\n\n      return {\n         all,\n         latest: (all.length && all[0]) || null,\n         total: all.length,\n      };\n   };\n}\n", "import { StringTask } from '../types';\nimport { DiffResult } from '../../../typings';\nimport { isLogFormat, LogFormat, logFormatFromCommand } from '../args/log-format';\nimport { getDiffParser } from '../parsers/parse-diff-summary';\nimport { configurationErrorTask, EmptyTask } from './task';\n\nexport function diffSummaryTask(customArgs: string[]): StringTask<DiffResult> | EmptyTask {\n   let logFormat = logFormatFromCommand(customArgs);\n\n   const commands = ['diff'];\n\n   if (logFormat === LogFormat.NONE) {\n      logFormat = LogFormat.STAT;\n      commands.push('--stat=4096');\n   }\n\n   commands.push(...customArgs);\n\n   return (\n      validateLogFormatConfig(commands) || {\n         commands,\n         format: 'utf-8',\n         parser: getDiffParser(logFormat),\n      }\n   );\n}\n\nexport function validateLogFormatConfig(customArgs: unknown[]): EmptyTask | void {\n   const flags = customArgs.filter(isLogFormat);\n\n   if (flags.length > 1) {\n      return configurationErrorTask(\n         `Summary flags are mutually exclusive - pick one of ${flags.join(',')}`\n      );\n   }\n\n   if (flags.length && customArgs.includes('-z')) {\n      return configurationErrorTask(\n         `Summary flag ${flags} parsing is not compatible with null termination option '-z'`\n      );\n   }\n}\n", "import type { Options, StringTask } from '../types';\nimport type { LogResult, SimpleGit } from '../../../typings';\nimport { logFormatFromCommand } from '../args/log-format';\nimport { pathspec } from '../args/pathspec';\nimport {\n   COMMIT_BOUNDARY,\n   createListLogSummaryParser,\n   SPLITTER,\n   START_BOUNDARY,\n} from '../parsers/parse-list-log-summary';\nimport {\n   appendTaskOptions,\n   filterArray,\n   filterPrimitives,\n   filterString,\n   filterType,\n   trailingFunctionArgument,\n   trailingOptionsArgument,\n} from '../utils';\nimport { SimpleGitApi } from '../simple-git-api';\nimport { configurationErrorTask } from './task';\nimport { validateLogFormatConfig } from './diff';\n\nenum excludeOptions {\n   '--pretty',\n   'max-count',\n   'maxCount',\n   'n',\n   'file',\n   'format',\n   'from',\n   'to',\n   'splitter',\n   'symmetric',\n   'mailMap',\n   'multiLine',\n   'strictDate',\n}\n\nexport interface DefaultLogFields {\n   hash: string;\n   date: string;\n   message: string;\n   refs: string;\n   body: string;\n   author_name: string;\n   author_email: string;\n}\n\nexport type LogOptions<T = DefaultLogFields> = {\n   file?: string;\n   format?: T;\n   from?: string;\n   mailMap?: boolean;\n   maxCount?: number;\n   multiLine?: boolean;\n   splitter?: string;\n   strictDate?: boolean;\n   symmetric?: boolean;\n   to?: string;\n};\n\ninterface ParsedLogOptions {\n   fields: string[];\n   splitter: string;\n   commands: string[];\n}\n\nfunction prettyFormat(\n   format: Record<string, string | unknown>,\n   splitter: string\n): [string[], string] {\n   const fields: string[] = [];\n   const formatStr: string[] = [];\n\n   Object.keys(format).forEach((field) => {\n      fields.push(field);\n      formatStr.push(String(format[field]));\n   });\n\n   return [fields, formatStr.join(splitter)];\n}\n\nfunction userOptions<T extends Options>(input: T): Options {\n   return Object.keys(input).reduce((out, key) => {\n      if (!(key in excludeOptions)) {\n         out[key] = input[key];\n      }\n      return out;\n   }, {} as Options);\n}\n\nexport function parseLogOptions<T extends Options>(\n   opt: Options | LogOptions<T> = {},\n   customArgs: string[] = []\n): ParsedLogOptions {\n   const splitter = filterType(opt.splitter, filterString, SPLITTER);\n   const format =\n      !filterPrimitives(opt.format) && opt.format\n         ? opt.format\n         : {\n              hash: '%H',\n              date: opt.strictDate === false ? '%ai' : '%aI',\n              message: '%s',\n              refs: '%D',\n              body: opt.multiLine ? '%B' : '%b',\n              author_name: opt.mailMap !== false ? '%aN' : '%an',\n              author_email: opt.mailMap !== false ? '%aE' : '%ae',\n           };\n\n   const [fields, formatStr] = prettyFormat(format, splitter);\n\n   const suffix: string[] = [];\n   const command: string[] = [\n      `--pretty=format:${START_BOUNDARY}${formatStr}${COMMIT_BOUNDARY}`,\n      ...customArgs,\n   ];\n\n   const maxCount: number | undefined = (opt as any).n || (opt as any)['max-count'] || opt.maxCount;\n   if (maxCount) {\n      command.push(`--max-count=${maxCount}`);\n   }\n\n   if (opt.from || opt.to) {\n      const rangeOperator = opt.symmetric !== false ? '...' : '..';\n      suffix.push(`${opt.from || ''}${rangeOperator}${opt.to || ''}`);\n   }\n\n   if (filterString(opt.file)) {\n      command.push('--follow', pathspec(opt.file));\n   }\n\n   appendTaskOptions(userOptions(opt as Options), command);\n\n   return {\n      fields,\n      splitter,\n      commands: [...command, ...suffix],\n   };\n}\n\nexport function logTask<T>(\n   splitter: string,\n   fields: string[],\n   customArgs: string[]\n): StringTask<LogResult<T>> {\n   const parser = createListLogSummaryParser(splitter, fields, logFormatFromCommand(customArgs));\n\n   return {\n      commands: ['log', ...customArgs],\n      format: 'utf-8',\n      parser,\n   };\n}\n\nexport default function (): Pick<SimpleGit, 'log'> {\n   return {\n      log<T extends Options>(this: SimpleGitApi, ...rest: unknown[]) {\n         const next = trailingFunctionArgument(arguments);\n         const options = parseLogOptions<T>(\n            trailingOptionsArgument(arguments),\n            filterType(arguments[0], filterArray)\n         );\n         const task =\n            rejectDeprecatedSignatures(...rest) ||\n            validateLogFormatConfig(options.commands) ||\n            createLogTask(options);\n\n         return this._runTask(task, next);\n      },\n   };\n\n   function createLogTask(options: ParsedLogOptions) {\n      return logTask(options.splitter, options.fields, options.commands);\n   }\n\n   function rejectDeprecatedSignatures(from?: unknown, to?: unknown) {\n      return (\n         filterString(from) &&\n         filterString(to) &&\n         configurationErrorTask(\n            `git.log(string, string) should be replaced with git.log({ from: string, to: string })`\n         )\n      );\n   }\n}\n", "import {\n   MergeConflict,\n   MergeConflictDeletion,\n   MergeDetail,\n   MergeResultStatus,\n} from '../../../typings';\n\nexport class MergeSummaryConflict implements MergeConflict {\n   constructor(\n      public readonly reason: string,\n      public readonly file: string | null = null,\n      public readonly meta?: MergeConflictDeletion\n   ) {}\n\n   toString() {\n      return `${this.file}:${this.reason}`;\n   }\n}\n\nexport class MergeSummaryDetail implements MergeDetail {\n   public conflicts: MergeConflict[] = [];\n   public merges: string[] = [];\n   public result: MergeResultStatus = 'success';\n\n   get failed() {\n      return this.conflicts.length > 0;\n   }\n\n   get reason() {\n      return this.result;\n   }\n\n   toString() {\n      if (this.conflicts.length) {\n         return `CONFLICTS: ${this.conflicts.join(', ')}`;\n      }\n\n      return 'OK';\n   }\n}\n", "import {\n   PullDetailFileChanges,\n   PullDetailSummary,\n   PullFailedResult,\n   PullResult,\n} from '../../../typings';\n\nexport class PullSummary implements PullResult {\n   public remoteMessages = {\n      all: [],\n   };\n   public created = [];\n   public deleted: string[] = [];\n   public files: string[] = [];\n   public deletions: PullDetailFileChanges = {};\n   public insertions: PullDetailFileChanges = {};\n   public summary: PullDetailSummary = {\n      changes: 0,\n      deletions: 0,\n      insertions: 0,\n   };\n}\n\nexport class PullFailedSummary implements PullFailedResult {\n   remote = '';\n   hash = {\n      local: '',\n      remote: '',\n   };\n   branch = {\n      local: '',\n      remote: '',\n   };\n   message = '';\n\n   toString() {\n      return this.message;\n   }\n}\n", "import {\n   RemoteMessageResult,\n   RemoteMessages,\n   RemoteMessagesObjectEnumeration,\n} from '../../../typings';\nimport { asNumber, RemoteLineParser } from '../utils';\n\nfunction objectEnumerationResult<T extends RemoteMessages = RemoteMessages>(\n   remoteMessages: T\n): RemoteMessagesObjectEnumeration {\n   return (remoteMessages.objects = remoteMessages.objects || {\n      compressing: 0,\n      counting: 0,\n      enumerating: 0,\n      packReused: 0,\n      reused: { count: 0, delta: 0 },\n      total: { count: 0, delta: 0 },\n   });\n}\n\nfunction asObjectCount(source: string) {\n   const count = /^\\s*(\\d+)/.exec(source);\n   const delta = /delta (\\d+)/i.exec(source);\n\n   return {\n      count: asNumber((count && count[1]) || '0'),\n      delta: asNumber((delta && delta[1]) || '0'),\n   };\n}\n\nexport const remoteMessagesObjectParsers: RemoteLineParser<RemoteMessageResult<RemoteMessages>>[] =\n   [\n      new RemoteLineParser(\n         /^remote:\\s*(enumerating|counting|compressing) objects: (\\d+),/i,\n         (result, [action, count]) => {\n            const key = action.toLowerCase();\n            const enumeration = objectEnumerationResult(result.remoteMessages);\n\n            Object.assign(enumeration, { [key]: asNumber(count) });\n         }\n      ),\n      new RemoteLineParser(\n         /^remote:\\s*(enumerating|counting|compressing) objects: \\d+% \\(\\d+\\/(\\d+)\\),/i,\n         (result, [action, count]) => {\n            const key = action.toLowerCase();\n            const enumeration = objectEnumerationResult(result.remoteMessages);\n\n            Object.assign(enumeration, { [key]: asNumber(count) });\n         }\n      ),\n      new RemoteLineParser(\n         /total ([^,]+), reused ([^,]+), pack-reused (\\d+)/i,\n         (result, [total, reused, packReused]) => {\n            const objects = objectEnumerationResult(result.remoteMessages);\n            objects.total = asObjectCount(total);\n            objects.reused = asObjectCount(reused);\n            objects.packReused = asNumber(packReused);\n         }\n      ),\n   ];\n", "import { PushResultRemoteMessages, RemoteMessageResult, RemoteMessages } from '../../../typings';\nimport { asNumber, parseStringResponse, RemoteLineParser } from '../utils';\nimport { remoteMessagesObjectParsers } from './parse-remote-objects';\n\nconst parsers: RemoteLineParser<RemoteMessageResult<PushResultRemoteMessages | RemoteMessages>>[] =\n   [\n      new RemoteLineParser(/^remote:\\s*(.+)$/, (result, [text]) => {\n         result.remoteMessages.all.push(text.trim());\n         return false;\n      }),\n      ...remoteMessagesObjectParsers,\n      new RemoteLineParser(\n         [/create a (?:pull|merge) request/i, /\\s(https?:\\/\\/\\S+)$/],\n         (result, [pullRequestUrl]) => {\n            (result.remoteMessages as PushResultRemoteMessages).pullRequestUrl = pullRequestUrl;\n         }\n      ),\n      new RemoteLineParser(\n         [/found (\\d+) vulnerabilities.+\\(([^)]+)\\)/i, /\\s(https?:\\/\\/\\S+)$/],\n         (result, [count, summary, url]) => {\n            (result.remoteMessages as PushResultRemoteMessages).vulnerabilities = {\n               count: asNumber(count),\n               summary,\n               url,\n            };\n         }\n      ),\n   ];\n\nexport function parseRemoteMessages<T extends RemoteMessages = RemoteMessages>(\n   _stdOut: string,\n   stdErr: string\n): RemoteMessageResult {\n   return parseStringResponse({ remoteMessages: new RemoteMessageSummary() as T }, parsers, stdErr);\n}\n\nexport class RemoteMessageSummary implements RemoteMessages {\n   public readonly all: string[] = [];\n}\n", "import { PullDetail, PullFailedResult, PullResult, RemoteMessages } from '../../../typings';\nimport { PullFailedSummary, PullSummary } from '../responses/PullSummary';\nimport { TaskParser } from '../types';\nimport { append, LineParser, parseStringResponse } from '../utils';\nimport { parseRemoteMessages } from './parse-remote-messages';\n\nconst FILE_UPDATE_REGEX = /^\\s*(.+?)\\s+\\|\\s+\\d+\\s*(\\+*)(-*)/;\nconst SUMMARY_REGEX = /(\\d+)\\D+((\\d+)\\D+\\(\\+\\))?(\\D+(\\d+)\\D+\\(-\\))?/;\nconst ACTION_REGEX = /^(create|delete) mode \\d+ (.+)/;\n\nconst parsers: LineParser<PullResult>[] = [\n   new LineParser(FILE_UPDATE_REGEX, (result, [file, insertions, deletions]) => {\n      result.files.push(file);\n\n      if (insertions) {\n         result.insertions[file] = insertions.length;\n      }\n\n      if (deletions) {\n         result.deletions[file] = deletions.length;\n      }\n   }),\n   new LineParser(SUMMARY_REGEX, (result, [changes, , insertions, , deletions]) => {\n      if (insertions !== undefined || deletions !== undefined) {\n         result.summary.changes = +changes || 0;\n         result.summary.insertions = +insertions || 0;\n         result.summary.deletions = +deletions || 0;\n         return true;\n      }\n      return false;\n   }),\n   new LineParser(ACTION_REGEX, (result, [action, file]) => {\n      append(result.files, file);\n      append(action === 'create' ? result.created : result.deleted, file);\n   }),\n];\n\nconst errorParsers: LineParser<PullFailedResult>[] = [\n   new LineParser(/^from\\s(.+)$/i, (result, [remote]) => void (result.remote = remote)),\n   new LineParser(/^fatal:\\s(.+)$/, (result, [message]) => void (result.message = message)),\n   new LineParser(\n      /([a-z0-9]+)\\.\\.([a-z0-9]+)\\s+(\\S+)\\s+->\\s+(\\S+)$/,\n      (result, [hashLocal, hashRemote, branchLocal, branchRemote]) => {\n         result.branch.local = branchLocal;\n         result.hash.local = hashLocal;\n         result.branch.remote = branchRemote;\n         result.hash.remote = hashRemote;\n      }\n   ),\n];\n\nexport const parsePullDetail: TaskParser<string, PullDetail> = (stdOut, stdErr) => {\n   return parseStringResponse(new PullSummary(), parsers, [stdOut, stdErr]);\n};\n\nexport const parsePullResult: TaskParser<string, PullResult> = (stdOut, stdErr) => {\n   return Object.assign(\n      new PullSummary(),\n      parsePullDetail(stdOut, stdErr),\n      parseRemoteMessages<RemoteMessages>(stdOut, stdErr)\n   );\n};\n\nexport function parsePullErrorResult(stdOut: string, stdErr: string) {\n   const pullError = parseStringResponse(new PullFailedSummary(), errorParsers, [stdOut, stdErr]);\n\n   return pullError.message && pullError;\n}\n", "import { MergeDetail, MergeResult } from '../../../typings';\nimport { MergeSummaryConflict, MergeSummaryDetail } from '../responses/MergeSummary';\nimport { TaskParser } from '../types';\nimport { LineParser, parseStringResponse } from '../utils';\nimport { parsePullResult } from './parse-pull';\n\nconst parsers: LineParser<MergeDetail>[] = [\n   new LineParser(/^Auto-merging\\s+(.+)$/, (summary, [autoMerge]) => {\n      summary.merges.push(autoMerge);\n   }),\n   new LineParser(/^CONFLICT\\s+\\((.+)\\): Merge conflict in (.+)$/, (summary, [reason, file]) => {\n      summary.conflicts.push(new MergeSummaryConflict(reason, file));\n   }),\n   new LineParser(\n      /^CONFLICT\\s+\\((.+\\/delete)\\): (.+) deleted in (.+) and/,\n      (summary, [reason, file, deleteRef]) => {\n         summary.conflicts.push(new MergeSummaryConflict(reason, file, { deleteRef }));\n      }\n   ),\n   new LineParser(/^CONFLICT\\s+\\((.+)\\):/, (summary, [reason]) => {\n      summary.conflicts.push(new MergeSummaryConflict(reason, null));\n   }),\n   new LineParser(/^Automatic merge failed;\\s+(.+)$/, (summary, [result]) => {\n      summary.result = result;\n   }),\n];\n\n/**\n * Parse the complete response from `git.merge`\n */\nexport const parseMergeResult: TaskParser<string, MergeResult> = (stdOut, stdErr) => {\n   return Object.assign(parseMergeDetail(stdOut, stdErr), parsePullResult(stdOut, stdErr));\n};\n\n/**\n * Parse the merge specific detail (ie: not the content also available in the pull detail) from `git.mnerge`\n * @param stdOut\n */\nexport const parseMergeDetail: TaskParser<string, MergeDetail> = (stdOut) => {\n   return parseStringResponse(new MergeSummaryDetail(), parsers, stdOut);\n};\n", "import { MergeResult } from '../../../typings';\nimport { GitResponseError } from '../errors/git-response-error';\nimport { parseMergeResult } from '../parsers/parse-merge';\nimport { StringTask } from '../types';\nimport { configurationErrorTask, EmptyTask } from './task';\n\nexport function mergeTask(customArgs: string[]): EmptyTask | StringTask<MergeResult> {\n   if (!customArgs.length) {\n      return configurationErrorTask('Git.merge requires at least one option');\n   }\n\n   return {\n      commands: ['merge', ...customArgs],\n      format: 'utf-8',\n      parser(stdOut, stdErr): MergeResult {\n         const merge = parseMergeResult(stdOut, stdErr);\n         if (merge.failed) {\n            throw new GitResponseError(merge);\n         }\n\n         return merge;\n      },\n   };\n}\n", "import {\n   PushDetail,\n   PushResult,\n   PushResultPushedItem,\n   PushResultRemoteMessages,\n} from '../../../typings';\nimport { TaskParser } from '../types';\nimport { LineParser, parseStringResponse } from '../utils';\nimport { parseRemoteMessages } from './parse-remote-messages';\n\nfunction pushResultPushedItem(local: string, remote: string, status: string): PushResultPushedItem {\n   const deleted = status.includes('deleted');\n   const tag = status.includes('tag') || /^refs\\/tags/.test(local);\n   const alreadyUpdated = !status.includes('new');\n\n   return {\n      deleted,\n      tag,\n      branch: !tag,\n      new: !alreadyUpdated,\n      alreadyUpdated,\n      local,\n      remote,\n   };\n}\n\nconst parsers: LineParser<PushDetail>[] = [\n   new LineParser(/^Pushing to (.+)$/, (result, [repo]) => {\n      result.repo = repo;\n   }),\n   new LineParser(/^updating local tracking ref '(.+)'/, (result, [local]) => {\n      result.ref = {\n         ...(result.ref || {}),\n         local,\n      };\n   }),\n   new LineParser(/^[=*-]\\s+([^:]+):(\\S+)\\s+\\[(.+)]$/, (result, [local, remote, type]) => {\n      result.pushed.push(pushResultPushedItem(local, remote, type));\n   }),\n   new LineParser(\n      /^Branch '([^']+)' set up to track remote branch '([^']+)' from '([^']+)'/,\n      (result, [local, remote, remoteName]) => {\n         result.branch = {\n            ...(result.branch || {}),\n            local,\n            remote,\n            remoteName,\n         };\n      }\n   ),\n   new LineParser(\n      /^([^:]+):(\\S+)\\s+([a-z0-9]+)\\.\\.([a-z0-9]+)$/,\n      (result, [local, remote, from, to]) => {\n         result.update = {\n            head: {\n               local,\n               remote,\n            },\n            hash: {\n               from,\n               to,\n            },\n         };\n      }\n   ),\n];\n\nexport const parsePushResult: TaskParser<string, PushResult> = (stdOut, stdErr) => {\n   const pushDetail = parsePushDetail(stdOut, stdErr);\n   const responseDetail = parseRemoteMessages<PushResultRemoteMessages>(stdOut, stdErr);\n\n   return {\n      ...pushDetail,\n      ...responseDetail,\n   };\n};\n\nexport const parsePushDetail: TaskParser<string, PushDetail> = (stdOut, stdErr) => {\n   return parseStringResponse({ pushed: [] }, parsers, [stdOut, stdErr]);\n};\n", "import { PushResult } from '../../../typings';\nimport { parsePushResult as parser } from '../parsers/parse-push';\nimport { StringTask } from '../types';\nimport { append, remove } from '../utils';\n\ntype PushRef = { remote?: string; branch?: string };\n\nexport function pushTagsTask(ref: PushRef = {}, customArgs: string[]): StringTask<PushResult> {\n   append(customArgs, '--tags');\n   return pushTask(ref, customArgs);\n}\n\nexport function pushTask(ref: PushRef = {}, customArgs: string[]): StringTask<PushResult> {\n   const commands = ['push', ...customArgs];\n   if (ref.branch) {\n      commands.splice(1, 0, ref.branch);\n   }\n   if (ref.remote) {\n      commands.splice(1, 0, ref.remote);\n   }\n\n   remove(commands, '-v');\n   append(commands, '--verbose');\n   append(commands, '--porcelain');\n\n   return {\n      commands,\n      format: 'utf-8',\n      parser,\n   };\n}\n", "import { SimpleGit } from '../../../typings';\nimport { SimpleGitApi } from '../simple-git-api';\nimport { getTrailingOptions, trailingFunctionArgument } from '../utils';\nimport { straightThroughBufferTask, straightThroughStringTask } from './task';\n\nexport default function (): Pick<SimpleGit, 'showBuffer' | 'show'> {\n   return {\n      showBuffer(this: SimpleGitApi) {\n         const commands = ['show', ...getTrailingOptions(arguments, 1)];\n         if (!commands.includes('--binary')) {\n            commands.splice(1, 0, '--binary');\n         }\n\n         return this._runTask(\n            straightThroughBufferTask(commands),\n            trailingFunctionArgument(arguments)\n         );\n      },\n\n      show(this: SimpleGitApi) {\n         const commands = ['show', ...getTrailingOptions(arguments, 1)];\n         return this._runTask(\n            straightThroughStringTask(commands),\n            trailingFunctionArgument(arguments)\n         );\n      },\n   };\n}\n", "import { FileStatusResult } from '../../../typings';\n\nexport const fromPathRegex = /^(.+) -> (.+)$/;\n\nexport class FileStatusSummary implements FileStatusResult {\n   public readonly from: string | undefined;\n\n   constructor(\n      public path: string,\n      public index: string,\n      public working_dir: string\n   ) {\n      if ('R' === index + working_dir) {\n         const detail = fromPathRegex.exec(path) || [null, path, path];\n         this.from = detail[1] || '';\n         this.path = detail[2] || '';\n      }\n   }\n}\n", "import { StatusResult } from '../../../typings';\nimport { append, NULL } from '../utils';\nimport { FileStatusSummary } from './FileStatusSummary';\n\ntype StatusLineParser = (result: StatusResult, file: string) => void;\n\nexport class StatusSummary implements StatusResult {\n   public not_added = [];\n   public conflicted = [];\n   public created = [];\n   public deleted = [];\n   public ignored = undefined;\n   public modified = [];\n   public renamed = [];\n   public files = [];\n   public staged = [];\n   public ahead = 0;\n   public behind = 0;\n   public current = null;\n   public tracking = null;\n   public detached = false;\n\n   public isClean = () => {\n      return !this.files.length;\n   };\n}\n\nenum PorcelainFileStatus {\n   ADDED = 'A',\n   DELETED = 'D',\n   MODIFIED = 'M',\n   RENAMED = 'R',\n   COPIED = 'C',\n   UNMERGED = 'U',\n   UNTRACKED = '?',\n   IGNORED = '!',\n   NONE = ' ',\n}\n\nfunction renamedFile(line: string) {\n   const [to, from] = line.split(NULL);\n\n   return {\n      from: from || to,\n      to,\n   };\n}\n\nfunction parser(\n   indexX: PorcelainFileStatus,\n   indexY: PorcelainFileStatus,\n   handler: StatusLineParser\n): [string, StatusLineParser] {\n   return [`${indexX}${indexY}`, handler];\n}\n\nfunction conflicts(indexX: PorcelainFileStatus, ...indexY: PorcelainFileStatus[]) {\n   return indexY.map((y) => parser(indexX, y, (result, file) => append(result.conflicted, file)));\n}\n\nconst parsers: Map<string, StatusLineParser> = new Map([\n   parser(PorcelainFileStatus.NONE, PorcelainFileStatus.ADDED, (result, file) =>\n      append(result.created, file)\n   ),\n   parser(PorcelainFileStatus.NONE, PorcelainFileStatus.DELETED, (result, file) =>\n      append(result.deleted, file)\n   ),\n   parser(PorcelainFileStatus.NONE, PorcelainFileStatus.MODIFIED, (result, file) =>\n      append(result.modified, file)\n   ),\n\n   parser(\n      PorcelainFileStatus.ADDED,\n      PorcelainFileStatus.NONE,\n      (result, file) => append(result.created, file) && append(result.staged, file)\n   ),\n   parser(\n      PorcelainFileStatus.ADDED,\n      PorcelainFileStatus.MODIFIED,\n      (result, file) =>\n         append(result.created, file) &&\n         append(result.staged, file) &&\n         append(result.modified, file)\n   ),\n\n   parser(\n      PorcelainFileStatus.DELETED,\n      PorcelainFileStatus.NONE,\n      (result, file) => append(result.deleted, file) && append(result.staged, file)\n   ),\n\n   parser(\n      PorcelainFileStatus.MODIFIED,\n      PorcelainFileStatus.NONE,\n      (result, file) => append(result.modified, file) && append(result.staged, file)\n   ),\n   parser(\n      PorcelainFileStatus.MODIFIED,\n      PorcelainFileStatus.MODIFIED,\n      (result, file) => append(result.modified, file) && append(result.staged, file)\n   ),\n\n   parser(PorcelainFileStatus.RENAMED, PorcelainFileStatus.NONE, (result, file) => {\n      append(result.renamed, renamedFile(file));\n   }),\n   parser(PorcelainFileStatus.RENAMED, PorcelainFileStatus.MODIFIED, (result, file) => {\n      const renamed = renamedFile(file);\n      append(result.renamed, renamed);\n      append(result.modified, renamed.to);\n   }),\n   parser(PorcelainFileStatus.IGNORED, PorcelainFileStatus.IGNORED, (_result, _file) => {\n      append((_result.ignored = _result.ignored || []), _file);\n   }),\n\n   parser(PorcelainFileStatus.UNTRACKED, PorcelainFileStatus.UNTRACKED, (result, file) =>\n      append(result.not_added, file)\n   ),\n\n   ...conflicts(PorcelainFileStatus.ADDED, PorcelainFileStatus.ADDED, PorcelainFileStatus.UNMERGED),\n   ...conflicts(\n      PorcelainFileStatus.DELETED,\n      PorcelainFileStatus.DELETED,\n      PorcelainFileStatus.UNMERGED\n   ),\n   ...conflicts(\n      PorcelainFileStatus.UNMERGED,\n      PorcelainFileStatus.ADDED,\n      PorcelainFileStatus.DELETED,\n      PorcelainFileStatus.UNMERGED\n   ),\n\n   [\n      '##',\n      (result, line) => {\n         const aheadReg = /ahead (\\d+)/;\n         const behindReg = /behind (\\d+)/;\n         const currentReg = /^(.+?(?=(?:\\.{3}|\\s|$)))/;\n         const trackingReg = /\\.{3}(\\S*)/;\n         const onEmptyBranchReg = /\\son\\s([\\S]+)$/;\n         let regexResult;\n\n         regexResult = aheadReg.exec(line);\n         result.ahead = (regexResult && +regexResult[1]) || 0;\n\n         regexResult = behindReg.exec(line);\n         result.behind = (regexResult && +regexResult[1]) || 0;\n\n         regexResult = currentReg.exec(line);\n         result.current = regexResult && regexResult[1];\n\n         regexResult = trackingReg.exec(line);\n         result.tracking = regexResult && regexResult[1];\n\n         regexResult = onEmptyBranchReg.exec(line);\n         result.current = (regexResult && regexResult[1]) || result.current;\n\n         result.detached = /\\(no branch\\)/.test(line);\n      },\n   ],\n]);\n\nexport const parseStatusSummary = function (text: string): StatusResult {\n   const lines = text.split(NULL);\n   const status = new StatusSummary();\n\n   for (let i = 0, l = lines.length; i < l; ) {\n      let line = lines[i++].trim();\n\n      if (!line) {\n         continue;\n      }\n\n      if (line.charAt(0) === PorcelainFileStatus.RENAMED) {\n         line += NULL + (lines[i++] || '');\n      }\n\n      splitLine(status, line);\n   }\n\n   return status;\n};\n\nfunction splitLine(result: StatusResult, lineStr: string) {\n   const trimmed = lineStr.trim();\n   switch (' ') {\n      case trimmed.charAt(2):\n         return data(trimmed.charAt(0), trimmed.charAt(1), trimmed.substr(3));\n      case trimmed.charAt(1):\n         return data(PorcelainFileStatus.NONE, trimmed.charAt(0), trimmed.substr(2));\n      default:\n         return;\n   }\n\n   function data(index: string, workingDir: string, path: string) {\n      const raw = `${index}${workingDir}`;\n      const handler = parsers.get(raw);\n\n      if (handler) {\n         handler(result, path);\n      }\n\n      if (raw !== '##' && raw !== '!!') {\n         result.files.push(new FileStatusSummary(path.replace(/\\0.+$/, ''), index, workingDir));\n      }\n   }\n}\n", "import { StatusResult } from '../../../typings';\nimport { parseStatusSummary } from '../responses/StatusSummary';\nimport { StringTask } from '../types';\n\nconst ignoredOptions = ['--null', '-z'];\n\nexport function statusTask(customArgs: string[]): StringTask<StatusResult> {\n   const commands = [\n      'status',\n      '--porcelain',\n      '-b',\n      '-u',\n      '--null',\n      ...customArgs.filter((arg) => !ignoredOptions.includes(arg)),\n   ];\n\n   return {\n      format: 'utf-8',\n      commands,\n      parser(text: string) {\n         return parseStatusSummary(text);\n      },\n   };\n}\n", "import type { SimpleGitApi } from '../simple-git-api';\nimport type { SimpleGit } from '../../../typings';\nimport { asNumber, ExitCodes, LineParser, parseStringResponse } from '../utils';\n\nexport interface VersionResult {\n   major: number;\n   minor: number;\n   patch: number | string;\n   agent: string;\n   installed: boolean;\n}\n\nconst NOT_INSTALLED = 'installed=false';\n\nfunction versionResponse(\n   major = 0,\n   minor = 0,\n   patch: string | number = 0,\n   agent = '',\n   installed = true\n): VersionResult {\n   return Object.defineProperty(\n      {\n         major,\n         minor,\n         patch,\n         agent,\n         installed,\n      },\n      'toString',\n      {\n         value() {\n            return `${this.major}.${this.minor}.${this.patch}`;\n         },\n         configurable: false,\n         enumerable: false,\n      }\n   );\n}\n\nfunction notInstalledResponse() {\n   return versionResponse(0, 0, 0, '', false);\n}\n\nexport default function (): Pick<SimpleGit, 'version'> {\n   return {\n      version(this: SimpleGitApi) {\n         return this._runTask({\n            commands: ['--version'],\n            format: 'utf-8',\n            parser: versionParser,\n            onError(result, error, done, fail) {\n               if (result.exitCode === ExitCodes.NOT_FOUND) {\n                  return done(Buffer.from(NOT_INSTALLED));\n               }\n\n               fail(error);\n            },\n         });\n      },\n   };\n}\n\nconst parsers: LineParser<VersionResult>[] = [\n   new LineParser(\n      /version (\\d+)\\.(\\d+)\\.(\\d+)(?:\\s*\\((.+)\\))?/,\n      (result, [major, minor, patch, agent = '']) => {\n         Object.assign(\n            result,\n            versionResponse(asNumber(major), asNumber(minor), asNumber(patch), agent)\n         );\n      }\n   ),\n   new LineParser(\n      /version (\\d+)\\.(\\d+)\\.(\\D+)(.+)?$/,\n      (result, [major, minor, patch, agent = '']) => {\n         Object.assign(result, versionResponse(asNumber(major), asNumber(minor), patch, agent));\n      }\n   ),\n];\n\nfunction versionParser(stdOut: string) {\n   if (stdOut === NOT_INSTALLED) {\n      return notInstalledResponse();\n   }\n\n   return parseStringResponse(versionResponse(0, 0, 0, stdOut), parsers, stdOut);\n}\n", "import { SimpleGitBase } from '../../typings';\nimport { taskCallback } from './task-callback';\nimport { changeWorkingDirectoryTask } from './tasks/change-working-directory';\nimport checkout from './tasks/checkout';\nimport commit from './tasks/commit';\nimport config from './tasks/config';\nimport firstCommit from './tasks/first-commit';\nimport grep from './tasks/grep';\nimport { hashObjectTask } from './tasks/hash-object';\nimport { initTask } from './tasks/init';\nimport log from './tasks/log';\nimport { mergeTask } from './tasks/merge';\nimport { pushTask } from './tasks/push';\nimport show from './tasks/show';\nimport { statusTask } from './tasks/status';\nimport { configurationErrorTask, straightThroughStringTask } from './tasks/task';\nimport version from './tasks/version';\nimport { outputHandler, SimpleGitExecutor, SimpleGitTask, SimpleGitTaskCallback } from './types';\nimport {\n   asArray,\n   filterString,\n   filterType,\n   getTrailingOptions,\n   trailingFunctionArgument,\n} from './utils';\n\nexport class SimpleGitApi implements SimpleGitBase {\n   constructor(private _executor: SimpleGitExecutor) {}\n\n   protected _runTask<T>(task: SimpleGitTask<T>, then?: SimpleGitTaskCallback<T>) {\n      const chain = this._executor.chain();\n      const promise = chain.push(task);\n\n      if (then) {\n         taskCallback(task, promise, then);\n      }\n\n      return Object.create(this, {\n         then: { value: promise.then.bind(promise) },\n         catch: { value: promise.catch.bind(promise) },\n         _executor: { value: chain },\n      });\n   }\n\n   add(files: string | string[]) {\n      return this._runTask(\n         straightThroughStringTask(['add', ...asArray(files)]),\n         trailingFunctionArgument(arguments)\n      );\n   }\n\n   cwd(directory: string | { path: string; root?: boolean }) {\n      const next = trailingFunctionArgument(arguments);\n\n      if (typeof directory === 'string') {\n         return this._runTask(changeWorkingDirectoryTask(directory, this._executor), next);\n      }\n\n      if (typeof directory?.path === 'string') {\n         return this._runTask(\n            changeWorkingDirectoryTask(\n               directory.path,\n               (directory.root && this._executor) || undefined\n            ),\n            next\n         );\n      }\n\n      return this._runTask(\n         configurationErrorTask('Git.cwd: workingDirectory must be supplied as a string'),\n         next\n      );\n   }\n\n   hashObject(path: string, write: boolean | unknown) {\n      return this._runTask(\n         hashObjectTask(path, write === true),\n         trailingFunctionArgument(arguments)\n      );\n   }\n\n   init(bare?: boolean | unknown) {\n      return this._runTask(\n         initTask(bare === true, this._executor.cwd, getTrailingOptions(arguments)),\n         trailingFunctionArgument(arguments)\n      );\n   }\n\n   merge() {\n      return this._runTask(\n         mergeTask(getTrailingOptions(arguments)),\n         trailingFunctionArgument(arguments)\n      );\n   }\n\n   mergeFromTo(remote: string, branch: string) {\n      if (!(filterString(remote) && filterString(branch))) {\n         return this._runTask(\n            configurationErrorTask(\n               `Git.mergeFromTo requires that the 'remote' and 'branch' arguments are supplied as strings`\n            )\n         );\n      }\n\n      return this._runTask(\n         mergeTask([remote, branch, ...getTrailingOptions(arguments)]),\n         trailingFunctionArgument(arguments, false)\n      );\n   }\n\n   outputHandler(handler: outputHandler) {\n      this._executor.outputHandler = handler;\n      return this;\n   }\n\n   push() {\n      const task = pushTask(\n         {\n            remote: filterType(arguments[0], filterString),\n            branch: filterType(arguments[1], filterString),\n         },\n         getTrailingOptions(arguments)\n      );\n\n      return this._runTask(task, trailingFunctionArgument(arguments));\n   }\n\n   stash() {\n      return this._runTask(\n         straightThroughStringTask(['stash', ...getTrailingOptions(arguments)]),\n         trailingFunctionArgument(arguments)\n      );\n   }\n\n   status() {\n      return this._runTask(\n         statusTask(getTrailingOptions(arguments)),\n         trailingFunctionArgument(arguments)\n      );\n   }\n}\n\nObject.assign(\n   SimpleGitApi.prototype,\n   checkout(),\n   commit(),\n   config(),\n   firstCommit(),\n   grep(),\n   log(),\n   show(),\n   version()\n);\n", "import { append, remove } from '../utils';\nimport { createDeferred, DeferredPromise } from '@kwsites/promise-deferred';\nimport { createLogger } from '../git-logger';\n\ntype ScheduleCompleteCallback = () => void;\ntype ScheduledTask = Pick<DeferredPromise<ScheduleCompleteCallback>, 'promise' | 'done'> & {\n   id: number;\n};\n\nconst createScheduledTask: () => ScheduledTask = (() => {\n   let id = 0;\n   return () => {\n      id++;\n      const { promise, done } = createDeferred<ScheduleCompleteCallback>();\n\n      return {\n         promise,\n         done,\n         id,\n      };\n   };\n})();\n\nexport class Scheduler {\n   private logger = createLogger('', 'scheduler');\n   private pending: ScheduledTask[] = [];\n   private running: ScheduledTask[] = [];\n\n   constructor(private concurrency = 2) {\n      this.logger(`Constructed, concurrency=%s`, concurrency);\n   }\n\n   private schedule() {\n      if (!this.pending.length || this.running.length >= this.concurrency) {\n         this.logger(\n            `Schedule attempt ignored, pending=%s running=%s concurrency=%s`,\n            this.pending.length,\n            this.running.length,\n            this.concurrency\n         );\n         return;\n      }\n\n      const task = append(this.running, this.pending.shift()!);\n      this.logger(`Attempting id=%s`, task.id);\n      task.done(() => {\n         this.logger(`Completing id=`, task.id);\n         remove(this.running, task);\n         this.schedule();\n      });\n   }\n\n   next(): Promise<ScheduleCompleteCallback> {\n      const { promise, id } = append(this.pending, createScheduledTask());\n      this.logger(`Scheduling id=%s`, id);\n\n      this.schedule();\n\n      return promise;\n   }\n}\n", "import { straightThroughStringTask } from './task';\nimport { OptionFlags, Options, StringTask } from '../types';\n\nexport type ApplyOptions = Options &\n   OptionFlags<\n      | '--stat'\n      | '--numstat'\n      | '--summary'\n      | '--check'\n      | '--index'\n      | '--intent-to-add'\n      | '--3way'\n      | '--apply'\n      | '--no-add'\n      | '-R'\n      | '--reverse'\n      | '--allow-binary-replacement'\n      | '--binary'\n      | '--reject'\n      | '-z'\n      | '--inaccurate-eof'\n      | '--recount'\n      | '--cached'\n      | '--ignore-space-change'\n      | '--ignore-whitespace'\n      | '--verbose'\n      | '--unsafe-paths'\n   > &\n   OptionFlags<'--whitespace', 'nowarn' | 'warn' | 'fix' | 'error' | 'error-all'> &\n   OptionFlags<'--build-fake-ancestor' | '--exclude' | '--include' | '--directory', string> &\n   OptionFlags<'-p' | '-C', number>;\n\nexport function applyPatchTask(patches: string[], customArgs: string[]): StringTask<string> {\n   return straightThroughStringTask(['apply', ...customArgs, ...patches]);\n}\n", "import {\n   BranchMultiDeleteResult,\n   BranchSingleDeleteFailure,\n   BranchSingleDeleteResult,\n   BranchSingleDeleteSuccess,\n} from '../../../typings';\n\nexport class BranchDeletionBatch implements BranchMultiDeleteResult {\n   all: BranchSingleDeleteResult[] = [];\n   branches: { [branchName: string]: BranchSingleDeleteResult } = {};\n   errors: BranchSingleDeleteResult[] = [];\n\n   get success(): boolean {\n      return !this.errors.length;\n   }\n}\n\nexport function branchDeletionSuccess(branch: string, hash: string): BranchSingleDeleteSuccess {\n   return {\n      branch,\n      hash,\n      success: true,\n   };\n}\n\nexport function branchDeletionFailure(branch: string): BranchSingleDeleteFailure {\n   return {\n      branch,\n      hash: null,\n      success: false,\n   };\n}\n\nexport function isSingleBranchDeleteFailure(\n   test: BranchSingleDeleteResult\n): test is BranchSingleDeleteSuccess {\n   return test.success;\n}\n", "import { BranchMultiDeleteResult } from '../../../typings';\nimport {\n   BranchDeletionBatch,\n   branchDeletionFailure,\n   branchDeletionSuccess,\n} from '../responses/BranchDeleteSummary';\nimport { TaskParser } from '../types';\nimport { ExitCodes, LineParser, parseStringResponse } from '../utils';\n\nconst deleteSuccessRegex = /(\\S+)\\s+\\(\\S+\\s([^)]+)\\)/;\nconst deleteErrorRegex = /^error[^']+'([^']+)'/m;\n\nconst parsers: LineParser<BranchMultiDeleteResult>[] = [\n   new LineParser(deleteSuccessRegex, (result, [branch, hash]) => {\n      const deletion = branchDeletionSuccess(branch, hash);\n\n      result.all.push(deletion);\n      result.branches[branch] = deletion;\n   }),\n   new LineParser(deleteErrorRegex, (result, [branch]) => {\n      const deletion = branchDeletionFailure(branch);\n\n      result.errors.push(deletion);\n      result.all.push(deletion);\n      result.branches[branch] = deletion;\n   }),\n];\n\nexport const parseBranchDeletions: TaskParser<string, BranchMultiDeleteResult> = (\n   stdOut,\n   stdErr\n) => {\n   return parseStringResponse(new BranchDeletionBatch(), parsers, [stdOut, stdErr]);\n};\n\nexport function hasBranchDeletionError(data: string, processExitCode: ExitCodes): boolean {\n   return processExitCode === ExitCodes.ERROR && deleteErrorRegex.test(data);\n}\n", "import type { BranchSummary, BranchSummaryBranch } from '../../../typings';\n\nexport enum BranchStatusIdentifier {\n   CURRENT = '*',\n   LINKED = '+',\n}\n\nexport class BranchSummaryResult implements BranchSummary {\n   public all: string[] = [];\n   public branches: { [p: string]: BranchSummaryBranch } = {};\n   public current: string = '';\n   public detached: boolean = false;\n\n   push(\n      status: BranchStatusIdentifier | unknown,\n      detached: boolean,\n      name: string,\n      commit: string,\n      label: string\n   ) {\n      if (status === BranchStatusIdentifier.CURRENT) {\n         this.detached = detached;\n         this.current = name;\n      }\n\n      this.all.push(name);\n      this.branches[name] = {\n         current: status === BranchStatusIdentifier.CURRENT,\n         linkedWorkTree: status === BranchStatusIdentifier.LINKED,\n         name,\n         commit,\n         label,\n      };\n   }\n}\n", "import type { BranchSummary } from '../../../typings';\nimport { BranchSummaryResult } from '../responses/BranchSummary';\nimport { LineParser, parseStringResponse } from '../utils';\n\nconst parsers: LineParser<BranchSummaryResult>[] = [\n   new LineParser(\n      /^([*+]\\s)?\\((?:HEAD )?detached (?:from|at) (\\S+)\\)\\s+([a-z0-9]+)\\s(.*)$/,\n      (result, [current, name, commit, label]) => {\n         result.push(branchStatus(current), true, name, commit, label);\n      }\n   ),\n   new LineParser(\n      /^([*+]\\s)?(\\S+)\\s+([a-z0-9]+)\\s?(.*)$/s,\n      (result, [current, name, commit, label]) => {\n         result.push(branchStatus(current), false, name, commit, label);\n      }\n   ),\n];\n\nfunction branchStatus(input?: string) {\n   return input ? input.charAt(0) : '';\n}\n\nexport function parseBranchSummary(stdOut: string): BranchSummary {\n   return parseStringResponse(new BranchSummaryResult(), parsers, stdOut);\n}\n", "import { BranchMultiDeleteResult, BranchSingleDeleteResult, BranchSummary } from '../../../typings';\nimport { StringTask } from '../types';\nimport { GitResponseError } from '../errors/git-response-error';\nimport { hasBranchDeletionError, parseBranchDeletions } from '../parsers/parse-branch-delete';\nimport { parseBranchSummary } from '../parsers/parse-branch';\nimport { bufferToString } from '../utils';\n\nexport function containsDeleteBranchCommand(commands: string[]) {\n   const deleteCommands = ['-d', '-D', '--delete'];\n   return commands.some((command) => deleteCommands.includes(command));\n}\n\nexport function branchTask(\n   customArgs: string[]\n): StringTask<BranchSummary | BranchSingleDeleteResult> {\n   const isDelete = containsDeleteBranchCommand(customArgs);\n   const commands = ['branch', ...customArgs];\n\n   if (commands.length === 1) {\n      commands.push('-a');\n   }\n\n   if (!commands.includes('-v')) {\n      commands.splice(1, 0, '-v');\n   }\n\n   return {\n      format: 'utf-8',\n      commands,\n      parser(stdOut, stdErr) {\n         if (isDelete) {\n            return parseBranchDeletions(stdOut, stdErr).all[0];\n         }\n\n         return parseBranchSummary(stdOut);\n      },\n   };\n}\n\nexport function branchLocalTask(): StringTask<BranchSummary> {\n   const parser = parseBranchSummary;\n\n   return {\n      format: 'utf-8',\n      commands: ['branch', '-v'],\n      parser,\n   };\n}\n\nexport function deleteBranchesTask(\n   branches: string[],\n   forceDelete = false\n): StringTask<BranchMultiDeleteResult> {\n   return {\n      format: 'utf-8',\n      commands: ['branch', '-v', forceDelete ? '-D' : '-d', ...branches],\n      parser(stdOut, stdErr) {\n         return parseBranchDeletions(stdOut, stdErr);\n      },\n      onError({ exitCode, stdOut }, error, done, fail) {\n         if (!hasBranchDeletionError(String(error), exitCode)) {\n            return fail(error);\n         }\n\n         done(stdOut);\n      },\n   };\n}\n\nexport function deleteBranchTask(\n   branch: string,\n   forceDelete = false\n): StringTask<BranchSingleDeleteResult> {\n   const task: StringTask<BranchSingleDeleteResult> = {\n      format: 'utf-8',\n      commands: ['branch', '-v', forceDelete ? '-D' : '-d', branch],\n      parser(stdOut, stdErr) {\n         return parseBranchDeletions(stdOut, stdErr).branches[branch]!;\n      },\n      onError({ exitCode, stdErr, stdOut }, error, _, fail) {\n         if (!hasBranchDeletionError(String(error), exitCode)) {\n            return fail(error);\n         }\n\n         throw new GitResponseError(\n            task.parser(bufferToString(stdOut), bufferToString(stdErr)),\n            String(error)\n         );\n      },\n   };\n\n   return task;\n}\n", "/**\n * Parser for the `check-ignore` command - returns each file as a string array\n */\nexport const parseCheckIgnore = (text: string): string[] => {\n   return text\n      .split(/\\n/g)\n      .map((line) => line.trim())\n      .filter((file) => !!file);\n};\n", "import { StringTask } from '../types';\nimport { parseCheckIgnore } from '../responses/CheckIgnore';\n\nexport function checkIgnoreTask(paths: string[]): StringTask<string[]> {\n   return {\n      commands: ['check-ignore', ...paths],\n      format: 'utf-8',\n      parser: parseCheckIgnore,\n   };\n}\n", "import { configurationErrorTask, EmptyTask, straightThroughStringTask } from './task';\nimport { OptionFlags, Options, StringTask } from '../types';\nimport { append, filterString } from '../utils';\n\nexport type CloneOptions = Options &\n   OptionFlags<\n      | '--bare'\n      | '--dissociate'\n      | '--mirror'\n      | '--no-checkout'\n      | '--no-remote-submodules'\n      | '--no-shallow-submodules'\n      | '--no-single-branch'\n      | '--no-tags'\n      | '--remote-submodules'\n      | '--single-branch'\n      | '--shallow-submodules'\n      | '--verbose'\n   > &\n   OptionFlags<'--depth' | '-j' | '--jobs', number> &\n   OptionFlags<\n      | '--branch'\n      | '--origin'\n      | '--recurse-submodules'\n      | '--separate-git-dir'\n      | '--shallow-exclude'\n      | '--shallow-since'\n      | '--template',\n      string\n   >;\n\nfunction disallowedCommand(command: string) {\n   return /^--upload-pack(=|$)/.test(command);\n}\n\nexport function cloneTask(\n   repo: string | undefined,\n   directory: string | undefined,\n   customArgs: string[]\n): StringTask<string> | EmptyTask {\n   const commands = ['clone', ...customArgs];\n\n   filterString(repo) && commands.push(repo);\n   filterString(directory) && commands.push(directory);\n\n   const banned = commands.find(disallowedCommand);\n   if (banned) {\n      return configurationErrorTask(`git.fetch: potential exploit argument blocked.`);\n   }\n\n   return straightThroughStringTask(commands);\n}\n\nexport function cloneMirrorTask(\n   repo: string | undefined,\n   directory: string | undefined,\n   customArgs: string[]\n) {\n   append(customArgs, '--mirror');\n\n   return cloneTask(repo, directory, customArgs);\n}\n", "import { FetchResult } from '../../../typings';\nimport { LineParser, parseStringResponse } from '../utils';\n\nconst parsers: LineParser<FetchResult>[] = [\n   new LineParser(/From (.+)$/, (result, [remote]) => {\n      result.remote = remote;\n   }),\n   new LineParser(/\\* \\[new branch]\\s+(\\S+)\\s*-> (.+)$/, (result, [name, tracking]) => {\n      result.branches.push({\n         name,\n         tracking,\n      });\n   }),\n   new LineParser(/\\* \\[new tag]\\s+(\\S+)\\s*-> (.+)$/, (result, [name, tracking]) => {\n      result.tags.push({\n         name,\n         tracking,\n      });\n   }),\n   new LineParser(/- \\[deleted]\\s+\\S+\\s*-> (.+)$/, (result, [tracking]) => {\n      result.deleted.push({\n         tracking,\n      });\n   }),\n   new LineParser(\n      /\\s*([^.]+)\\.\\.(\\S+)\\s+(\\S+)\\s*-> (.+)$/,\n      (result, [from, to, name, tracking]) => {\n         result.updated.push({\n            name,\n            tracking,\n            to,\n            from,\n         });\n      }\n   ),\n];\n\nexport function parseFetchResult(stdOut: string, stdErr: string): FetchResult {\n   const result: FetchResult = {\n      raw: stdOut,\n      remote: null,\n      branches: [],\n      tags: [],\n      updated: [],\n      deleted: [],\n   };\n   return parseStringResponse(result, parsers, [stdOut, stdErr]);\n}\n", "import { FetchResult } from '../../../typings';\nimport { parseFetchResult } from '../parsers/parse-fetch';\nimport { StringTask } from '../types';\n\nimport { configurationErrorTask, EmptyTask } from './task';\n\nfunction disallowedCommand(command: string) {\n   return /^--upload-pack(=|$)/.test(command);\n}\n\nexport function fetchTask(\n   remote: string,\n   branch: string,\n   customArgs: string[]\n): StringTask<FetchResult> | EmptyTask {\n   const commands = ['fetch', ...customArgs];\n   if (remote && branch) {\n      commands.push(remote, branch);\n   }\n\n   const banned = commands.find(disallowedCommand);\n   if (banned) {\n      return configurationErrorTask(`git.fetch: potential exploit argument blocked.`);\n   }\n\n   return {\n      commands,\n      format: 'utf-8',\n      parser: parseFetchResult,\n   };\n}\n", "import { MoveResult } from '../../../typings';\nimport { LineParser, parseStringResponse } from '../utils';\n\nconst parsers: LineParser<MoveResult>[] = [\n   new LineParser(/^Renaming (.+) to (.+)$/, (result, [from, to]) => {\n      result.moves.push({ from, to });\n   }),\n];\n\nexport function parseMoveResult(stdOut: string): MoveResult {\n   return parseStringResponse({ moves: [] }, parsers, stdOut);\n}\n", "import { MoveResult } from '../../../typings';\nimport { parseMoveResult } from '../parsers/parse-move';\nimport { StringTask } from '../types';\nimport { asArray } from '../utils';\n\nexport function moveTask(from: string | string[], to: string): StringTask<MoveResult> {\n   return {\n      commands: ['mv', '-v', ...asArray(from), to],\n      format: 'utf-8',\n      parser: parseMoveResult,\n   };\n}\n", "import { PullResult } from '../../../typings';\nimport { GitResponseError } from '../errors/git-response-error';\nimport { parsePullErrorResult, parsePullResult } from '../parsers/parse-pull';\nimport { Maybe, StringTask } from '../types';\nimport { bufferToString } from '../utils';\n\nexport function pullTask(\n   remote: Maybe<string>,\n   branch: Maybe<string>,\n   customArgs: string[]\n): StringTask<PullResult> {\n   const commands: string[] = ['pull', ...customArgs];\n   if (remote && branch) {\n      commands.splice(1, 0, remote, branch);\n   }\n\n   return {\n      commands,\n      format: 'utf-8',\n      parser(stdOut, stdErr): PullResult {\n         return parsePullResult(stdOut, stdErr);\n      },\n      onError(result, _error, _done, fail) {\n         const pullError = parsePullErrorResult(\n            bufferToString(result.stdOut),\n            bufferToString(result.stdErr)\n         );\n         if (pullError) {\n            return fail(new GitResponseError(pullError));\n         }\n\n         fail(_error);\n      },\n   };\n}\n", "import { forEachLineWithContent } from '../utils';\n\nexport interface RemoteWithoutRefs {\n   name: string;\n}\n\nexport interface RemoteWithRefs extends RemoteWithoutRefs {\n   refs: {\n      fetch: string;\n      push: string;\n   };\n}\n\nexport function parseGetRemotes(text: string): RemoteWithoutRefs[] {\n   const remotes: { [name: string]: RemoteWithoutRefs } = {};\n\n   forEach(text, ([name]) => (remotes[name] = { name }));\n\n   return Object.values(remotes);\n}\n\nexport function parseGetRemotesVerbose(text: string): RemoteWithRefs[] {\n   const remotes: { [name: string]: RemoteWithRefs } = {};\n\n   forEach(text, ([name, url, purpose]) => {\n      if (!remotes.hasOwnProperty(name)) {\n         remotes[name] = {\n            name: name,\n            refs: { fetch: '', push: '' },\n         };\n      }\n\n      if (purpose && url) {\n         remotes[name].refs[purpose.replace(/[^a-z]/g, '') as keyof RemoteWithRefs['refs']] = url;\n      }\n   });\n\n   return Object.values(remotes);\n}\n\nfunction forEach(text: string, handler: (line: string[]) => void) {\n   forEachLineWithContent(text, (line) => handler(line.split(/\\s+/)));\n}\n", "import { parseGetRemotes, parseGetRemotesVerbose } from '../responses/GetRemoteSummary';\nimport { StringTask } from '../types';\nimport { straightThroughStringTask } from './task';\n\nexport function addRemoteTask(\n   remoteName: string,\n   remoteRepo: string,\n   customArgs: string[] = []\n): StringTask<string> {\n   return straightThroughStringTask(['remote', 'add', ...customArgs, remoteName, remoteRepo]);\n}\n\nexport function getRemotesTask(verbose: boolean): StringTask<any> {\n   const commands = ['remote'];\n   if (verbose) {\n      commands.push('-v');\n   }\n\n   return {\n      commands,\n      format: 'utf-8',\n      parser: verbose ? parseGetRemotesVerbose : parseGetRemotes,\n   };\n}\n\nexport function listRemotesTask(customArgs: string[] = []): StringTask<string> {\n   const commands = [...customArgs];\n   if (commands[0] !== 'ls-remote') {\n      commands.unshift('ls-remote');\n   }\n\n   return straightThroughStringTask(commands);\n}\n\nexport function remoteTask(customArgs: string[] = []): StringTask<string> {\n   const commands = [...customArgs];\n   if (commands[0] !== 'remote') {\n      commands.unshift('remote');\n   }\n\n   return straightThroughStringTask(commands);\n}\n\nexport function removeRemoteTask(remoteName: string) {\n   return straightThroughStringTask(['remote', 'remove', remoteName]);\n}\n", "import { LogOptions, LogResult } from '../../../typings';\nimport { logFormatFromCommand } from '../args/log-format';\nimport { createListLogSummaryParser } from '../parsers/parse-list-log-summary';\nimport type { StringTask } from '../types';\nimport { validateLogFormatConfig } from './diff';\nimport { parseLogOptions } from './log';\nimport type { EmptyTask } from './task';\n\nexport function stashListTask(\n   opt: LogOptions = {},\n   customArgs: string[]\n): EmptyTask | StringTask<LogResult> {\n   const options = parseLogOptions<any>(opt);\n   const commands = ['stash', 'list', ...options.commands, ...customArgs];\n   const parser = createListLogSummaryParser(\n      options.splitter,\n      options.fields,\n      logFormatFromCommand(commands)\n   );\n\n   return (\n      validateLogFormatConfig(commands) || {\n         commands,\n         format: 'utf-8',\n         parser,\n      }\n   );\n}\n", "import { StringTask } from '../types';\nimport { straightThroughStringTask } from './task';\n\nexport function addSubModuleTask(repo: string, path: string): StringTask<string> {\n   return subModuleTask(['add', repo, path]);\n}\n\nexport function initSubModuleTask(customArgs: string[]): StringTask<string> {\n   return subModuleTask(['init', ...customArgs]);\n}\n\nexport function subModuleTask(customArgs: string[]): StringTask<string> {\n   const commands = [...customArgs];\n   if (commands[0] !== 'submodule') {\n      commands.unshift('submodule');\n   }\n\n   return straightThroughStringTask(commands);\n}\n\nexport function updateSubModuleTask(customArgs: string[]): StringTask<string> {\n   return subModuleTask(['update', ...customArgs]);\n}\n", "import { TagResult } from '../../../typings';\n\nexport class TagList implements TagResult {\n   constructor(\n      public readonly all: string[],\n      public readonly latest: string | undefined\n   ) {}\n}\n\nexport const parseTagList = function (data: string, customSort = false) {\n   const tags = data.split('\\n').map(trimmed).filter(Boolean);\n\n   if (!customSort) {\n      tags.sort(function (tagA, tagB) {\n         const partsA = tagA.split('.');\n         const partsB = tagB.split('.');\n\n         if (partsA.length === 1 || partsB.length === 1) {\n            return singleSorted(toNumber(partsA[0]), toNumber(partsB[0]));\n         }\n\n         for (let i = 0, l = Math.max(partsA.length, partsB.length); i < l; i++) {\n            const diff = sorted(toNumber(partsA[i]), toNumber(partsB[i]));\n\n            if (diff) {\n               return diff;\n            }\n         }\n\n         return 0;\n      });\n   }\n\n   const latest = customSort ? tags[0] : [...tags].reverse().find((tag) => tag.indexOf('.') >= 0);\n\n   return new TagList(tags, latest);\n};\n\nfunction singleSorted(a: number, b: number): number {\n   const aIsNum = isNaN(a);\n   const bIsNum = isNaN(b);\n\n   if (aIsNum !== bIsNum) {\n      return aIsNum ? 1 : -1;\n   }\n\n   return aIsNum ? sorted(a, b) : 0;\n}\n\nfunction sorted(a: number, b: number) {\n   return a === b ? 0 : a > b ? 1 : -1;\n}\n\nfunction trimmed(input: string) {\n   return input.trim();\n}\n\nfunction toNumber(input: string | undefined) {\n   if (typeof input === 'string') {\n      return parseInt(input.replace(/^\\D+/g, ''), 10) || 0;\n   }\n\n   return 0;\n}\n", "import { TagResult } from '../../../typings';\nimport { parseTagList } from '../responses/TagList';\nimport { StringTask } from '../types';\n\n/**\n * Task used by `git.tags`\n */\nexport function tagListTask(customArgs: string[] = []): StringTask<TagResult> {\n   const hasCustomSort = customArgs.some((option) => /^--sort=/.test(option));\n\n   return {\n      format: 'utf-8',\n      commands: ['tag', '-l', ...customArgs],\n      parser(text: string) {\n         return parseTagList(text, hasCustomSort);\n      },\n   };\n}\n\n/**\n * Task used by `git.addTag`\n */\nexport function addTagTask(name: string): StringTask<{ name: string }> {\n   return {\n      format: 'utf-8',\n      commands: ['tag', name],\n      parser() {\n         return { name };\n      },\n   };\n}\n\n/**\n * Task used by `git.addTag`\n */\nexport function addAnnotatedTagTask(\n   name: string,\n   tagMessage: string\n): StringTask<{ name: string }> {\n   return {\n      format: 'utf-8',\n      commands: ['tag', '-a', '-m', tagMessage, name],\n      parser() {\n         return { name };\n      },\n   };\n}\n", "const { GitExecutor } = require('./lib/runners/git-executor');\nconst { SimpleGitApi } = require('./lib/simple-git-api');\n\nconst { Scheduler } = require('./lib/runners/scheduler');\nconst { configurationErrorTask } = require('./lib/tasks/task');\nconst {\n   asArray,\n   filterArray,\n   filterPrimitives,\n   filterString,\n   filterStringOrStringArray,\n   filterType,\n   getTrailingOptions,\n   trailingFunctionArgument,\n   trailingOptionsArgument,\n} = require('./lib/utils');\nconst { applyPatchTask } = require('./lib/tasks/apply-patch');\nconst {\n   branchTask,\n   branchLocalTask,\n   deleteBranchesTask,\n   deleteBranchTask,\n} = require('./lib/tasks/branch');\nconst { checkIgnoreTask } = require('./lib/tasks/check-ignore');\nconst { checkIsRepoTask } = require('./lib/tasks/check-is-repo');\nconst { cloneTask, cloneMirrorTask } = require('./lib/tasks/clone');\nconst { cleanWithOptionsTask, isCleanOptionsArray } = require('./lib/tasks/clean');\nconst { diffSummaryTask } = require('./lib/tasks/diff');\nconst { fetchTask } = require('./lib/tasks/fetch');\nconst { moveTask } = require('./lib/tasks/move');\nconst { pullTask } = require('./lib/tasks/pull');\nconst { pushTagsTask } = require('./lib/tasks/push');\nconst {\n   addRemoteTask,\n   getRemotesTask,\n   listRemotesTask,\n   remoteTask,\n   removeRemoteTask,\n} = require('./lib/tasks/remote');\nconst { getResetMode, resetTask } = require('./lib/tasks/reset');\nconst { stashListTask } = require('./lib/tasks/stash-list');\nconst {\n   addSubModuleTask,\n   initSubModuleTask,\n   subModuleTask,\n   updateSubModuleTask,\n} = require('./lib/tasks/sub-module');\nconst { addAnnotatedTagTask, addTagTask, tagListTask } = require('./lib/tasks/tag');\nconst { straightThroughBufferTask, straightThroughStringTask } = require('./lib/tasks/task');\n\nfunction Git(options, plugins) {\n   this._executor = new GitExecutor(\n      options.binary,\n      options.baseDir,\n      new Scheduler(options.maxConcurrentProcesses),\n      plugins\n   );\n\n   this._trimmed = options.trimmed;\n}\n\n(Git.prototype = Object.create(SimpleGitApi.prototype)).constructor = Git;\n\n/**\n * Sets the path to a custom git binary, should either be `git` when there is an installation of git available on\n * the system path, or a fully qualified path to the executable.\n *\n * @param {string} command\n * @returns {Git}\n */\nGit.prototype.customBinary = function (command) {\n   this._executor.binary = command;\n   return this;\n};\n\n/**\n * Sets an environment variable for the spawned child process, either supply both a name and value as strings or\n * a single object to entirely replace the current environment variables.\n *\n * @param {string|Object} name\n * @param {string} [value]\n * @returns {Git}\n */\nGit.prototype.env = function (name, value) {\n   if (arguments.length === 1 && typeof name === 'object') {\n      this._executor.env = name;\n   } else {\n      (this._executor.env = this._executor.env || {})[name] = value;\n   }\n\n   return this;\n};\n\n/**\n * List the stash(s) of the local repo\n */\nGit.prototype.stashList = function (options) {\n   return this._runTask(\n      stashListTask(\n         trailingOptionsArgument(arguments) || {},\n         (filterArray(options) && options) || []\n      ),\n      trailingFunctionArgument(arguments)\n   );\n};\n\nfunction createCloneTask(api, task, repoPath, localPath) {\n   if (typeof repoPath !== 'string') {\n      return configurationErrorTask(`git.${api}() requires a string 'repoPath'`);\n   }\n\n   return task(repoPath, filterType(localPath, filterString), getTrailingOptions(arguments));\n}\n\n/**\n * Clone a git repo\n */\nGit.prototype.clone = function () {\n   return this._runTask(\n      createCloneTask('clone', cloneTask, ...arguments),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Mirror a git repo\n */\nGit.prototype.mirror = function () {\n   return this._runTask(\n      createCloneTask('mirror', cloneMirrorTask, ...arguments),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Moves one or more files to a new destination.\n *\n * @see https://git-scm.com/docs/git-mv\n *\n * @param {string|string[]} from\n * @param {string} to\n */\nGit.prototype.mv = function (from, to) {\n   return this._runTask(moveTask(from, to), trailingFunctionArgument(arguments));\n};\n\n/**\n * Internally uses pull and tags to get the list of tags then checks out the latest tag.\n *\n * @param {Function} [then]\n */\nGit.prototype.checkoutLatestTag = function (then) {\n   var git = this;\n   return this.pull(function () {\n      git.tags(function (err, tags) {\n         git.checkout(tags.latest, then);\n      });\n   });\n};\n\n/**\n * Pull the updated contents of the current repo\n */\nGit.prototype.pull = function (remote, branch, options, then) {\n   return this._runTask(\n      pullTask(\n         filterType(remote, filterString),\n         filterType(branch, filterString),\n         getTrailingOptions(arguments)\n      ),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Fetch the updated contents of the current repo.\n *\n * @example\n *   .fetch('upstream', 'master') // fetches from master on remote named upstream\n *   .fetch(function () {}) // runs fetch against default remote and branch and calls function\n *\n * @param {string} [remote]\n * @param {string} [branch]\n */\nGit.prototype.fetch = function (remote, branch) {\n   return this._runTask(\n      fetchTask(\n         filterType(remote, filterString),\n         filterType(branch, filterString),\n         getTrailingOptions(arguments)\n      ),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Disables/enables the use of the console for printing warnings and errors, by default messages are not shown in\n * a production environment.\n *\n * @param {boolean} silence\n * @returns {Git}\n */\nGit.prototype.silent = function (silence) {\n   console.warn(\n      'simple-git deprecation notice: git.silent: logging should be configured using the `debug` library / `DEBUG` environment variable, this will be an error in version 3'\n   );\n   return this;\n};\n\n/**\n * List all tags. When using git 2.7.0 or above, include an options object with `\"--sort\": \"property-name\"` to\n * sort the tags by that property instead of using the default semantic versioning sort.\n *\n * Note, supplying this option when it is not supported by your Git version will cause the operation to fail.\n *\n * @param {Object} [options]\n * @param {Function} [then]\n */\nGit.prototype.tags = function (options, then) {\n   return this._runTask(\n      tagListTask(getTrailingOptions(arguments)),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Rebases the current working copy. Options can be supplied either as an array of string parameters\n * to be sent to the `git rebase` command, or a standard options object.\n */\nGit.prototype.rebase = function () {\n   return this._runTask(\n      straightThroughStringTask(['rebase', ...getTrailingOptions(arguments)]),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Reset a repo\n */\nGit.prototype.reset = function (mode) {\n   return this._runTask(\n      resetTask(getResetMode(mode), getTrailingOptions(arguments)),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Revert one or more commits in the local working copy\n */\nGit.prototype.revert = function (commit) {\n   const next = trailingFunctionArgument(arguments);\n\n   if (typeof commit !== 'string') {\n      return this._runTask(configurationErrorTask('Commit must be a string'), next);\n   }\n\n   return this._runTask(\n      straightThroughStringTask(['revert', ...getTrailingOptions(arguments, 0, true), commit]),\n      next\n   );\n};\n\n/**\n * Add a lightweight tag to the head of the current branch\n */\nGit.prototype.addTag = function (name) {\n   const task =\n      typeof name === 'string'\n         ? addTagTask(name)\n         : configurationErrorTask('Git.addTag requires a tag name');\n\n   return this._runTask(task, trailingFunctionArgument(arguments));\n};\n\n/**\n * Add an annotated tag to the head of the current branch\n */\nGit.prototype.addAnnotatedTag = function (tagName, tagMessage) {\n   return this._runTask(\n      addAnnotatedTagTask(tagName, tagMessage),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Delete a local branch\n */\nGit.prototype.deleteLocalBranch = function (branchName, forceDelete, then) {\n   return this._runTask(\n      deleteBranchTask(branchName, typeof forceDelete === 'boolean' ? forceDelete : false),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Delete one or more local branches\n */\nGit.prototype.deleteLocalBranches = function (branchNames, forceDelete, then) {\n   return this._runTask(\n      deleteBranchesTask(branchNames, typeof forceDelete === 'boolean' ? forceDelete : false),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * List all branches\n *\n * @param {Object | string[]} [options]\n * @param {Function} [then]\n */\nGit.prototype.branch = function (options, then) {\n   return this._runTask(\n      branchTask(getTrailingOptions(arguments)),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Return list of local branches\n *\n * @param {Function} [then]\n */\nGit.prototype.branchLocal = function (then) {\n   return this._runTask(branchLocalTask(), trailingFunctionArgument(arguments));\n};\n\n/**\n * Executes any command against the git binary.\n */\nGit.prototype.raw = function (commands) {\n   const createRestCommands = !Array.isArray(commands);\n   const command = [].slice.call(createRestCommands ? arguments : commands, 0);\n\n   for (let i = 0; i < command.length && createRestCommands; i++) {\n      if (!filterPrimitives(command[i])) {\n         command.splice(i, command.length - i);\n         break;\n      }\n   }\n\n   command.push(...getTrailingOptions(arguments, 0, true));\n\n   var next = trailingFunctionArgument(arguments);\n\n   if (!command.length) {\n      return this._runTask(\n         configurationErrorTask('Raw: must supply one or more command to execute'),\n         next\n      );\n   }\n\n   return this._runTask(straightThroughStringTask(command, this._trimmed), next);\n};\n\nGit.prototype.submoduleAdd = function (repo, path, then) {\n   return this._runTask(addSubModuleTask(repo, path), trailingFunctionArgument(arguments));\n};\n\nGit.prototype.submoduleUpdate = function (args, then) {\n   return this._runTask(\n      updateSubModuleTask(getTrailingOptions(arguments, true)),\n      trailingFunctionArgument(arguments)\n   );\n};\n\nGit.prototype.submoduleInit = function (args, then) {\n   return this._runTask(\n      initSubModuleTask(getTrailingOptions(arguments, true)),\n      trailingFunctionArgument(arguments)\n   );\n};\n\nGit.prototype.subModule = function (options, then) {\n   return this._runTask(\n      subModuleTask(getTrailingOptions(arguments)),\n      trailingFunctionArgument(arguments)\n   );\n};\n\nGit.prototype.listRemote = function () {\n   return this._runTask(\n      listRemotesTask(getTrailingOptions(arguments)),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Adds a remote to the list of remotes.\n */\nGit.prototype.addRemote = function (remoteName, remoteRepo, then) {\n   return this._runTask(\n      addRemoteTask(remoteName, remoteRepo, getTrailingOptions(arguments)),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Removes an entry by name from the list of remotes.\n */\nGit.prototype.removeRemote = function (remoteName, then) {\n   return this._runTask(removeRemoteTask(remoteName), trailingFunctionArgument(arguments));\n};\n\n/**\n * Gets the currently available remotes, setting the optional verbose argument to true includes additional\n * detail on the remotes themselves.\n */\nGit.prototype.getRemotes = function (verbose, then) {\n   return this._runTask(getRemotesTask(verbose === true), trailingFunctionArgument(arguments));\n};\n\n/**\n * Call any `git remote` function with arguments passed as an array of strings.\n *\n * @param {string[]} options\n * @param {Function} [then]\n */\nGit.prototype.remote = function (options, then) {\n   return this._runTask(\n      remoteTask(getTrailingOptions(arguments)),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Call any `git tag` function with arguments passed as an array of strings.\n *\n * @param {string[]} options\n * @param {Function} [then]\n */\nGit.prototype.tag = function (options, then) {\n   const command = getTrailingOptions(arguments);\n\n   if (command[0] !== 'tag') {\n      command.unshift('tag');\n   }\n\n   return this._runTask(straightThroughStringTask(command), trailingFunctionArgument(arguments));\n};\n\n/**\n * Updates repository server info\n *\n * @param {Function} [then]\n */\nGit.prototype.updateServerInfo = function (then) {\n   return this._runTask(\n      straightThroughStringTask(['update-server-info']),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Pushes the current tag changes to a remote which can be either a URL or named remote. When not specified uses the\n * default configured remote spec.\n *\n * @param {string} [remote]\n * @param {Function} [then]\n */\nGit.prototype.pushTags = function (remote, then) {\n   const task = pushTagsTask(\n      { remote: filterType(remote, filterString) },\n      getTrailingOptions(arguments)\n   );\n\n   return this._runTask(task, trailingFunctionArgument(arguments));\n};\n\n/**\n * Removes the named files from source control.\n */\nGit.prototype.rm = function (files) {\n   return this._runTask(\n      straightThroughStringTask(['rm', '-f', ...asArray(files)]),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Removes the named files from source control but keeps them on disk rather than deleting them entirely. To\n * completely remove the files, use `rm`.\n *\n * @param {string|string[]} files\n */\nGit.prototype.rmKeepLocal = function (files) {\n   return this._runTask(\n      straightThroughStringTask(['rm', '--cached', ...asArray(files)]),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n * Returns a list of objects in a tree based on commit hash. Passing in an object hash returns the object's content,\n * size, and type.\n *\n * Passing \"-p\" will instruct cat-file to determine the object type, and display its formatted contents.\n *\n * @param {string[]} [options]\n * @param {Function} [then]\n */\nGit.prototype.catFile = function (options, then) {\n   return this._catFile('utf-8', arguments);\n};\n\nGit.prototype.binaryCatFile = function () {\n   return this._catFile('buffer', arguments);\n};\n\nGit.prototype._catFile = function (format, args) {\n   var handler = trailingFunctionArgument(args);\n   var command = ['cat-file'];\n   var options = args[0];\n\n   if (typeof options === 'string') {\n      return this._runTask(\n         configurationErrorTask('Git.catFile: options must be supplied as an array of strings'),\n         handler\n      );\n   }\n\n   if (Array.isArray(options)) {\n      command.push.apply(command, options);\n   }\n\n   const task =\n      format === 'buffer' ? straightThroughBufferTask(command) : straightThroughStringTask(command);\n\n   return this._runTask(task, handler);\n};\n\nGit.prototype.diff = function (options, then) {\n   const task = filterString(options)\n      ? configurationErrorTask(\n           'git.diff: supplying options as a single string is no longer supported, switch to an array of strings'\n        )\n      : straightThroughStringTask(['diff', ...getTrailingOptions(arguments)]);\n\n   return this._runTask(task, trailingFunctionArgument(arguments));\n};\n\nGit.prototype.diffSummary = function () {\n   return this._runTask(\n      diffSummaryTask(getTrailingOptions(arguments, 1)),\n      trailingFunctionArgument(arguments)\n   );\n};\n\nGit.prototype.applyPatch = function (patches) {\n   const task = !filterStringOrStringArray(patches)\n      ? configurationErrorTask(\n           `git.applyPatch requires one or more string patches as the first argument`\n        )\n      : applyPatchTask(asArray(patches), getTrailingOptions([].slice.call(arguments, 1)));\n\n   return this._runTask(task, trailingFunctionArgument(arguments));\n};\n\nGit.prototype.revparse = function () {\n   const commands = ['rev-parse', ...getTrailingOptions(arguments, true)];\n   return this._runTask(\n      straightThroughStringTask(commands, true),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n */\nGit.prototype.clean = function (mode, options, then) {\n   const usingCleanOptionsArray = isCleanOptionsArray(mode);\n   const cleanMode =\n      (usingCleanOptionsArray && mode.join('')) || filterType(mode, filterString) || '';\n   const customArgs = getTrailingOptions([].slice.call(arguments, usingCleanOptionsArray ? 1 : 0));\n\n   return this._runTask(\n      cleanWithOptionsTask(cleanMode, customArgs),\n      trailingFunctionArgument(arguments)\n   );\n};\n\nGit.prototype.exec = function (then) {\n   const task = {\n      commands: [],\n      format: 'utf-8',\n      parser() {\n         if (typeof then === 'function') {\n            then();\n         }\n      },\n   };\n\n   return this._runTask(task);\n};\n\n/**\n * Clears the queue of pending commands and returns the wrapper instance for chaining.\n *\n * @returns {Git}\n */\nGit.prototype.clearQueue = function () {\n   // TODO:\n   // this._executor.clear();\n   return this;\n};\n\n/**\n * Check if a pathname or pathnames are excluded by .gitignore\n *\n * @param {string|string[]} pathnames\n * @param {Function} [then]\n */\nGit.prototype.checkIgnore = function (pathnames, then) {\n   return this._runTask(\n      checkIgnoreTask(asArray(filterType(pathnames, filterStringOrStringArray, []))),\n      trailingFunctionArgument(arguments)\n   );\n};\n\nGit.prototype.checkIsRepo = function (checkType, then) {\n   return this._runTask(\n      checkIsRepoTask(filterType(checkType, filterString)),\n      trailingFunctionArgument(arguments)\n   );\n};\n\nmodule.exports = Git;\n", "import { pathspec } from './args/pathspec';\nimport { GitConstructError } from './errors/git-construct-error';\nimport { GitError } from './errors/git-error';\nimport { GitPluginError } from './errors/git-plugin-error';\nimport { GitResponseError } from './errors/git-response-error';\nimport { TaskConfigurationError } from './errors/task-configuration-error';\nimport { CheckRepoActions } from './tasks/check-is-repo';\nimport { CleanOptions } from './tasks/clean';\nimport { GitConfigScope } from './tasks/config';\nimport { DiffNameStatus } from './tasks/diff-name-status';\nimport { grepQueryBuilder } from './tasks/grep';\nimport { ResetMode } from './tasks/reset';\n\nexport {\n   CheckRepoActions,\n   CleanOptions,\n   DiffNameStatus,\n   GitConfigScope,\n   GitConstructError,\n   GitError,\n   GitPluginError,\n   GitResponseError,\n   ResetMode,\n   TaskConfigurationError,\n   grepQueryBuilder,\n   pathspec,\n};\n", "import { GitError } from './git-error';\nimport { SimpleGitOptions } from '../types';\n\n/**\n * The `GitConstructError` is thrown when an error occurs in the constructor\n * of the `simple-git` instance itself. Most commonly as a result of using\n * a `baseDir` option that points to a folder that either does not exist,\n * or cannot be read by the user the node script is running as.\n *\n * Check the `.message` property for more detail including the properties\n * passed to the constructor.\n */\nexport class GitConstructError extends GitError {\n   constructor(\n      public readonly config: SimpleGitOptions,\n      message: string\n   ) {\n      super(undefined, message);\n   }\n}\n", "import { SimpleGitOptions, SimpleGitTask } from '../types';\nimport { GitError } from './git-error';\n\nexport class GitPluginError extends GitError {\n   constructor(\n      public task?: SimpleGitTask<any>,\n      public readonly plugin?: keyof SimpleGitOptions,\n      message?: string\n   ) {\n      super(task, message);\n      Object.setPrototypeOf(this, new.target.prototype);\n   }\n}\n", "import { SimpleGitOptions } from '../types';\nimport { SimpleGitPlugin } from './simple-git-plugin';\nimport { GitPluginError } from '../errors/git-plugin-error';\n\nexport function abortPlugin(signal: SimpleGitOptions['abort']) {\n   if (!signal) {\n      return;\n   }\n\n   const onSpawnAfter: SimpleGitPlugin<'spawn.after'> = {\n      type: 'spawn.after',\n      action(_data, context) {\n         function kill() {\n            context.kill(new GitPluginError(undefined, 'abort', 'Abort signal received'));\n         }\n\n         signal.addEventListener('abort', kill);\n\n         context.spawned.on('close', () => signal.removeEventListener('abort', kill));\n      },\n   };\n\n   const onSpawnBefore: SimpleGitPlugin<'spawn.before'> = {\n      type: 'spawn.before',\n      action(_data, context) {\n         if (signal.aborted) {\n            context.kill(new GitPluginError(undefined, 'abort', 'Abort already signaled'));\n         }\n      },\n   };\n\n   return [onSpawnBefore, onSpawnAfter];\n}\n", "import type { SimpleGitPlugin } from './simple-git-plugin';\n\nimport { GitPluginError } from '../errors/git-plugin-error';\nimport type { SimpleGitPluginConfig } from '../types';\n\nfunction isConfigSwitch(arg: string | unknown) {\n   return typeof arg === 'string' && arg.trim().toLowerCase() === '-c';\n}\n\nfunction preventProtocolOverride(arg: string, next: string) {\n   if (!isConfigSwitch(arg)) {\n      return;\n   }\n\n   if (!/^\\s*protocol(.[a-z]+)?.allow/.test(next)) {\n      return;\n   }\n\n   throw new GitPluginError(\n      undefined,\n      'unsafe',\n      'Configuring protocol.allow is not permitted without enabling allowUnsafeExtProtocol'\n   );\n}\n\nfunction preventUploadPack(arg: string, method: string) {\n   if (/^\\s*--(upload|receive)-pack/.test(arg)) {\n      throw new GitPluginError(\n         undefined,\n         'unsafe',\n         `Use of --upload-pack or --receive-pack is not permitted without enabling allowUnsafePack`\n      );\n   }\n\n   if (method === 'clone' && /^\\s*-u\\b/.test(arg)) {\n      throw new GitPluginError(\n         undefined,\n         'unsafe',\n         `Use of clone with option -u is not permitted without enabling allowUnsafePack`\n      );\n   }\n\n   if (method === 'push' && /^\\s*--exec\\b/.test(arg)) {\n      throw new GitPluginError(\n         undefined,\n         'unsafe',\n         `Use of push with option --exec is not permitted without enabling allowUnsafePack`\n      );\n   }\n}\n\nexport function blockUnsafeOperationsPlugin({\n   allowUnsafeProtocolOverride = false,\n   allowUnsafePack = false,\n}: SimpleGitPluginConfig['unsafe'] = {}): SimpleGitPlugin<'spawn.args'> {\n   return {\n      type: 'spawn.args',\n      action(args, context) {\n         args.forEach((current, index) => {\n            const next = index < args.length ? args[index + 1] : '';\n\n            allowUnsafeProtocolOverride || preventProtocolOverride(current, next);\n            allowUnsafePack || preventUploadPack(current, context.method);\n         });\n\n         return args;\n      },\n   };\n}\n", "import { prefixedArray } from '../utils';\nimport { SimpleGitPlugin } from './simple-git-plugin';\n\nexport function commandConfigPrefixingPlugin(\n   configuration: string[]\n): SimpleGitPlugin<'spawn.args'> {\n   const prefix = prefixedArray(configuration, '-c');\n\n   return {\n      type: 'spawn.args',\n      action(data) {\n         return [...prefix, ...data];\n      },\n   };\n}\n", "import { deferred, DeferredPromise } from '@kwsites/promise-deferred';\nimport { SimpleGitPluginConfig } from '../types';\nimport { delay } from '../utils';\nimport { SimpleGitPlugin } from './simple-git-plugin';\n\nconst never = deferred().promise;\n\nexport function completionDetectionPlugin({\n   onClose = true,\n   onExit = 50,\n}: SimpleGitPluginConfig['completion'] = {}): SimpleGitPlugin<'spawn.after'> {\n   function createEvents() {\n      let exitCode = -1;\n      const events = {\n         close: deferred(),\n         closeTimeout: deferred(),\n         exit: deferred(),\n         exitTimeout: deferred(),\n      };\n\n      const result = Promise.race([\n         onClose === false ? never : events.closeTimeout.promise,\n         onExit === false ? never : events.exitTimeout.promise,\n      ]);\n\n      configureTimeout(onClose, events.close, events.closeTimeout);\n      configureTimeout(onExit, events.exit, events.exitTimeout);\n\n      return {\n         close(code: number) {\n            exitCode = code;\n            events.close.done();\n         },\n         exit(code: number) {\n            exitCode = code;\n            events.exit.done();\n         },\n         get exitCode() {\n            return exitCode;\n         },\n         result,\n      };\n   }\n\n   function configureTimeout(\n      flag: boolean | number,\n      event: DeferredPromise<void>,\n      timeout: DeferredPromise<void>\n   ) {\n      if (flag === false) {\n         return;\n      }\n\n      (flag === true ? event.promise : event.promise.then(() => delay(flag))).then(timeout.done);\n   }\n\n   return {\n      type: 'spawn.after',\n      async action(_data, { spawned, close }) {\n         const events = createEvents();\n\n         let deferClose = true;\n         let quickClose = () => void (deferClose = false);\n\n         spawned.stdout?.on('data', quickClose);\n         spawned.stderr?.on('data', quickClose);\n         spawned.on('error', quickClose);\n\n         spawned.on('close', (code: number) => events.close(code));\n         spawned.on('exit', (code: number) => events.exit(code));\n\n         try {\n            await events.result;\n            if (deferClose) {\n               await delay(50);\n            }\n            close(events.exitCode);\n         } catch (err) {\n            close(events.exitCode, err as Error);\n         }\n      },\n   };\n}\n", "import { GitError } from '../errors/git-error';\nimport { GitExecutorResult, SimpleGitPluginConfig } from '../types';\nimport { SimpleGitPlugin } from './simple-git-plugin';\n\ntype TaskResult = Omit<GitExecutorResult, 'rejection'>;\n\nfunction isTaskError(result: TaskResult) {\n   return !!(result.exitCode && result.stdErr.length);\n}\n\nfunction getErrorMessage(result: TaskResult) {\n   return Buffer.concat([...result.stdOut, ...result.stdErr]);\n}\n\nexport function errorDetectionHandler(\n   overwrite = false,\n   isError = isTaskError,\n   errorMessage: (result: TaskResult) => Buffer | Error = getErrorMessage\n) {\n   return (error: Buffer | Error | undefined, result: TaskResult) => {\n      if ((!overwrite && error) || !isError(result)) {\n         return error;\n      }\n\n      return errorMessage(result);\n   };\n}\n\nexport function errorDetectionPlugin(\n   config: SimpleGitPluginConfig['errors']\n): SimpleGitPlugin<'task.error'> {\n   return {\n      type: 'task.error',\n      action(data, context) {\n         const error = config(data.error, {\n            stdErr: context.stdErr,\n            stdOut: context.stdOut,\n            exitCode: context.exitCode,\n         });\n\n         if (Buffer.isBuffer(error)) {\n            return { error: new GitError(undefined, error.toString('utf-8')) };\n         }\n\n         return {\n            error,\n         };\n      },\n   };\n}\n", "import { SimpleGitPlugin, SimpleGitPluginType, SimpleGitPluginTypes } from './simple-git-plugin';\nimport { append, asArray } from '../utils';\n\nexport class PluginStore {\n   private plugins: Set<SimpleGitPlugin<SimpleGitPluginType>> = new Set();\n\n   public add<T extends SimpleGitPluginType>(\n      plugin: void | SimpleGitPlugin<T> | SimpleGitPlugin<T>[]\n   ) {\n      const plugins: SimpleGitPlugin<T>[] = [];\n\n      asArray(plugin).forEach((plugin) => plugin && this.plugins.add(append(plugins, plugin)));\n\n      return () => {\n         plugins.forEach((plugin) => this.plugins.delete(plugin));\n      };\n   }\n\n   public exec<T extends SimpleGitPluginType>(\n      type: T,\n      data: SimpleGitPluginTypes[T]['data'],\n      context: SimpleGitPluginTypes[T]['context']\n   ): typeof data {\n      let output = data;\n      const contextual = Object.freeze(Object.create(context));\n\n      for (const plugin of this.plugins) {\n         if (plugin.type === type) {\n            output = plugin.action(output, contextual);\n         }\n      }\n\n      return output;\n   }\n}\n", "import { SimpleGitOptions } from '../types';\nimport { asNumber, including } from '../utils';\n\nimport { SimpleGitPlugin } from './simple-git-plugin';\n\nexport function progressMonitorPlugin(progress: Exclude<SimpleGitOptions['progress'], void>) {\n   const progressCommand = '--progress';\n   const progressMethods = ['checkout', 'clone', 'fetch', 'pull', 'push'];\n\n   const onProgress: SimpleGitPlugin<'spawn.after'> = {\n      type: 'spawn.after',\n      action(_data, context) {\n         if (!context.commands.includes(progressCommand)) {\n            return;\n         }\n\n         context.spawned.stderr?.on('data', (chunk: Buffer) => {\n            const message = /^([\\s\\S]+?):\\s*(\\d+)% \\((\\d+)\\/(\\d+)\\)/.exec(chunk.toString('utf8'));\n            if (!message) {\n               return;\n            }\n\n            progress({\n               method: context.method,\n               stage: progressEventStage(message[1]),\n               progress: asNumber(message[2]),\n               processed: asNumber(message[3]),\n               total: asNumber(message[4]),\n            });\n         });\n      },\n   };\n\n   const onArgs: SimpleGitPlugin<'spawn.args'> = {\n      type: 'spawn.args',\n      action(args, context) {\n         if (!progressMethods.includes(context.method)) {\n            return args;\n         }\n\n         return including(args, progressCommand);\n      },\n   };\n\n   return [onArgs, onProgress];\n}\n\nfunction progressEventStage(input: string) {\n   return String(input.toLowerCase().split(' ', 1)) || 'unknown';\n}\n", "import { SpawnOptions } from 'child_process';\nimport { pick } from '../utils';\nimport { SimpleGitPlugin } from './simple-git-plugin';\n\nexport function spawnOptionsPlugin(\n   spawnOptions: Partial<SpawnOptions>\n): SimpleGitPlugin<'spawn.options'> {\n   const options = pick(spawnOptions, ['uid', 'gid']);\n\n   return {\n      type: 'spawn.options',\n      action(data) {\n         return { ...options, ...data };\n      },\n   };\n}\n", "import type { SimpleGitPlugin } from './simple-git-plugin';\n\nimport type { SimpleGitOptions } from '../types';\nimport { GitPluginError } from '../errors/git-plugin-error';\n\nexport function timeoutPlugin({\n   block,\n   stdErr = true,\n   stdOut = true,\n}: Exclude<SimpleGitOptions['timeout'], undefined>): SimpleGitPlugin<'spawn.after'> | void {\n   if (block > 0) {\n      return {\n         type: 'spawn.after',\n         action(_data, context) {\n            let timeout: NodeJS.Timeout;\n\n            function wait() {\n               timeout && clearTimeout(timeout);\n               timeout = setTimeout(kill, block);\n            }\n\n            function stop() {\n               context.spawned.stdout?.off('data', wait);\n               context.spawned.stderr?.off('data', wait);\n               context.spawned.off('exit', stop);\n               context.spawned.off('close', stop);\n               timeout && clearTimeout(timeout);\n            }\n\n            function kill() {\n               stop();\n               context.kill(new GitPluginError(undefined, 'timeout', `block timeout reached`));\n            }\n\n            stdOut && context.spawned.stdout?.on('data', wait);\n            stdErr && context.spawned.stderr?.on('data', wait);\n            context.spawned.on('exit', stop);\n            context.spawned.on('close', stop);\n\n            wait();\n         },\n      };\n   }\n}\n", "import { SimpleGitPlugin } from './simple-git-plugin';\nimport { isPathSpec, toPaths } from '../args/pathspec';\n\nexport function suffixPathsPlugin(): SimpleGitPlugin<'spawn.args'> {\n   return {\n      type: 'spawn.args',\n      action(data) {\n         const prefix: string[] = [];\n         let suffix: undefined | string[];\n         function append(args: string[]) {\n            (suffix = suffix || []).push(...args);\n         }\n\n         for (let i = 0; i < data.length; i++) {\n            const param = data[i];\n\n            if (isPathSpec(param)) {\n               append(toPaths(param));\n               continue;\n            }\n\n            if (param === '--') {\n               append(\n                  data.slice(i + 1).flatMap((item) => (isPathSpec(item) && toPaths(item)) || item)\n               );\n               break;\n            }\n\n            prefix.push(param);\n         }\n\n         return !suffix ? prefix : [...prefix, '--', ...suffix.map(String)];\n      },\n   };\n}\n", "import { SimpleGitFactory } from '../../typings';\n\nimport * as api from './api';\nimport {\n   abortPlugin,\n   blockUnsafeOperationsPlugin,\n   commandConfigPrefixingPlugin,\n   completionDetectionPlugin,\n   errorDetectionHandler,\n   errorDetectionPlugin,\n   PluginStore,\n   progressMonitorPlugin,\n   spawnOptionsPlugin,\n   timeoutPlugin,\n} from './plugins';\nimport { suffixPathsPlugin } from './plugins/suffix-paths.plugin';\nimport { createInstanceConfig, folderExists } from './utils';\nimport { SimpleGitOptions } from './types';\n\nconst Git = require('../git');\n\n/**\n * Adds the necessary properties to the supplied object to enable it for use as\n * the default export of a module.\n *\n * Eg: `module.exports = esModuleFactory({ something () {} })`\n */\nexport function esModuleFactory<T>(defaultExport: T) {\n   return Object.defineProperties(defaultExport, {\n      __esModule: { value: true },\n      default: { value: defaultExport },\n   }) as T & { __esModule: true; default: T };\n}\n\nexport function gitExportFactory(factory: SimpleGitFactory) {\n   return Object.assign(factory.bind(null), api);\n}\n\nexport function gitInstanceFactory(\n   baseDir?: string | Partial<SimpleGitOptions>,\n   options?: Partial<SimpleGitOptions>\n) {\n   const plugins = new PluginStore();\n   const config = createInstanceConfig(\n      (baseDir && (typeof baseDir === 'string' ? { baseDir } : baseDir)) || {},\n      options\n   );\n\n   if (!folderExists(config.baseDir)) {\n      throw new api.GitConstructError(\n         config,\n         `Cannot use simple-git on a directory that does not exist`\n      );\n   }\n\n   if (Array.isArray(config.config)) {\n      plugins.add(commandConfigPrefixingPlugin(config.config));\n   }\n\n   plugins.add(blockUnsafeOperationsPlugin(config.unsafe));\n   plugins.add(suffixPathsPlugin());\n   plugins.add(completionDetectionPlugin(config.completion));\n   config.abort && plugins.add(abortPlugin(config.abort));\n   config.progress && plugins.add(progressMonitorPlugin(config.progress));\n   config.timeout && plugins.add(timeoutPlugin(config.timeout));\n   config.spawnOptions && plugins.add(spawnOptionsPlugin(config.spawnOptions));\n\n   plugins.add(errorDetectionPlugin(errorDetectionHandler(true)));\n   config.errors && plugins.add(errorDetectionPlugin(config.errors));\n\n   return new Git(config, plugins);\n}\n", "import { SimpleGit, SimpleGitOptions } from '../../../typings';\n\nimport { GitResponseError } from '../errors/git-response-error';\nimport { gitInstanceFactory } from '../git-factory';\nimport { SimpleGitTaskCallback } from '../types';\n\nconst functionNamesBuilderApi = ['customBinary', 'env', 'outputHandler', 'silent'];\n\nconst functionNamesPromiseApi = [\n   'add',\n   'addAnnotatedTag',\n   'addConfig',\n   'addRemote',\n   'addTag',\n   'applyPatch',\n   'binaryCatFile',\n   'branch',\n   'branchLocal',\n   'catFile',\n   'checkIgnore',\n   'checkIsRepo',\n   'checkout',\n   'checkoutBranch',\n   'checkoutLatestTag',\n   'checkoutLocalBranch',\n   'clean',\n   'clone',\n   'commit',\n   'cwd',\n   'deleteLocalBranch',\n   'deleteLocalBranches',\n   'diff',\n   'diffSummary',\n   'exec',\n   'fetch',\n   'getRemotes',\n   'init',\n   'listConfig',\n   'listRemote',\n   'log',\n   'merge',\n   'mergeFromTo',\n   'mirror',\n   'mv',\n   'pull',\n   'push',\n   'pushTags',\n   'raw',\n   'rebase',\n   'remote',\n   'removeRemote',\n   'reset',\n   'revert',\n   'revparse',\n   'rm',\n   'rmKeepLocal',\n   'show',\n   'stash',\n   'stashList',\n   'status',\n   'subModule',\n   'submoduleAdd',\n   'submoduleInit',\n   'submoduleUpdate',\n   'tag',\n   'tags',\n   'updateServerInfo',\n];\n\nexport function gitP(\n   ...args: [] | [string] | [Partial<SimpleGitOptions>] | [string, Partial<SimpleGitOptions>]\n): SimpleGit {\n   let git: any;\n\n   let chain = Promise.resolve();\n\n   try {\n      git = gitInstanceFactory(...args);\n   } catch (e) {\n      chain = Promise.reject(e);\n   }\n\n   function builderReturn() {\n      return promiseApi;\n   }\n\n   function chainReturn() {\n      return chain;\n   }\n\n   const promiseApi = [...functionNamesBuilderApi, ...functionNamesPromiseApi].reduce(\n      (api: any, name: string) => {\n         const isAsync = functionNamesPromiseApi.includes(name);\n\n         const valid = isAsync ? asyncWrapper(name, git) : syncWrapper(name, git, api);\n         const alternative = isAsync ? chainReturn : builderReturn;\n\n         Object.defineProperty(api, name, {\n            enumerable: false,\n            configurable: false,\n            value: git ? valid : alternative,\n         });\n\n         return api;\n      },\n      {}\n   );\n\n   return promiseApi as SimpleGit;\n\n   function asyncWrapper(fn: string, git: any): (...args: any[]) => Promise<any> {\n      return function (...args: any[]) {\n         if (typeof args[args.length] === 'function') {\n            throw new TypeError(\n               'Promise interface requires that handlers are not supplied inline, ' +\n                  'trailing function not allowed in call to ' +\n                  fn\n            );\n         }\n\n         return chain.then(function () {\n            return new Promise(function (resolve, reject) {\n               const callback: SimpleGitTaskCallback = (err: Error | null, result?: any) => {\n                  if (err) {\n                     return reject(toError(err));\n                  }\n\n                  resolve(result);\n               };\n               args.push(callback);\n\n               git[fn].apply(git, args);\n            });\n         });\n      };\n   }\n\n   function syncWrapper(fn: string, git: any, api: SimpleGit) {\n      return (...args: any[]) => {\n         git[fn](...args);\n\n         return api;\n      };\n   }\n}\n\nfunction toError(error: Error | string | any): Error {\n   if (error instanceof Error) {\n      return error;\n   }\n\n   if (typeof error === 'string') {\n      return new Error(error);\n   }\n\n   return new GitResponseError(error);\n}\n", "import { gitInstanceFactory } from './lib/git-factory';\n\nexport { gitP } from './lib/runners/promise-wrapped';\nexport * from './lib/api';\n\nexport const simpleGit = gitInstanceFactory;\n\nexport default gitInstanceFactory;\n", "import { GitService } from \"@/services/gitService\";\r\nimport logger from \"@/utils/logger\";\r\n\r\nimport { resolve } from \"path\";\r\n\r\nconst GITIGNORE_FILE_NAME = \".gitignore\";\r\n\r\nexport class GitignoreService {\r\n\tprivate gitignorePath: string;\r\n\r\n\tconstructor(basePath: string, private gitService: GitService) {\r\n\t\tlogger.debug(\"Initializing GitignoreService...\");\r\n\t\tthis.gitignorePath = resolve(basePath, GITIGNORE_FILE_NAME);\r\n\t\tlogger.debug(\"GitignoreService initialized.\");\r\n\t}\r\n\r\n\tprivate async stageCommitAndPushGitignore(message: string) {\r\n\t\tawait this.gitService.gitStage(GITIGNORE_FILE_NAME);\r\n\t\tawait this.gitService.gitCommit(message);\r\n\t\tawait this.gitService.gitPush();\r\n\t}\r\n}\r\n", "import { GitService } from \"@/services/gitService\";\r\n\r\nimport { App, Modal } from \"obsidian\";\r\n\r\nexport default class UnmergedFilesView extends Modal {\r\n\tconstructor(app: App, private gitService?: GitService) {\r\n\t\tsuper(app);\r\n\t}\r\n\r\n\tonOpen(): void {\r\n\t\tthis.contentEl.empty();\r\n\r\n\t\tthis.contentEl.createEl(\"h3\", {\r\n\t\t\ttext: \"Loading...\",\r\n\t\t\tcls: \"sync-title\",\r\n\t\t});\r\n\r\n\t\tthis.gitService?.getConflictingFiles().then((files) => {\r\n\t\t\tthis.contentEl.empty();\r\n\r\n\t\t\tif (files.length > 0) {\r\n\t\t\t\tthis.contentEl.createEl(\"h3\", {\r\n\t\t\t\t\ttext: \"Please resolve the conflicts in the following files:\",\r\n\t\t\t\t\tcls: \"sync-title\",\r\n\t\t\t\t});\r\n\r\n\t\t\t\tconst list = this.contentEl.createEl(\"ul\");\r\n\r\n\t\t\t\tfiles.forEach((file) =>\r\n\t\t\t\t\tlist\r\n\t\t\t\t\t\t.createEl(\"li\")\r\n\t\t\t\t\t\t.createEl(\"strong\", {\r\n\t\t\t\t\t\t\ttext: file,\r\n\t\t\t\t\t\t\tcls: \"sync-conflicting-files\",\r\n\t\t\t\t\t\t})\r\n\t\t\t\t);\r\n\t\t\t} else {\r\n\t\t\t\tthis.contentEl.createEl(\"h3\", {\r\n\t\t\t\t\ttext: \"No unmerged files to show!\",\r\n\t\t\t\t\tcls: \"sync-title\",\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tonClose(): void {\r\n\t\tthis.contentEl.empty();\r\n\t}\r\n}\r\n", "import CicadaPlugin from \"@/main\";\r\n\r\nimport { App, PluginSettingTab, Setting } from \"obsidian\";\r\n\r\nimport os from \"os\";\r\nimport simpleGit, { SimpleGit } from \"simple-git\";\r\n\r\nconst GITHUB_ISSUE_LINK =\r\n\t\"https://github.com/adapole/cicada-sync/issues/new/choose\";\r\nconst SAMPLE_REPO = \"git@github.com:adapole/obsidian-yaos.git\";\r\n\r\nexport interface YaosSettings {\r\n\tdeviceName: string;\r\n\tremoteRepo: string;\r\n\tbasePath: string;\r\n\tbranchName: string;\r\n\tsyncImages: boolean;\r\n\tsyncAudio: boolean;\r\n\tsyncVideos: boolean;\r\n\tsyncPdfs: boolean;\r\n\tsyncOtherFiles: boolean;\r\n\tsyncMainSettings: boolean;\r\n\tsyncAppearanceSettings: boolean;\r\n\tsyncThemesAndSnippets: boolean;\r\n\tsyncHotkeys: boolean;\r\n\tsyncCorePluginSettings: boolean;\r\n\tsyncCommunityPluginSettings: boolean;\r\n}\r\n\r\nexport const DEFAULT_YAOS_SETTINGS: YaosSettings = {\r\n\tdeviceName: os.hostname(),\r\n\tremoteRepo: SAMPLE_REPO,\r\n\tbasePath: __dirname,\r\n\tbranchName: \"main\",\r\n\tsyncImages: false,\r\n\tsyncAudio: false,\r\n\tsyncVideos: false,\r\n\tsyncPdfs: false,\r\n\tsyncOtherFiles: false,\r\n\tsyncMainSettings: false,\r\n\tsyncAppearanceSettings: false,\r\n\tsyncThemesAndSnippets: false,\r\n\tsyncHotkeys: false,\r\n\tsyncCorePluginSettings: false,\r\n\tsyncCommunityPluginSettings: false,\r\n};\r\n\r\nexport default class YaosSettingTab extends PluginSettingTab {\r\n\tplugin: CicadaPlugin;\r\n\tprivate gitProvider: SimpleGit;\r\n\r\n\tconstructor(app: App, plugin: CicadaPlugin) {\r\n\t\tsuper(app, plugin);\r\n\t\tthis.plugin = plugin;\r\n\t\tthis.gitProvider = simpleGit();\r\n\t}\r\n\r\n\tdisplay() {\r\n\t\tconst { containerEl } = this;\r\n\r\n\t\tcontainerEl.empty();\r\n\r\n\t\tthis.addGeneralSection(containerEl);\r\n\t\tthis.addGitSetup(containerEl);\r\n\t}\r\n\r\n\tprivate addGeneralSection(containerEl: HTMLElement) {\r\n\t\tnew Setting(containerEl).setName(\"General\").setHeading();\r\n\t\tthis.addDeviceNameSetting(containerEl);\r\n\t\tthis.addCreateIssueSetting(containerEl);\r\n\t}\r\n\r\n\tprivate addGitSetup(containerEl: HTMLElement) {\r\n\t\tnew Setting(containerEl).setName(\"Setup Git\").setHeading();\r\n\t\tthis.addBranchName(containerEl);\r\n\t\tthis.addRemoteRepoURL(containerEl);\r\n\t}\r\n\r\n\tprivate addDeviceNameSetting(el: HTMLElement) {\r\n\t\tnew Setting(el)\r\n\t\t\t.setName(\"Device name\")\r\n\t\t\t.setDesc(\r\n\t\t\t\t\"This name will be displayed in the commit messages to indicate the sync source. Leave empty to use the default name.\"\r\n\t\t\t)\r\n\t\t\t.addText((text) =>\r\n\t\t\t\ttext\r\n\t\t\t\t\t.setPlaceholder(DEFAULT_YAOS_SETTINGS.deviceName)\r\n\t\t\t\t\t.setValue(this.plugin.settings.deviceName)\r\n\t\t\t\t\t.onChange(async (deviceName) => {\r\n\t\t\t\t\t\tthis.plugin.settings.deviceName = deviceName;\r\n\t\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t\t})\r\n\t\t\t);\r\n\t}\r\n\r\n\tprivate addCreateIssueSetting(el: HTMLElement) {\r\n\t\tnew Setting(el)\r\n\t\t\t.setName(\"Contact support\")\r\n\t\t\t.setDesc(\r\n\t\t\t\t\"If you run into any issues working with this plugin, please let us know by creating an issue on our GitHub page.\"\r\n\t\t\t)\r\n\t\t\t.addButton((button) =>\r\n\t\t\t\tbutton\r\n\t\t\t\t\t.setButtonText(\"Create issue\")\r\n\t\t\t\t\t.setTooltip(\"Create an issue on GitHub\")\r\n\t\t\t\t\t.setCta()\r\n\t\t\t\t\t.onClick(() =>\r\n\t\t\t\t\t\tself.open(GITHUB_ISSUE_LINK, \"_blank\", \"norefferrer\")\r\n\t\t\t\t\t)\r\n\t\t\t);\r\n\t}\r\n\r\n\tprivate addRemoteRepoURL(el: HTMLElement) {\r\n\t\tnew Setting(el)\r\n\t\t\t.setName(\"Import repository\")\r\n\t\t\t.setDesc(\r\n\t\t\t\t\"If you want to import a vault from a remote repository, add the URL and Import to the directory you want.\"\r\n\t\t\t)\r\n\t\t\t.addText((text) =>\r\n\t\t\t\ttext\r\n\t\t\t\t\t.setPlaceholder(SAMPLE_REPO)\r\n\t\t\t\t\t.setValue(this.plugin.settings.remoteRepo)\r\n\t\t\t\t\t.onChange(async (remoteRepo) => {\r\n\t\t\t\t\t\tthis.plugin.settings.remoteRepo = remoteRepo;\r\n\t\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t\t})\r\n\t\t\t);\r\n\t\tnew Setting(el)\r\n\t\t\t.setDesc(\"The local vault directory to link the remote repository.\")\r\n\t\t\t.addText((text) =>\r\n\t\t\t\ttext\r\n\t\t\t\t\t.setPlaceholder(\"C:/Users/\")\r\n\t\t\t\t\t.setValue(this.plugin.settings.basePath)\r\n\t\t\t\t\t.onChange(async (basePath) => {\r\n\t\t\t\t\t\tthis.plugin.settings.basePath = basePath;\r\n\t\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t\t})\r\n\t\t\t);\r\n\r\n\t\tnew Setting(el).addButton((button) =>\r\n\t\t\tbutton\r\n\t\t\t\t.setButtonText(\"Import\")\r\n\t\t\t\t.setTooltip(\"Import a remote repository\")\r\n\t\t\t\t.setCta()\r\n\t\t\t\t.onClick(async () => {\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tconst remoteRepo = `${this.plugin.settings.remoteRepo}`;\r\n\t\t\t\t\t\tawait this.gitProvider\r\n\t\t\t\t\t\t\t.clone(\r\n\t\t\t\t\t\t\t\tremoteRepo,\r\n\t\t\t\t\t\t\t\t`${this.plugin.settings.basePath}`\r\n\t\t\t\t\t\t\t)\r\n\t\t\t\t\t\t\t.fetch();\r\n\t\t\t\t\t} catch (error) {\r\n\t\t\t\t\t\tconsole.error(error);\r\n\t\t\t\t\t}\r\n\t\t\t\t})\r\n\t\t);\r\n\t}\r\n\r\n\tprivate addBranchName(el: HTMLElement) {\r\n\t\tnew Setting(el)\r\n\t\t\t.setName(\"Select branch\")\r\n\t\t\t.setDesc(\"Set the working branch.\")\r\n\t\t\t.addText((text) =>\r\n\t\t\t\ttext\r\n\t\t\t\t\t.setPlaceholder(\"main\")\r\n\t\t\t\t\t.setValue(this.plugin.settings.branchName)\r\n\t\t\t\t\t.onChange(async (branchName) => {\r\n\t\t\t\t\t\tthis.plugin.settings.branchName = branchName;\r\n\t\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t\t})\r\n\t\t\t);\r\n\t\tnew Setting(el).addButton((button) =>\r\n\t\t\tbutton\r\n\t\t\t\t.setButtonText(\"Switch\")\r\n\t\t\t\t.setTooltip(\"Switch to this branch\")\r\n\t\t\t\t.setCta()\r\n\t\t\t\t.onClick(async () => {\r\n\t\t\t\t\tlet git = simpleGit(this.plugin.settings.basePath);\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tawait git.checkoutBranch(\r\n\t\t\t\t\t\t\t`${this.plugin.settings.branchName}`,\r\n\t\t\t\t\t\t\t\"HEAD\"\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t} catch (error) {\r\n\t\t\t\t\t\tawait git.checkout(\r\n\t\t\t\t\t\t\t`${this.plugin.settings.branchName}`\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t}\r\n\t\t\t\t})\r\n\t\t);\r\n\t}\r\n}\r\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA,6CAAAA,SAAA;AAAA,KAAC,SAAS,GAAE,GAAE;AAAC,kBAAU,OAAO,WAAS,eAAa,OAAOA,UAAOA,QAAO,UAAQ,EAAE,IAAE,cAAY,OAAO,UAAQ,OAAO,MAAI,OAAO,CAAC,KAAG,IAAE,eAAa,OAAO,aAAW,aAAW,KAAG,MAAM,QAAM,EAAE;AAAA,IAAC,EAAE,SAAM,WAAU;AAAC;AAAa,UAAI,IAAE,KAAI,IAAE,KAAI,IAAE,MAAK,IAAE,eAAc,IAAE,UAAS,IAAE,UAAS,IAAE,QAAO,IAAE,OAAM,IAAE,QAAO,IAAE,SAAQ,IAAE,WAAU,IAAE,QAAO,IAAE,QAAO,IAAE,gBAAe,IAAE,8FAA6F,IAAE,uFAAsF,IAAE,EAAC,MAAK,MAAK,UAAS,2DAA2D,MAAM,GAAG,GAAE,QAAO,wFAAwF,MAAM,GAAG,GAAE,SAAQ,SAASC,IAAE;AAAC,YAAIC,KAAE,CAAC,MAAK,MAAK,MAAK,IAAI,GAAEC,KAAEF,KAAE;AAAI,eAAM,MAAIA,MAAGC,IAAGC,KAAE,MAAI,EAAE,KAAGD,GAAEC,EAAC,KAAGD,GAAE,CAAC,KAAG;AAAA,MAAG,EAAC,GAAE,IAAE,SAASD,IAAEC,IAAEC,IAAE;AAAC,YAAIC,KAAE,OAAOH,EAAC;AAAE,eAAM,CAACG,MAAGA,GAAE,UAAQF,KAAED,KAAE,KAAG,MAAMC,KAAE,IAAEE,GAAE,MAAM,EAAE,KAAKD,EAAC,IAAEF;AAAA,MAAC,GAAE,IAAE,EAAC,GAAE,GAAE,GAAE,SAASA,IAAE;AAAC,YAAIC,KAAE,CAACD,GAAE,UAAU,GAAEE,KAAE,KAAK,IAAID,EAAC,GAAEE,KAAE,KAAK,MAAMD,KAAE,EAAE,GAAEE,KAAEF,KAAE;AAAG,gBAAOD,MAAG,IAAE,MAAI,OAAK,EAAEE,IAAE,GAAE,GAAG,IAAE,MAAI,EAAEC,IAAE,GAAE,GAAG;AAAA,MAAC,GAAE,GAAE,SAASJ,GAAEC,IAAEC,IAAE;AAAC,YAAGD,GAAE,KAAK,IAAEC,GAAE,KAAK;AAAE,iBAAM,CAACF,GAAEE,IAAED,EAAC;AAAE,YAAIE,KAAE,MAAID,GAAE,KAAK,IAAED,GAAE,KAAK,MAAIC,GAAE,MAAM,IAAED,GAAE,MAAM,IAAGG,KAAEH,GAAE,MAAM,EAAE,IAAIE,IAAE,CAAC,GAAEE,KAAEH,KAAEE,KAAE,GAAEE,KAAEL,GAAE,MAAM,EAAE,IAAIE,MAAGE,KAAE,KAAG,IAAG,CAAC;AAAE,eAAM,EAAE,EAAEF,MAAGD,KAAEE,OAAIC,KAAED,KAAEE,KAAEA,KAAEF,QAAK;AAAA,MAAE,GAAE,GAAE,SAASJ,IAAE;AAAC,eAAOA,KAAE,IAAE,KAAK,KAAKA,EAAC,KAAG,IAAE,KAAK,MAAMA,EAAC;AAAA,MAAC,GAAE,GAAE,SAASA,IAAE;AAAC,eAAM,EAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,IAAG,GAAE,GAAE,EAAC,EAAEA,EAAC,KAAG,OAAOA,MAAG,EAAE,EAAE,YAAY,EAAE,QAAQ,MAAK,EAAE;AAAA,MAAC,GAAE,GAAE,SAASA,IAAE;AAAC,eAAO,WAASA;AAAA,MAAC,EAAC,GAAE,IAAE,MAAK,IAAE,CAAC;AAAE,QAAE,CAAC,IAAE;AAAE,UAAI,IAAE,kBAAiB,IAAE,SAASA,IAAE;AAAC,eAAOA,cAAa,KAAG,EAAE,CAACA,MAAG,CAACA,GAAE,CAAC;AAAA,MAAE,GAAE,IAAE,SAASA,GAAEC,IAAEC,IAAEC,IAAE;AAAC,YAAIC;AAAE,YAAG,CAACH;AAAE,iBAAO;AAAE,YAAG,YAAU,OAAOA,IAAE;AAAC,cAAII,KAAEJ,GAAE,YAAY;AAAE,YAAEI,EAAC,MAAID,KAAEC,KAAGH,OAAI,EAAEG,EAAC,IAAEH,IAAEE,KAAEC;AAAG,cAAIC,KAAEL,GAAE,MAAM,GAAG;AAAE,cAAG,CAACG,MAAGE,GAAE,SAAO;AAAE,mBAAON,GAAEM,GAAE,CAAC,CAAC;AAAA,QAAC,OAAK;AAAC,cAAIC,KAAEN,GAAE;AAAK,YAAEM,EAAC,IAAEN,IAAEG,KAAEG;AAAA,QAAC;AAAC,eAAM,CAACJ,MAAGC,OAAI,IAAEA,KAAGA,MAAG,CAACD,MAAG;AAAA,MAAC,GAAE,IAAE,SAASH,IAAEC,IAAE;AAAC,YAAG,EAAED,EAAC;AAAE,iBAAOA,GAAE,MAAM;AAAE,YAAIE,KAAE,YAAU,OAAOD,KAAEA,KAAE,CAAC;AAAE,eAAOC,GAAE,OAAKF,IAAEE,GAAE,OAAK,WAAU,IAAI,EAAEA,EAAC;AAAA,MAAC,GAAE,IAAE;AAAE,QAAE,IAAE,GAAE,EAAE,IAAE,GAAE,EAAE,IAAE,SAASF,IAAEC,IAAE;AAAC,eAAO,EAAED,IAAE,EAAC,QAAOC,GAAE,IAAG,KAAIA,GAAE,IAAG,GAAEA,GAAE,IAAG,SAAQA,GAAE,QAAO,CAAC;AAAA,MAAC;AAAE,UAAI,IAAE,WAAU;AAAC,iBAASO,GAAER,IAAE;AAAC,eAAK,KAAG,EAAEA,GAAE,QAAO,MAAK,IAAE,GAAE,KAAK,MAAMA,EAAC,GAAE,KAAK,KAAG,KAAK,MAAIA,GAAE,KAAG,CAAC,GAAE,KAAK,CAAC,IAAE;AAAA,QAAE;AAAC,YAAIS,KAAED,GAAE;AAAU,eAAOC,GAAE,QAAM,SAAST,IAAE;AAAC,eAAK,KAAG,SAASA,IAAE;AAAC,gBAAIC,KAAED,GAAE,MAAKE,KAAEF,GAAE;AAAI,gBAAG,SAAOC;AAAE,qBAAO,IAAI,KAAK,GAAG;AAAE,gBAAG,EAAE,EAAEA,EAAC;AAAE,qBAAO,IAAI;AAAK,gBAAGA,cAAa;AAAK,qBAAO,IAAI,KAAKA,EAAC;AAAE,gBAAG,YAAU,OAAOA,MAAG,CAAC,MAAM,KAAKA,EAAC,GAAE;AAAC,kBAAIE,KAAEF,GAAE,MAAM,CAAC;AAAE,kBAAGE,IAAE;AAAC,oBAAIC,KAAED,GAAE,CAAC,IAAE,KAAG,GAAEE,MAAGF,GAAE,CAAC,KAAG,KAAK,UAAU,GAAE,CAAC;AAAE,uBAAOD,KAAE,IAAI,KAAK,KAAK,IAAIC,GAAE,CAAC,GAAEC,IAAED,GAAE,CAAC,KAAG,GAAEA,GAAE,CAAC,KAAG,GAAEA,GAAE,CAAC,KAAG,GAAEA,GAAE,CAAC,KAAG,GAAEE,EAAC,CAAC,IAAE,IAAI,KAAKF,GAAE,CAAC,GAAEC,IAAED,GAAE,CAAC,KAAG,GAAEA,GAAE,CAAC,KAAG,GAAEA,GAAE,CAAC,KAAG,GAAEA,GAAE,CAAC,KAAG,GAAEE,EAAC;AAAA,cAAC;AAAA,YAAC;AAAC,mBAAO,IAAI,KAAKJ,EAAC;AAAA,UAAC,EAAED,EAAC,GAAE,KAAK,KAAK;AAAA,QAAC,GAAES,GAAE,OAAK,WAAU;AAAC,cAAIT,KAAE,KAAK;AAAG,eAAK,KAAGA,GAAE,YAAY,GAAE,KAAK,KAAGA,GAAE,SAAS,GAAE,KAAK,KAAGA,GAAE,QAAQ,GAAE,KAAK,KAAGA,GAAE,OAAO,GAAE,KAAK,KAAGA,GAAE,SAAS,GAAE,KAAK,KAAGA,GAAE,WAAW,GAAE,KAAK,KAAGA,GAAE,WAAW,GAAE,KAAK,MAAIA,GAAE,gBAAgB;AAAA,QAAC,GAAES,GAAE,SAAO,WAAU;AAAC,iBAAO;AAAA,QAAC,GAAEA,GAAE,UAAQ,WAAU;AAAC,iBAAM,EAAE,KAAK,GAAG,SAAS,MAAI;AAAA,QAAE,GAAEA,GAAE,SAAO,SAAST,IAAEC,IAAE;AAAC,cAAIC,KAAE,EAAEF,EAAC;AAAE,iBAAO,KAAK,QAAQC,EAAC,KAAGC,MAAGA,MAAG,KAAK,MAAMD,EAAC;AAAA,QAAC,GAAEQ,GAAE,UAAQ,SAAST,IAAEC,IAAE;AAAC,iBAAO,EAAED,EAAC,IAAE,KAAK,QAAQC,EAAC;AAAA,QAAC,GAAEQ,GAAE,WAAS,SAAST,IAAEC,IAAE;AAAC,iBAAO,KAAK,MAAMA,EAAC,IAAE,EAAED,EAAC;AAAA,QAAC,GAAES,GAAE,KAAG,SAAST,IAAEC,IAAEC,IAAE;AAAC,iBAAO,EAAE,EAAEF,EAAC,IAAE,KAAKC,EAAC,IAAE,KAAK,IAAIC,IAAEF,EAAC;AAAA,QAAC,GAAES,GAAE,OAAK,WAAU;AAAC,iBAAO,KAAK,MAAM,KAAK,QAAQ,IAAE,GAAG;AAAA,QAAC,GAAEA,GAAE,UAAQ,WAAU;AAAC,iBAAO,KAAK,GAAG,QAAQ;AAAA,QAAC,GAAEA,GAAE,UAAQ,SAAST,IAAEC,IAAE;AAAC,cAAIC,KAAE,MAAKC,KAAE,CAAC,CAAC,EAAE,EAAEF,EAAC,KAAGA,IAAES,KAAE,EAAE,EAAEV,EAAC,GAAEW,KAAE,SAASX,IAAEC,IAAE;AAAC,gBAAIG,KAAE,EAAE,EAAEF,GAAE,KAAG,KAAK,IAAIA,GAAE,IAAGD,IAAED,EAAC,IAAE,IAAI,KAAKE,GAAE,IAAGD,IAAED,EAAC,GAAEE,EAAC;AAAE,mBAAOC,KAAEC,KAAEA,GAAE,MAAM,CAAC;AAAA,UAAC,GAAEQ,KAAE,SAASZ,IAAEC,IAAE;AAAC,mBAAO,EAAE,EAAEC,GAAE,OAAO,EAAEF,EAAC,EAAE,MAAME,GAAE,OAAO,GAAG,IAAGC,KAAE,CAAC,GAAE,GAAE,GAAE,CAAC,IAAE,CAAC,IAAG,IAAG,IAAG,GAAG,GAAG,MAAMF,EAAC,CAAC,GAAEC,EAAC;AAAA,UAAC,GAAEW,KAAE,KAAK,IAAGL,KAAE,KAAK,IAAGC,KAAE,KAAK,IAAGK,KAAE,SAAO,KAAK,KAAG,QAAM;AAAI,kBAAOJ,IAAE;AAAA,YAAC,KAAK;AAAE,qBAAOP,KAAEQ,GAAE,GAAE,CAAC,IAAEA,GAAE,IAAG,EAAE;AAAA,YAAE,KAAK;AAAE,qBAAOR,KAAEQ,GAAE,GAAEH,EAAC,IAAEG,GAAE,GAAEH,KAAE,CAAC;AAAA,YAAE,KAAK;AAAE,kBAAIO,KAAE,KAAK,QAAQ,EAAE,aAAW,GAAEC,MAAGH,KAAEE,KAAEF,KAAE,IAAEA,MAAGE;AAAE,qBAAOJ,GAAER,KAAEM,KAAEO,KAAEP,MAAG,IAAEO,KAAGR,EAAC;AAAA,YAAE,KAAK;AAAA,YAAE,KAAK;AAAE,qBAAOI,GAAEE,KAAE,SAAQ,CAAC;AAAA,YAAE,KAAK;AAAE,qBAAOF,GAAEE,KAAE,WAAU,CAAC;AAAA,YAAE,KAAK;AAAE,qBAAOF,GAAEE,KAAE,WAAU,CAAC;AAAA,YAAE,KAAK;AAAE,qBAAOF,GAAEE,KAAE,gBAAe,CAAC;AAAA,YAAE;AAAQ,qBAAO,KAAK,MAAM;AAAA,UAAC;AAAA,QAAC,GAAEL,GAAE,QAAM,SAAST,IAAE;AAAC,iBAAO,KAAK,QAAQA,IAAE,KAAE;AAAA,QAAC,GAAES,GAAE,OAAK,SAAST,IAAEC,IAAE;AAAC,cAAIC,IAAEe,KAAE,EAAE,EAAEjB,EAAC,GAAEU,KAAE,SAAO,KAAK,KAAG,QAAM,KAAIC,MAAGT,KAAE,CAAC,GAAEA,GAAE,CAAC,IAAEQ,KAAE,QAAOR,GAAE,CAAC,IAAEQ,KAAE,QAAOR,GAAE,CAAC,IAAEQ,KAAE,SAAQR,GAAE,CAAC,IAAEQ,KAAE,YAAWR,GAAE,CAAC,IAAEQ,KAAE,SAAQR,GAAE,CAAC,IAAEQ,KAAE,WAAUR,GAAE,CAAC,IAAEQ,KAAE,WAAUR,GAAE,CAAC,IAAEQ,KAAE,gBAAeR,IAAGe,EAAC,GAAEL,KAAEK,OAAI,IAAE,KAAK,MAAIhB,KAAE,KAAK,MAAIA;AAAE,cAAGgB,OAAI,KAAGA,OAAI,GAAE;AAAC,gBAAIJ,KAAE,KAAK,MAAM,EAAE,IAAI,GAAE,CAAC;AAAE,YAAAA,GAAE,GAAGF,EAAC,EAAEC,EAAC,GAAEC,GAAE,KAAK,GAAE,KAAK,KAAGA,GAAE,IAAI,GAAE,KAAK,IAAI,KAAK,IAAGA,GAAE,YAAY,CAAC,CAAC,EAAE;AAAA,UAAE;AAAM,YAAAF,MAAG,KAAK,GAAGA,EAAC,EAAEC,EAAC;AAAE,iBAAO,KAAK,KAAK,GAAE;AAAA,QAAI,GAAEH,GAAE,MAAI,SAAST,IAAEC,IAAE;AAAC,iBAAO,KAAK,MAAM,EAAE,KAAKD,IAAEC,EAAC;AAAA,QAAC,GAAEQ,GAAE,MAAI,SAAST,IAAE;AAAC,iBAAO,KAAK,EAAE,EAAEA,EAAC,CAAC,EAAE;AAAA,QAAC,GAAES,GAAE,MAAI,SAASN,IAAEO,IAAE;AAAC,cAAIQ,IAAEP,KAAE;AAAK,UAAAR,KAAE,OAAOA,EAAC;AAAE,cAAIS,KAAE,EAAE,EAAEF,EAAC,GAAEG,KAAE,SAASb,IAAE;AAAC,gBAAIC,KAAE,EAAEU,EAAC;AAAE,mBAAO,EAAE,EAAEV,GAAE,KAAKA,GAAE,KAAK,IAAE,KAAK,MAAMD,KAAEG,EAAC,CAAC,GAAEQ,EAAC;AAAA,UAAC;AAAE,cAAGC,OAAI;AAAE,mBAAO,KAAK,IAAI,GAAE,KAAK,KAAGT,EAAC;AAAE,cAAGS,OAAI;AAAE,mBAAO,KAAK,IAAI,GAAE,KAAK,KAAGT,EAAC;AAAE,cAAGS,OAAI;AAAE,mBAAOC,GAAE,CAAC;AAAE,cAAGD,OAAI;AAAE,mBAAOC,GAAE,CAAC;AAAE,cAAIL,MAAGU,KAAE,CAAC,GAAEA,GAAE,CAAC,IAAE,GAAEA,GAAE,CAAC,IAAE,GAAEA,GAAE,CAAC,IAAE,GAAEA,IAAGN,EAAC,KAAG,GAAEH,KAAE,KAAK,GAAG,QAAQ,IAAEN,KAAEK;AAAE,iBAAO,EAAE,EAAEC,IAAE,IAAI;AAAA,QAAC,GAAEA,GAAE,WAAS,SAAST,IAAEC,IAAE;AAAC,iBAAO,KAAK,IAAI,KAAGD,IAAEC,EAAC;AAAA,QAAC,GAAEQ,GAAE,SAAO,SAAST,IAAE;AAAC,cAAIC,KAAE,MAAKC,KAAE,KAAK,QAAQ;AAAE,cAAG,CAAC,KAAK,QAAQ;AAAE,mBAAOA,GAAE,eAAa;AAAE,cAAIC,KAAEH,MAAG,wBAAuBI,KAAE,EAAE,EAAE,IAAI,GAAEC,KAAE,KAAK,IAAGC,KAAE,KAAK,IAAGC,KAAE,KAAK,IAAGU,KAAEf,GAAE,UAASiB,KAAEjB,GAAE,QAAOQ,KAAER,GAAE,UAASkB,KAAE,SAASpB,IAAEE,IAAEE,IAAEC,IAAE;AAAC,mBAAOL,OAAIA,GAAEE,EAAC,KAAGF,GAAEC,IAAEE,EAAC,MAAIC,GAAEF,EAAC,EAAE,MAAM,GAAEG,EAAC;AAAA,UAAC,GAAEa,KAAE,SAASlB,IAAE;AAAC,mBAAO,EAAE,EAAEK,KAAE,MAAI,IAAGL,IAAE,GAAG;AAAA,UAAC,GAAEY,KAAEF,MAAG,SAASV,IAAEC,IAAEC,IAAE;AAAC,gBAAIC,KAAEH,KAAE,KAAG,OAAK;AAAK,mBAAOE,KAAEC,GAAE,YAAY,IAAEA;AAAA,UAAC;AAAE,iBAAOA,GAAE,QAAQ,GAAG,SAASH,IAAEG,IAAE;AAAC,mBAAOA,MAAG,SAASH,IAAE;AAAC,sBAAOA,IAAE;AAAA,gBAAC,KAAI;AAAK,yBAAO,OAAOC,GAAE,EAAE,EAAE,MAAM,EAAE;AAAA,gBAAE,KAAI;AAAO,yBAAO,EAAE,EAAEA,GAAE,IAAG,GAAE,GAAG;AAAA,gBAAE,KAAI;AAAI,yBAAOM,KAAE;AAAA,gBAAE,KAAI;AAAK,yBAAO,EAAE,EAAEA,KAAE,GAAE,GAAE,GAAG;AAAA,gBAAE,KAAI;AAAM,yBAAOa,GAAElB,GAAE,aAAYK,IAAEY,IAAE,CAAC;AAAA,gBAAE,KAAI;AAAO,yBAAOC,GAAED,IAAEZ,EAAC;AAAA,gBAAE,KAAI;AAAI,yBAAON,GAAE;AAAA,gBAAG,KAAI;AAAK,yBAAO,EAAE,EAAEA,GAAE,IAAG,GAAE,GAAG;AAAA,gBAAE,KAAI;AAAI,yBAAO,OAAOA,GAAE,EAAE;AAAA,gBAAE,KAAI;AAAK,yBAAOmB,GAAElB,GAAE,aAAYD,GAAE,IAAGgB,IAAE,CAAC;AAAA,gBAAE,KAAI;AAAM,yBAAOG,GAAElB,GAAE,eAAcD,GAAE,IAAGgB,IAAE,CAAC;AAAA,gBAAE,KAAI;AAAO,yBAAOA,GAAEhB,GAAE,EAAE;AAAA,gBAAE,KAAI;AAAI,yBAAO,OAAOI,EAAC;AAAA,gBAAE,KAAI;AAAK,yBAAO,EAAE,EAAEA,IAAE,GAAE,GAAG;AAAA,gBAAE,KAAI;AAAI,yBAAOa,GAAE,CAAC;AAAA,gBAAE,KAAI;AAAK,yBAAOA,GAAE,CAAC;AAAA,gBAAE,KAAI;AAAI,yBAAON,GAAEP,IAAEC,IAAE,IAAE;AAAA,gBAAE,KAAI;AAAI,yBAAOM,GAAEP,IAAEC,IAAE,KAAE;AAAA,gBAAE,KAAI;AAAI,yBAAO,OAAOA,EAAC;AAAA,gBAAE,KAAI;AAAK,yBAAO,EAAE,EAAEA,IAAE,GAAE,GAAG;AAAA,gBAAE,KAAI;AAAI,yBAAO,OAAOL,GAAE,EAAE;AAAA,gBAAE,KAAI;AAAK,yBAAO,EAAE,EAAEA,GAAE,IAAG,GAAE,GAAG;AAAA,gBAAE,KAAI;AAAM,yBAAO,EAAE,EAAEA,GAAE,KAAI,GAAE,GAAG;AAAA,gBAAE,KAAI;AAAI,yBAAOG;AAAA,cAAC;AAAC,qBAAO;AAAA,YAAI,EAAEJ,EAAC,KAAGI,GAAE,QAAQ,KAAI,EAAE;AAAA,UAAC,CAAE;AAAA,QAAC,GAAEK,GAAE,YAAU,WAAU;AAAC,iBAAO,KAAG,CAAC,KAAK,MAAM,KAAK,GAAG,kBAAkB,IAAE,EAAE;AAAA,QAAC,GAAEA,GAAE,OAAK,SAASN,IAAEe,IAAEP,IAAE;AAAC,cAAIC,IAAEC,KAAE,MAAKL,KAAE,EAAE,EAAEU,EAAC,GAAET,KAAE,EAAEN,EAAC,GAAEW,MAAGL,GAAE,UAAU,IAAE,KAAK,UAAU,KAAG,GAAEM,KAAE,OAAKN,IAAEO,KAAE,WAAU;AAAC,mBAAO,EAAE,EAAEH,IAAEJ,EAAC;AAAA,UAAC;AAAE,kBAAOD,IAAE;AAAA,YAAC,KAAK;AAAE,cAAAI,KAAEI,GAAE,IAAE;AAAG;AAAA,YAAM,KAAK;AAAE,cAAAJ,KAAEI,GAAE;AAAE;AAAA,YAAM,KAAK;AAAE,cAAAJ,KAAEI,GAAE,IAAE;AAAE;AAAA,YAAM,KAAK;AAAE,cAAAJ,MAAGG,KAAED,MAAG;AAAO;AAAA,YAAM,KAAK;AAAE,cAAAF,MAAGG,KAAED,MAAG;AAAM;AAAA,YAAM,KAAK;AAAE,cAAAF,KAAEG,KAAE;AAAE;AAAA,YAAM,KAAK;AAAE,cAAAH,KAAEG,KAAE;AAAE;AAAA,YAAM,KAAK;AAAE,cAAAH,KAAEG,KAAE;AAAE;AAAA,YAAM;AAAQ,cAAAH,KAAEG;AAAA,UAAC;AAAC,iBAAOJ,KAAEC,KAAE,EAAE,EAAEA,EAAC;AAAA,QAAC,GAAEH,GAAE,cAAY,WAAU;AAAC,iBAAO,KAAK,MAAM,CAAC,EAAE;AAAA,QAAE,GAAEA,GAAE,UAAQ,WAAU;AAAC,iBAAO,EAAE,KAAK,EAAE;AAAA,QAAC,GAAEA,GAAE,SAAO,SAAST,IAAEC,IAAE;AAAC,cAAG,CAACD;AAAE,mBAAO,KAAK;AAAG,cAAIE,KAAE,KAAK,MAAM,GAAEC,KAAE,EAAEH,IAAEC,IAAE,IAAE;AAAE,iBAAOE,OAAID,GAAE,KAAGC,KAAGD;AAAA,QAAC,GAAEO,GAAE,QAAM,WAAU;AAAC,iBAAO,EAAE,EAAE,KAAK,IAAG,IAAI;AAAA,QAAC,GAAEA,GAAE,SAAO,WAAU;AAAC,iBAAO,IAAI,KAAK,KAAK,QAAQ,CAAC;AAAA,QAAC,GAAEA,GAAE,SAAO,WAAU;AAAC,iBAAO,KAAK,QAAQ,IAAE,KAAK,YAAY,IAAE;AAAA,QAAI,GAAEA,GAAE,cAAY,WAAU;AAAC,iBAAO,KAAK,GAAG,YAAY;AAAA,QAAC,GAAEA,GAAE,WAAS,WAAU;AAAC,iBAAO,KAAK,GAAG,YAAY;AAAA,QAAC,GAAED;AAAA,MAAC,EAAE,GAAE,IAAE,EAAE;AAAU,aAAO,EAAE,YAAU,GAAE,CAAC,CAAC,OAAM,CAAC,GAAE,CAAC,MAAK,CAAC,GAAE,CAAC,MAAK,CAAC,GAAE,CAAC,MAAK,CAAC,GAAE,CAAC,MAAK,CAAC,GAAE,CAAC,MAAK,CAAC,GAAE,CAAC,MAAK,CAAC,GAAE,CAAC,MAAK,CAAC,CAAC,EAAE,QAAS,SAASR,IAAE;AAAC,UAAEA,GAAE,CAAC,CAAC,IAAE,SAASC,IAAE;AAAC,iBAAO,KAAK,GAAGA,IAAED,GAAE,CAAC,GAAEA,GAAE,CAAC,CAAC;AAAA,QAAC;AAAA,MAAC,CAAE,GAAE,EAAE,SAAO,SAASA,IAAEC,IAAE;AAAC,eAAOD,GAAE,OAAKA,GAAEC,IAAE,GAAE,CAAC,GAAED,GAAE,KAAG,OAAI;AAAA,MAAC,GAAE,EAAE,SAAO,GAAE,EAAE,UAAQ,GAAE,EAAE,OAAK,SAASA,IAAE;AAAC,eAAO,EAAE,MAAIA,EAAC;AAAA,MAAC,GAAE,EAAE,KAAG,EAAE,CAAC,GAAE,EAAE,KAAG,GAAE,EAAE,IAAE,CAAC,GAAE;AAAA,IAAC,CAAE;AAAA;AAAA;;;ACAt/N;AAAA,sCAAAqB,SAAA;AAIA,QAAI,IAAI;AACR,QAAI,IAAI,IAAI;AACZ,QAAI,IAAI,IAAI;AACZ,QAAI,IAAI,IAAI;AACZ,QAAI,IAAI,IAAI;AACZ,QAAI,IAAI,IAAI;AAgBZ,IAAAA,QAAO,UAAU,SAAS,KAAK,SAAS;AACtC,gBAAU,WAAW,CAAC;AACtB,UAAI,OAAO,OAAO;AAClB,UAAI,SAAS,YAAY,IAAI,SAAS,GAAG;AACvC,eAAO,MAAM,GAAG;AAAA,MAClB,WAAW,SAAS,YAAY,SAAS,GAAG,GAAG;AAC7C,eAAO,QAAQ,OAAO,QAAQ,GAAG,IAAI,SAAS,GAAG;AAAA,MACnD;AACA,YAAM,IAAI;AAAA,QACR,0DACE,KAAK,UAAU,GAAG;AAAA,MACtB;AAAA,IACF;AAUA,aAAS,MAAM,KAAK;AAClB,YAAM,OAAO,GAAG;AAChB,UAAI,IAAI,SAAS,KAAK;AACpB;AAAA,MACF;AACA,UAAI,QAAQ,mIAAmI;AAAA,QAC7I;AAAA,MACF;AACA,UAAI,CAAC,OAAO;AACV;AAAA,MACF;AACA,UAAI,IAAI,WAAW,MAAM,CAAC,CAAC;AAC3B,UAAI,QAAQ,MAAM,CAAC,KAAK,MAAM,YAAY;AAC1C,cAAQ,MAAM;AAAA,QACZ,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AACH,iBAAO,IAAI;AAAA,QACb,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AACH,iBAAO,IAAI;AAAA,QACb,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AACH,iBAAO,IAAI;AAAA,QACb,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AACH,iBAAO,IAAI;AAAA,QACb,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AACH,iBAAO,IAAI;AAAA,QACb,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AACH,iBAAO,IAAI;AAAA,QACb,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AACH,iBAAO;AAAA,QACT;AACE,iBAAO;AAAA,MACX;AAAA,IACF;AAUA,aAAS,SAAS,IAAI;AACpB,UAAI,QAAQ,KAAK,IAAI,EAAE;AACvB,UAAI,SAAS,GAAG;AACd,eAAO,KAAK,MAAM,KAAK,CAAC,IAAI;AAAA,MAC9B;AACA,UAAI,SAAS,GAAG;AACd,eAAO,KAAK,MAAM,KAAK,CAAC,IAAI;AAAA,MAC9B;AACA,UAAI,SAAS,GAAG;AACd,eAAO,KAAK,MAAM,KAAK,CAAC,IAAI;AAAA,MAC9B;AACA,UAAI,SAAS,GAAG;AACd,eAAO,KAAK,MAAM,KAAK,CAAC,IAAI;AAAA,MAC9B;AACA,aAAO,KAAK;AAAA,IACd;AAUA,aAAS,QAAQ,IAAI;AACnB,UAAI,QAAQ,KAAK,IAAI,EAAE;AACvB,UAAI,SAAS,GAAG;AACd,eAAO,OAAO,IAAI,OAAO,GAAG,KAAK;AAAA,MACnC;AACA,UAAI,SAAS,GAAG;AACd,eAAO,OAAO,IAAI,OAAO,GAAG,MAAM;AAAA,MACpC;AACA,UAAI,SAAS,GAAG;AACd,eAAO,OAAO,IAAI,OAAO,GAAG,QAAQ;AAAA,MACtC;AACA,UAAI,SAAS,GAAG;AACd,eAAO,OAAO,IAAI,OAAO,GAAG,QAAQ;AAAA,MACtC;AACA,aAAO,KAAK;AAAA,IACd;AAMA,aAAS,OAAO,IAAI,OAAO,GAAG,MAAM;AAClC,UAAI,WAAW,SAAS,IAAI;AAC5B,aAAO,KAAK,MAAM,KAAK,CAAC,IAAI,MAAM,QAAQ,WAAW,MAAM;AAAA,IAC7D;AAAA;AAAA;;;ACjKA;AAAA,8CAAAC,SAAA;AAMA,aAAS,MAAM,KAAK;AACnB,kBAAY,QAAQ;AACpB,kBAAY,UAAU;AACtB,kBAAY,SAAS;AACrB,kBAAY,UAAU;AACtB,kBAAY,SAAS;AACrB,kBAAY,UAAU;AACtB,kBAAY,WAAW;AACvB,kBAAY,UAAU;AAEtB,aAAO,KAAK,GAAG,EAAE,QAAQ,SAAO;AAC/B,oBAAY,GAAG,IAAI,IAAI,GAAG;AAAA,MAC3B,CAAC;AAMD,kBAAY,QAAQ,CAAC;AACrB,kBAAY,QAAQ,CAAC;AAOrB,kBAAY,aAAa,CAAC;AAQ1B,eAAS,YAAY,WAAW;AAC/B,YAAI,OAAO;AAEX,iBAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AAC1C,kBAAS,QAAQ,KAAK,OAAQ,UAAU,WAAW,CAAC;AACpD,kBAAQ;AAAA,QACT;AAEA,eAAO,YAAY,OAAO,KAAK,IAAI,IAAI,IAAI,YAAY,OAAO,MAAM;AAAA,MACrE;AACA,kBAAY,cAAc;AAS1B,eAAS,YAAY,WAAW;AAC/B,YAAI;AACJ,YAAI,iBAAiB;AACrB,YAAI;AACJ,YAAI;AAEJ,iBAASC,UAAS,MAAM;AAEvB,cAAI,CAACA,OAAM,SAAS;AACnB;AAAA,UACD;AAEA,gBAAMC,QAAOD;AAGb,gBAAM,OAAO,OAAO,IAAI,KAAK,CAAC;AAC9B,gBAAM,KAAK,QAAQ,YAAY;AAC/B,UAAAC,MAAK,OAAO;AACZ,UAAAA,MAAK,OAAO;AACZ,UAAAA,MAAK,OAAO;AACZ,qBAAW;AAEX,eAAK,CAAC,IAAI,YAAY,OAAO,KAAK,CAAC,CAAC;AAEpC,cAAI,OAAO,KAAK,CAAC,MAAM,UAAU;AAEhC,iBAAK,QAAQ,IAAI;AAAA,UAClB;AAGA,cAAI,QAAQ;AACZ,eAAK,CAAC,IAAI,KAAK,CAAC,EAAE,QAAQ,iBAAiB,CAAC,OAAO,WAAW;AAE7D,gBAAI,UAAU,MAAM;AACnB,qBAAO;AAAA,YACR;AACA;AACA,kBAAM,YAAY,YAAY,WAAW,MAAM;AAC/C,gBAAI,OAAO,cAAc,YAAY;AACpC,oBAAM,MAAM,KAAK,KAAK;AACtB,sBAAQ,UAAU,KAAKA,OAAM,GAAG;AAGhC,mBAAK,OAAO,OAAO,CAAC;AACpB;AAAA,YACD;AACA,mBAAO;AAAA,UACR,CAAC;AAGD,sBAAY,WAAW,KAAKA,OAAM,IAAI;AAEtC,gBAAM,QAAQA,MAAK,OAAO,YAAY;AACtC,gBAAM,MAAMA,OAAM,IAAI;AAAA,QACvB;AAEA,QAAAD,OAAM,YAAY;AAClB,QAAAA,OAAM,YAAY,YAAY,UAAU;AACxC,QAAAA,OAAM,QAAQ,YAAY,YAAY,SAAS;AAC/C,QAAAA,OAAM,SAAS;AACf,QAAAA,OAAM,UAAU,YAAY;AAE5B,eAAO,eAAeA,QAAO,WAAW;AAAA,UACvC,YAAY;AAAA,UACZ,cAAc;AAAA,UACd,KAAK,MAAM;AACV,gBAAI,mBAAmB,MAAM;AAC5B,qBAAO;AAAA,YACR;AACA,gBAAI,oBAAoB,YAAY,YAAY;AAC/C,gCAAkB,YAAY;AAC9B,6BAAe,YAAY,QAAQ,SAAS;AAAA,YAC7C;AAEA,mBAAO;AAAA,UACR;AAAA,UACA,KAAK,OAAK;AACT,6BAAiB;AAAA,UAClB;AAAA,QACD,CAAC;AAGD,YAAI,OAAO,YAAY,SAAS,YAAY;AAC3C,sBAAY,KAAKA,MAAK;AAAA,QACvB;AAEA,eAAOA;AAAA,MACR;AAEA,eAAS,OAAO,WAAW,WAAW;AACrC,cAAM,WAAW,YAAY,KAAK,aAAa,OAAO,cAAc,cAAc,MAAM,aAAa,SAAS;AAC9G,iBAAS,MAAM,KAAK;AACpB,eAAO;AAAA,MACR;AASA,eAAS,OAAO,YAAY;AAC3B,oBAAY,KAAK,UAAU;AAC3B,oBAAY,aAAa;AAEzB,oBAAY,QAAQ,CAAC;AACrB,oBAAY,QAAQ,CAAC;AAErB,YAAI;AACJ,cAAM,SAAS,OAAO,eAAe,WAAW,aAAa,IAAI,MAAM,QAAQ;AAC/E,cAAM,MAAM,MAAM;AAElB,aAAK,IAAI,GAAG,IAAI,KAAK,KAAK;AACzB,cAAI,CAAC,MAAM,CAAC,GAAG;AAEd;AAAA,UACD;AAEA,uBAAa,MAAM,CAAC,EAAE,QAAQ,OAAO,KAAK;AAE1C,cAAI,WAAW,CAAC,MAAM,KAAK;AAC1B,wBAAY,MAAM,KAAK,IAAI,OAAO,MAAM,WAAW,MAAM,CAAC,IAAI,GAAG,CAAC;AAAA,UACnE,OAAO;AACN,wBAAY,MAAM,KAAK,IAAI,OAAO,MAAM,aAAa,GAAG,CAAC;AAAA,UAC1D;AAAA,QACD;AAAA,MACD;AAQA,eAAS,UAAU;AAClB,cAAM,aAAa;AAAA,UAClB,GAAG,YAAY,MAAM,IAAI,WAAW;AAAA,UACpC,GAAG,YAAY,MAAM,IAAI,WAAW,EAAE,IAAI,eAAa,MAAM,SAAS;AAAA,QACvE,EAAE,KAAK,GAAG;AACV,oBAAY,OAAO,EAAE;AACrB,eAAO;AAAA,MACR;AASA,eAAS,QAAQ,MAAM;AACtB,YAAI,KAAK,KAAK,SAAS,CAAC,MAAM,KAAK;AAClC,iBAAO;AAAA,QACR;AAEA,YAAI;AACJ,YAAI;AAEJ,aAAK,IAAI,GAAG,MAAM,YAAY,MAAM,QAAQ,IAAI,KAAK,KAAK;AACzD,cAAI,YAAY,MAAM,CAAC,EAAE,KAAK,IAAI,GAAG;AACpC,mBAAO;AAAA,UACR;AAAA,QACD;AAEA,aAAK,IAAI,GAAG,MAAM,YAAY,MAAM,QAAQ,IAAI,KAAK,KAAK;AACzD,cAAI,YAAY,MAAM,CAAC,EAAE,KAAK,IAAI,GAAG;AACpC,mBAAO;AAAA,UACR;AAAA,QACD;AAEA,eAAO;AAAA,MACR;AASA,eAAS,YAAY,QAAQ;AAC5B,eAAO,OAAO,SAAS,EACrB,UAAU,GAAG,OAAO,SAAS,EAAE,SAAS,CAAC,EACzC,QAAQ,WAAW,GAAG;AAAA,MACzB;AASA,eAAS,OAAO,KAAK;AACpB,YAAI,eAAe,OAAO;AACzB,iBAAO,IAAI,SAAS,IAAI;AAAA,QACzB;AACA,eAAO;AAAA,MACR;AAMA,eAAS,UAAU;AAClB,gBAAQ,KAAK,uIAAuI;AAAA,MACrJ;AAEA,kBAAY,OAAO,YAAY,KAAK,CAAC;AAErC,aAAO;AAAA,IACR;AAEA,IAAAD,QAAO,UAAU;AAAA;AAAA;;;ACjRjB;AAAA,+CAAAG,SAAA;AAMA,YAAQ,aAAa;AACrB,YAAQ,OAAO;AACf,YAAQ,OAAO;AACf,YAAQ,YAAY;AACpB,YAAQ,UAAU,aAAa;AAC/B,YAAQ,WAAW,MAAM;AACxB,UAAI,SAAS;AAEb,aAAO,MAAM;AACZ,YAAI,CAAC,QAAQ;AACZ,mBAAS;AACT,kBAAQ,KAAK,uIAAuI;AAAA,QACrJ;AAAA,MACD;AAAA,IACD,GAAG;AAMH,YAAQ,SAAS;AAAA,MAChB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACD;AAWA,aAAS,YAAY;AAIpB,UAAI,OAAO,WAAW,eAAe,OAAO,YAAY,OAAO,QAAQ,SAAS,cAAc,OAAO,QAAQ,SAAS;AACrH,eAAO;AAAA,MACR;AAGA,UAAI,OAAO,cAAc,eAAe,UAAU,aAAa,UAAU,UAAU,YAAY,EAAE,MAAM,uBAAuB,GAAG;AAChI,eAAO;AAAA,MACR;AAIA,aAAQ,OAAO,aAAa,eAAe,SAAS,mBAAmB,SAAS,gBAAgB,SAAS,SAAS,gBAAgB,MAAM;AAAA,MAEtI,OAAO,WAAW,eAAe,OAAO,YAAY,OAAO,QAAQ,WAAY,OAAO,QAAQ,aAAa,OAAO,QAAQ;AAAA;AAAA,MAG1H,OAAO,cAAc,eAAe,UAAU,aAAa,UAAU,UAAU,YAAY,EAAE,MAAM,gBAAgB,KAAK,SAAS,OAAO,IAAI,EAAE,KAAK;AAAA,MAEnJ,OAAO,cAAc,eAAe,UAAU,aAAa,UAAU,UAAU,YAAY,EAAE,MAAM,oBAAoB;AAAA,IAC1H;AAQA,aAAS,WAAW,MAAM;AACzB,WAAK,CAAC,KAAK,KAAK,YAAY,OAAO,MAClC,KAAK,aACJ,KAAK,YAAY,QAAQ,OAC1B,KAAK,CAAC,KACL,KAAK,YAAY,QAAQ,OAC1B,MAAMA,QAAO,QAAQ,SAAS,KAAK,IAAI;AAExC,UAAI,CAAC,KAAK,WAAW;AACpB;AAAA,MACD;AAEA,YAAM,IAAI,YAAY,KAAK;AAC3B,WAAK,OAAO,GAAG,GAAG,GAAG,gBAAgB;AAKrC,UAAI,QAAQ;AACZ,UAAI,QAAQ;AACZ,WAAK,CAAC,EAAE,QAAQ,eAAe,WAAS;AACvC,YAAI,UAAU,MAAM;AACnB;AAAA,QACD;AACA;AACA,YAAI,UAAU,MAAM;AAGnB,kBAAQ;AAAA,QACT;AAAA,MACD,CAAC;AAED,WAAK,OAAO,OAAO,GAAG,CAAC;AAAA,IACxB;AAUA,YAAQ,MAAM,QAAQ,SAAS,QAAQ,QAAQ,MAAM;AAAA,IAAC;AAQtD,aAAS,KAAK,YAAY;AACzB,UAAI;AACH,YAAI,YAAY;AACf,kBAAQ,QAAQ,QAAQ,SAAS,UAAU;AAAA,QAC5C,OAAO;AACN,kBAAQ,QAAQ,WAAW,OAAO;AAAA,QACnC;AAAA,MACD,SAAS,OAAP;AAAA,MAGF;AAAA,IACD;AAQA,aAAS,OAAO;AACf,UAAI;AACJ,UAAI;AACH,YAAI,QAAQ,QAAQ,QAAQ,OAAO;AAAA,MACpC,SAAS,OAAP;AAAA,MAGF;AAGA,UAAI,CAAC,KAAK,OAAO,YAAY,eAAe,SAAS,SAAS;AAC7D,YAAI,QAAQ,IAAI;AAAA,MACjB;AAEA,aAAO;AAAA,IACR;AAaA,aAAS,eAAe;AACvB,UAAI;AAGH,eAAO;AAAA,MACR,SAAS,OAAP;AAAA,MAGF;AAAA,IACD;AAEA,IAAAA,QAAO,UAAU,iBAAoB,OAAO;AAE5C,QAAM,EAAC,WAAU,IAAIA,QAAO;AAM5B,eAAW,IAAI,SAAU,GAAG;AAC3B,UAAI;AACH,eAAO,KAAK,UAAU,CAAC;AAAA,MACxB,SAAS,OAAP;AACD,eAAO,iCAAiC,MAAM;AAAA,MAC/C;AAAA,IACD;AAAA;AAAA;;;;;;;;;;AC5QA,QAAA,OAAA,QAAA,IAAA;AACA,QAAA,UAAA,gBAAA,iBAAA;AAEA,QAAM,MAAM,QAAA,QAAM,sBAAsB;AAExC,aAAS,MAAM,MAAc,QAAiB,aAAoB;AAC/D,UAAI,eAAe,IAAI;AAEvB,UAAI;AACD,cAAM,OAAO,KAAA,SAAS,IAAI;AAE1B,YAAI,KAAK,OAAM,KAAM,QAAQ;AAC1B,cAAI,6BAA6B;AACjC,iBAAO;;AAGV,YAAI,KAAK,YAAW,KAAM,aAAa;AACpC,cAAI,kCAAkC;AACtC,iBAAO;;AAGV,YAAI,iEAAiE;AACrE,eAAO;eACD,GAAP;AACC,YAAI,EAAE,SAAS,UAAU;AACtB,cAAI,qCAAqC,CAAC;AAC1C,iBAAO;;AAGV,YAAI,cAAc,CAAC;AACnB,cAAM;;IAEZ;AAQA,aAAgBC,QAAO,MAAc,OAAe,QAAA,UAAQ;AACzD,aAAO,MAAM,OAAO,OAAO,QAAA,QAAQ,IAAI,OAAO,QAAA,UAAU,CAAC;IAC5D;AAFA,YAAA,SAAAA;AAOa,YAAA,OAAO;AAKP,YAAA,SAAS;AAKT,YAAA,WAAW,QAAA,OAAO,QAAA;;;;;;;;;;;;;;ACxD/B,IAAAC,UAAA,aAAA;;;;;;;;;;ACgCA,aAAgBC,YAAQ;AACrB,UAAI;AACJ,UAAI;AACJ,UAAI,SAAgC;AAEpC,YAAM,UAAsB,IAAI,QAAW,CAAC,OAAO,UAAS;AACzD,eAAO;AACP,eAAO;MACV,CAAC;AAED,aAAO;QACJ;QACA,KAAM,QAAM;AACT,cAAI,WAAW,WAAW;AACvB,qBAAS;AACT,iBAAK,MAAM;;QAEjB;QACA,KAAM,OAAK;AACR,cAAI,WAAW,WAAW;AACvB,qBAAS;AACT,iBAAK,KAAK;;QAEhB;QACA,IAAI,YAAS;AACV,iBAAO,WAAW;QACrB;QACA,IAAI,SAAM;AACP,iBAAO;QACV;;IAEN;AA/BA,YAAA,WAAAA;AAyCa,YAAA,iBAAiBA;AAS9B,YAAA,UAAeA;;;;;ACnFf;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,cAAc;;;ACA3B,IAAM,YAAY;AAAA,EAChB,QAAQ,OAAO;AAAA,EACf,OAAO;AAAA,EACP,OAAO;AAAA,EACP,MAAM;AAAA,EACN,KAAK;AAAA,EACL,MAAM;AAAA,EACN,SAAS;AAAA,EACT,MAAM;AAAA,EACN,OAAO;AAAA,EACP,OAAO;AAAA,EACP,KAAK;AAAA,EACL,OAAO;AAAA,EACP,OAAO;AAAA,EACP,SAAS,OAAO;AAClB;AACA,IAAM,WAAW;AAAA;AAAA,EAEf,QAAQ;AAAA,IACN,OAAO;AAAA,EACT;AAAA;AAAA,EAEA,OAAO;AAAA,IACL,OAAO,UAAU;AAAA,EACnB;AAAA,EACA,OAAO;AAAA,IACL,OAAO,UAAU;AAAA,EACnB;AAAA;AAAA,EAEA,MAAM;AAAA,IACJ,OAAO,UAAU;AAAA,EACnB;AAAA;AAAA,EAEA,KAAK;AAAA,IACH,OAAO,UAAU;AAAA,EACnB;AAAA;AAAA,EAEA,MAAM;AAAA,IACJ,OAAO,UAAU;AAAA,EACnB;AAAA,EACA,SAAS;AAAA,IACP,OAAO,UAAU;AAAA,EACnB;AAAA,EACA,MAAM;AAAA,IACJ,OAAO,UAAU;AAAA,EACnB;AAAA,EACA,OAAO;AAAA,IACL,OAAO,UAAU;AAAA,EACnB;AAAA,EACA,OAAO;AAAA,IACL,OAAO,UAAU;AAAA,EACnB;AAAA,EACA,KAAK;AAAA,IACH,OAAO,UAAU;AAAA,EACnB;AAAA;AAAA,EAEA,OAAO;AAAA,IACL,OAAO,UAAU;AAAA,EACnB;AAAA;AAAA,EAEA,OAAO;AAAA,IACL,OAAO,UAAU;AAAA,EACnB;AAAA;AAAA,EAEA,SAAS;AAAA,IACP,OAAO,UAAU;AAAA,EACnB;AACF;AAEA,SAAS,SAAS,OAAO;AACvB,SAAO,UAAU,QAAQ,OAAO,UAAU;AAC5C;AACA,SAAS,MAAM,YAAY,UAAU,YAAY,KAAK,QAAQ;AAC5D,MAAI,CAAC,SAAS,QAAQ,GAAG;AACvB,WAAO,MAAM,YAAY,CAAC,GAAG,WAAW,MAAM;AAAA,EAChD;AACA,QAAM,SAAS,OAAO,OAAO,CAAC,GAAG,QAAQ;AACzC,aAAW,OAAO,YAAY;AAC5B,QAAI,QAAQ,eAAe,QAAQ,eAAe;AAChD;AAAA,IACF;AACA,UAAM,QAAQ,WAAW,GAAG;AAC5B,QAAI,UAAU,QAAQ,UAAU,QAAQ;AACtC;AAAA,IACF;AACA,QAAI,UAAU,OAAO,QAAQ,KAAK,OAAO,SAAS,GAAG;AACnD;AAAA,IACF;AACA,QAAI,MAAM,QAAQ,KAAK,KAAK,MAAM,QAAQ,OAAO,GAAG,CAAC,GAAG;AACtD,aAAO,GAAG,IAAI,CAAC,GAAG,OAAO,GAAG,OAAO,GAAG,CAAC;AAAA,IACzC,WAAW,SAAS,KAAK,KAAK,SAAS,OAAO,GAAG,CAAC,GAAG;AACnD,aAAO,GAAG,IAAI;AAAA,QACZ;AAAA,QACA,OAAO,GAAG;AAAA,SACT,YAAY,GAAG,eAAe,MAAM,IAAI,SAAS;AAAA,QAClD;AAAA,MACF;AAAA,IACF,OAAO;AACL,aAAO,GAAG,IAAI;AAAA,IAChB;AAAA,EACF;AACA,SAAO;AACT;AACA,SAAS,WAAW,QAAQ;AAC1B,SAAO,IAAI;AAAA;AAAA,IAET,WAAW,OAAO,CAAC,GAAG,MAAM,MAAM,GAAG,GAAG,IAAI,MAAM,GAAG,CAAC,CAAC;AAAA;AAE3D;AACA,IAAM,OAAO,WAAW;AAExB,SAAS,cAAc,KAAK;AAC1B,SAAO,OAAO,UAAU,SAAS,KAAK,GAAG,MAAM;AACjD;AACA,SAAS,SAAS,KAAK;AACrB,MAAI,CAAC,cAAc,GAAG,GAAG;AACvB,WAAO;AAAA,EACT;AACA,MAAI,CAAC,IAAI,WAAW,CAAC,IAAI,MAAM;AAC7B,WAAO;AAAA,EACT;AACA,MAAI,IAAI,OAAO;AACb,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEA,IAAI,SAAS;AACb,IAAM,QAAQ,CAAC;AACf,IAAM,UAAN,MAAc;AAAA,EACZ,YAAY,UAAU,CAAC,GAAG;AACxB,UAAM,QAAQ,QAAQ,SAAS;AAC/B,SAAK,UAAU;AAAA,MACb;AAAA,QACE,GAAG;AAAA,QACH,UAAU,EAAE,GAAG,QAAQ,SAAS;AAAA,QAChC,OAAO,mBAAmB,QAAQ,OAAO,KAAK;AAAA,QAC9C,WAAW,CAAC,GAAG,QAAQ,aAAa,CAAC,CAAC;AAAA,MACxC;AAAA,MACA;AAAA,QACE,OAAO;AAAA,QACP,UAAU;AAAA,QACV,aAAa;AAAA,QACb,eAAe;AAAA,UACb,MAAM;AAAA,UACN,QAAQ;AAAA,UACR,SAAS;AAAA,QACX;AAAA,MACF;AAAA,IACF;AACA,eAAW,QAAQ,OAAO;AACxB,YAAM,WAAW;AAAA,QACf;AAAA,QACA,GAAG,KAAK,QAAQ;AAAA,QAChB,GAAG,MAAM,IAAI;AAAA,MACf;AACA,WAAK,IAAI,IAAI,KAAK,WAAW,QAAQ;AACrC,WAAK,IAAI,EAAE,MAAM,KAAK;AAAA,QACpB;AAAA,QACA;AAAA,MACF;AAAA,IACF;AACA,QAAI,KAAK,QAAQ,QAAQ;AACvB,WAAK,UAAU;AAAA,IACjB;AACA,SAAK,WAAW,CAAC;AAAA,EACnB;AAAA,EACA,IAAI,QAAQ;AACV,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA,EACA,IAAI,MAAM,OAAO;AACf,SAAK,QAAQ,QAAQ;AAAA,MACnB;AAAA,MACA,KAAK,QAAQ;AAAA,MACb,KAAK,QAAQ;AAAA,IACf;AAAA,EACF;AAAA,EACA,OAAO,SAAS,MAAM;AACpB,QAAI,CAAC,KAAK,QAAQ,QAAQ;AACxB,YAAM,IAAI,MAAM,0BAA0B;AAAA,IAC5C;AACA,WAAO,KAAK,QAAQ,OAAO,SAAS,IAAI;AAAA,EAC1C;AAAA,EACA,OAAO,SAAS;AACd,UAAM,WAAW,IAAI,QAAQ;AAAA,MAC3B,GAAG,KAAK;AAAA,MACR,GAAG;AAAA,IACL,CAAC;AACD,QAAI,KAAK,SAAS;AAChB,eAAS,UAAU,KAAK,OAAO;AAAA,IACjC;AACA,WAAO;AAAA,EACT;AAAA,EACA,aAAa,UAAU;AACrB,WAAO,KAAK,OAAO;AAAA,MACjB,GAAG,KAAK;AAAA,MACR,UAAU;AAAA,QACR,GAAG,KAAK,QAAQ;AAAA,QAChB,GAAG;AAAA,MACL;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EACA,QAAQ,KAAK;AACX,WAAO,KAAK,aAAa;AAAA,MACvB,KAAK,KAAK,QAAQ,SAAS,MAAM,KAAK,QAAQ,SAAS,MAAM,MAAM,MAAM;AAAA,IAC3E,CAAC;AAAA,EACH;AAAA,EACA,YAAY,UAAU;AACpB,SAAK,QAAQ,UAAU,KAAK,QAAQ;AACpC,WAAO;AAAA,EACT;AAAA,EACA,eAAe,UAAU;AACvB,QAAI,UAAU;AACZ,YAAM,IAAI,KAAK,QAAQ,UAAU,QAAQ,QAAQ;AACjD,UAAI,KAAK,GAAG;AACV,eAAO,KAAK,QAAQ,UAAU,OAAO,GAAG,CAAC;AAAA,MAC3C;AAAA,IACF,OAAO;AACL,WAAK,QAAQ,UAAU,OAAO,CAAC;AAAA,IACjC;AACA,WAAO;AAAA,EACT;AAAA,EACA,aAAa,WAAW;AACtB,SAAK,QAAQ,YAAY,MAAM,QAAQ,SAAS,IAAI,YAAY,CAAC,SAAS;AAC1E,WAAO;AAAA,EACT;AAAA,EACA,UAAU;AACR,SAAK,YAAY;AACjB,SAAK,QAAQ;AAAA,EACf;AAAA,EACA,aAAa;AACX,SAAK,eAAe;AACpB,SAAK,WAAW;AAAA,EAClB;AAAA,EACA,cAAc;AACZ,eAAW,QAAQ,KAAK,QAAQ,OAAO;AACrC,UAAI,CAAC,QAAQ,OAAO,IAAI,GAAG;AACzB,gBAAQ,OAAO,IAAI,IAAI,QAAQ,IAAI;AAAA,MACrC;AACA,cAAQ,IAAI,IAAI,KAAK,IAAI,EAAE;AAAA,IAC7B;AAAA,EACF;AAAA,EACA,iBAAiB;AACf,eAAW,QAAQ,KAAK,QAAQ,OAAO;AACrC,UAAI,QAAQ,OAAO,IAAI,GAAG;AACxB,gBAAQ,IAAI,IAAI,QAAQ,OAAO,IAAI;AACnC,eAAO,QAAQ,OAAO,IAAI;AAAA,MAC5B;AAAA,IACF;AAAA,EACF;AAAA,EACA,UAAU;AACR,SAAK,YAAY,KAAK,QAAQ,QAAQ,KAAK;AAC3C,SAAK,YAAY,KAAK,QAAQ,QAAQ,KAAK;AAAA,EAC7C;AAAA,EACA,YAAY,QAAQ,MAAM;AACxB,QAAI,CAAC,QAAQ;AACX;AAAA,IACF;AACA,QAAI,CAAC,OAAO,SAAS;AACnB,aAAO,UAAU,OAAO;AAAA,IAC1B;AACA,WAAO,QAAQ,CAAC,SAAS;AACvB,WAAK,IAAI,EAAE,IAAI,OAAO,IAAI,EAAE,KAAK,CAAC;AAAA,IACpC;AAAA,EACF;AAAA,EACA,aAAa;AACX,SAAK,eAAe,KAAK,QAAQ,MAAM;AACvC,SAAK,eAAe,KAAK,QAAQ,MAAM;AAAA,EACzC;AAAA,EACA,eAAe,QAAQ;AACrB,QAAI,CAAC,QAAQ;AACX;AAAA,IACF;AACA,QAAI,OAAO,SAAS;AAClB,aAAO,QAAQ,OAAO;AACtB,aAAO,OAAO;AAAA,IAChB;AAAA,EACF;AAAA,EACA,YAAY;AACV,aAAS;AAAA,EACX;AAAA,EACA,aAAa;AACX,aAAS;AACT,UAAM,SAAS,MAAM,OAAO,CAAC;AAC7B,eAAW,QAAQ,QAAQ;AACzB,WAAK,CAAC,EAAE,OAAO,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC;AAAA,IACjC;AAAA,EACF;AAAA,EACA,UAAU,QAAQ;AAChB,UAAM,UAAU,UAAU,KAAK,QAAQ;AACvC,SAAK,UAAU;AACf,QAAI,OAAO,YAAY,YAAY;AACjC;AAAA,IACF;AACA,eAAW,QAAQ,KAAK,QAAQ,OAAO;AACrC,WAAK,IAAI,IAAI,QAAQ,MAAM,KAAK,QAAQ,MAAM,IAAI,CAAC,KAAK,KAAK,IAAI;AACjE,WAAK,IAAI,EAAE,MAAM,KAAK,IAAI;AAAA,IAC5B;AAAA,EACF;AAAA,EACA,WAAW,UAAU,OAAO;AAC1B,WAAO,IAAI,SAAS;AAClB,UAAI,QAAQ;AACV,cAAM,KAAK,CAAC,MAAM,UAAU,MAAM,KAAK,CAAC;AACxC;AAAA,MACF;AACA,aAAO,KAAK,OAAO,UAAU,MAAM,KAAK;AAAA,IAC1C;AAAA,EACF;AAAA,EACA,OAAO,UAAU,MAAM,OAAO;AAC5B,SAAK,SAAS,SAAS,KAAK,KAAK,OAAO;AACtC,aAAO;AAAA,IACT;AACA,UAAM,SAAS;AAAA,MACb,MAAsB,oBAAI,KAAK;AAAA,MAC/B,MAAM,CAAC;AAAA,MACP,GAAG;AAAA,MACH,OAAO,mBAAmB,SAAS,OAAO,KAAK,QAAQ,KAAK;AAAA,IAC9D;AACA,QAAI,CAAC,SAAS,KAAK,WAAW,KAAK,SAAS,KAAK,CAAC,CAAC,GAAG;AACpD,aAAO,OAAO,QAAQ,KAAK,CAAC,CAAC;AAAA,IAC/B,OAAO;AACL,aAAO,OAAO,CAAC,GAAG,IAAI;AAAA,IACxB;AACA,QAAI,OAAO,SAAS;AAClB,aAAO,KAAK,QAAQ,OAAO,OAAO;AAClC,aAAO,OAAO;AAAA,IAChB;AACA,QAAI,OAAO,YAAY;AACrB,UAAI,CAAC,MAAM,QAAQ,OAAO,UAAU,GAAG;AACrC,eAAO,aAAa,OAAO,WAAW,MAAM,IAAI;AAAA,MAClD;AACA,aAAO,KAAK,KAAK,OAAO,OAAO,WAAW,KAAK,IAAI,CAAC;AACpD,aAAO,OAAO;AAAA,IAChB;AACA,WAAO,OAAO,OAAO,OAAO,SAAS,WAAW,OAAO,KAAK,YAAY,IAAI;AAC5E,WAAO,MAAM,OAAO,OAAO,QAAQ,WAAW,OAAO,MAAM;AAC3D,UAAM,aAAa,CAAC,SAAS,UAAU;AACrC,YAAM,YAAY,KAAK,SAAS,SAAS,KAAK,KAAK,QAAQ;AAC3D,UAAI,KAAK,SAAS,UAAU,WAAW,GAAG;AACxC,cAAM,QAAQ,CAAC,GAAG,KAAK,SAAS,OAAO,IAAI;AAC3C,YAAI,WAAW,GAAG;AAChB,gBAAM,KAAK,aAAa,iBAAiB;AAAA,QAC3C;AACA,aAAK,KAAK,EAAE,GAAG,KAAK,SAAS,QAAQ,MAAM,MAAM,CAAC;AAClD,aAAK,SAAS,QAAQ;AAAA,MACxB;AACA,UAAI,QAAQ;AACV,aAAK,SAAS,SAAS;AACvB,aAAK,KAAK,MAAM;AAAA,MAClB;AAAA,IACF;AACA,iBAAa,KAAK,SAAS,OAAO;AAClC,UAAM,WAAW,KAAK,SAAS,QAAQ,OAAO,OAAO,OAAO,KAAK,QAAQ,IAAI,KAAK,SAAS,KAAK,QAAQ,IAAI;AAC5G,SAAK,SAAS,OAAO,OAAO;AAC5B,QAAI,WAAW,KAAK,QAAQ,UAAU;AACpC,UAAI;AACF,cAAM,gBAAgB,KAAK,UAAU;AAAA,UACnC,OAAO;AAAA,UACP,OAAO;AAAA,UACP,OAAO;AAAA,QACT,CAAC;AACD,cAAM,YAAY,KAAK,SAAS,eAAe;AAC/C,aAAK,SAAS,aAAa;AAC3B,YAAI,WAAW;AACb,eAAK,SAAS,SAAS,KAAK,SAAS,SAAS,KAAK;AACnD,cAAI,KAAK,SAAS,QAAQ,KAAK,QAAQ,aAAa;AAClD,iBAAK,SAAS,UAAU;AAAA,cACtB;AAAA,cACA,KAAK,QAAQ;AAAA,YACf;AACA;AAAA,UACF;AAAA,QACF;AAAA,MACF,SAAQ,GAAN;AAAA,MACF;AAAA,IACF;AACA,eAAW,IAAI;AAAA,EACjB;AAAA,EACA,KAAK,QAAQ;AACX,eAAW,YAAY,KAAK,QAAQ,WAAW;AAC7C,eAAS,IAAI,QAAQ;AAAA,QACnB,SAAS,KAAK;AAAA,MAChB,CAAC;AAAA,IACH;AAAA,EACF;AACF;AACA,SAAS,mBAAmB,OAAO,QAAQ,CAAC,GAAG,eAAe,GAAG;AAC/D,MAAI,UAAU,QAAQ;AACpB,WAAO;AAAA,EACT;AACA,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO;AAAA,EACT;AACA,MAAI,MAAM,KAAK,KAAK,MAAM,KAAK,EAAE,UAAU,QAAQ;AACjD,WAAO,MAAM,KAAK,EAAE;AAAA,EACtB;AACA,SAAO;AACT;AACA,QAAQ,UAAU,MAAM,QAAQ,UAAU;AAC1C,QAAQ,UAAU,SAAS,QAAQ,UAAU;AAC7C,QAAQ,UAAU,QAAQ,QAAQ,UAAU;AAC5C,QAAQ,UAAU,YAAY,QAAQ,UAAU;AAChD,QAAQ,UAAU,OAAO,QAAQ,UAAU;AAC3C,QAAQ,UAAU,QAAQ,QAAQ,UAAU;AAC5C,QAAQ,UAAU,SAAS,QAAQ,UAAU;AAC7C,SAAS,cAAc,UAAU,CAAC,GAAG;AACnC,SAAO,IAAI,QAAQ,OAAO;AAC5B;;;ACpZA,IAAM,kBAAN,MAAsB;AAAA,EACpB,YAAY,SAAS;AACnB,SAAK,UAAU,EAAE,GAAG,QAAQ;AAC5B,SAAK,eAAe;AACpB,SAAK,gBAAgB;AAAA,MACnB,GAAG;AAAA;AAAA,MAEH,GAAG;AAAA;AAAA,MAEH,GAAG;AAAA;AAAA,IAEL;AACA,SAAK,eAAe;AAAA,MAClB,SAAS;AAAA;AAAA,IAEX;AAAA,EACF;AAAA,EACA,UAAU,OAAO;AACf,QAAI,QAAQ,GAAG;AACb,aAAO,QAAQ,WAAW,QAAQ;AAAA,IACpC;AACA,QAAI,UAAU,GAAG;AACf,aAAO,QAAQ,UAAU,QAAQ;AAAA,IACnC;AACA,WAAO,QAAQ,SAAS,QAAQ;AAAA,EAClC;AAAA,EACA,IAAI,QAAQ;AACV,UAAM,eAAe,KAAK,UAAU,OAAO,KAAK;AAChD,UAAM,OAAO,OAAO,SAAS,QAAQ,KAAK,OAAO;AACjD,UAAM,MAAM,OAAO,OAAO;AAC1B,UAAM,QAAQ,KAAK,aAAa,OAAO,IAAI,KAAK,KAAK,cAAc,OAAO,KAAK,KAAK,KAAK;AACzF,UAAM,QAAQ;AAAA,oBACE;AAAA;AAAA;AAAA;AAAA;AAAA;AAMhB,UAAM,QAAQ,KAAK,CAAC,KAAK,IAAI,EAAE,OAAO,OAAO,EAAE,KAAK,GAAG;AACvD,QAAI,OAAO,OAAO,KAAK,CAAC,MAAM,UAAU;AACtC;AAAA,QACE,GAAG,WAAW,OAAO,KAAK,CAAC;AAAA,QAC3B;AAAA;AAAA,QAEA;AAAA,QACA,GAAG,OAAO,KAAK,MAAM,CAAC;AAAA,MACxB;AAAA,IACF,OAAO;AACL,mBAAa,OAAO,OAAO,GAAG,OAAO,IAAI;AAAA,IAC3C;AAAA,EACF;AACF;AAEA,SAASC,eAAc,UAAU,CAAC,GAAG;AACnC,QAAM,WAAW,cAAgB;AAAA,IAC/B,WAAW,QAAQ,aAAa,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC;AAAA,IACxD,OAAO,SAAS,WAAW,CAAC,GAAG;AAC7B,UAAI,SAAS,SAAS,WAAW;AAC/B,eAAO,QAAQ,QAAQ,QAAQ,OAAO,CAAC;AAAA,MACzC;AACA,aAAO,QAAQ,QAAQ,OAAO,OAAO,CAAC;AAAA,IACxC;AAAA,IACA,GAAG;AAAA,EACL,CAAC;AACD,SAAO;AACT;AACA,IAAM,UAAUA,eAAc;;;ACjE9B,IAAM,SAAS,QAAQ,OAAO,EAAE,OAAO,UAAU,MAAM,CAAC,EAAE,QAAQ,WAAW;AAE7E,IAAO,iBAAQ;;;ACNf,sBAAuB;AAEhB,IAAM,yBAAyB,CAAC,YACtC,IAAI,uBAAO,UAAU,SAAS;;;ACE/B,IAAAC,mBAAuB;AAEvB,IAAqB,iBAArB,MAAoC;AAAA,EACnC,YACS,YACA,kBACP;AAFO;AACA;AAER,mBAAO,MAAM,8BAA8B;AAAA,EAC5C;AAAA,EAEA,MAAc,oBAAoB;AACjC,QAAI,MAAM,KAAK,WAAW,qBAAqB,GAAG;AACjD,YAAM,KAAK,sBAAsB;AAAA,IAClC,OAAO;AACN,qBAAO,KAAK,+CAA+C;AAC3D,UAAI;AACH,cAAM,KAAK,WAAW,gBAAgB;AACtC,YAAI;AACH,gBAAM,KAAK,WAAW,QAAQ;AAAA,QAC/B,SAAQ,GAAN;AAGD,yBAAO,MAAM,cAAc;AAAA,QAC5B;AAAA,MACD,SAAS,OAAP;AACD,uBAAO,KAAK,gCAAgC;AAC5C,YAAI;AACH,gBAAM,KAAK,WAAW,QAAQ;AAC9B,gBAAM,KAAK,WAAW,gBAAgB;AAItC,yBAAO,QAAQ,0BAA0B;AAAA,QAC1C,SAAQ,GAAN;AACD,iCAAuB,4BAA4B;AAEnD,yBAAO,MAAM,2BAA2B;AAAA,QACzC;AAAA,MACD;AAAA,IACD;AAEA,QAAI,MAAM,KAAK,WAAW,aAAa,GAAG;AACzC,YAAM,KAAK,iBAAiB;AAAA,IAC7B;AAAA,EACD;AAAA,EAEA,MAAc,mBAAmB;AAChC,QAAI;AACH,YAAM,KAAK,WAAW,QAAQ;AAE9B,WAAK,sBAAsB;AAAA,IAC5B,SAAQ,GAAN;AACD,qBAAO,KAAK,4CAA4C;AACxD,qBAAO,KAAK,4BAA4B;AAExC,UAAI;AACH,cAAM,KAAK,WAAW,kBAAkB;AACxC,cAAM,KAAK,WAAW,QAAQ;AAE9B,aAAK,sBAAsB;AAE3B,uBAAO,QAAQ,qBAAqB;AAAA,MACrC,SAAQC,IAAN;AACD,aAAK,yBAAyB;AAE9B,uBAAO,MAAM,4BAA4B;AAAA,MAC1C;AAAA,IACD;AAAA,EACD;AAAA,EAEA,MAAc,wBAAwB;AACrC,mBAAO,KAAK,4CAA4C;AAExD,UAAM,KAAK,WAAW,YAAY;AAClC,UAAM,KAAK,WAAW,UAAU;AAAA,EACjC;AAAA,EAEQ,wBAAwB;AAC/B,QAAI,wBAAO,+BAA+B;AAAA,EAC3C;AAAA,EAEQ,2BAA2B;AAClC,QAAI;AAAA,MACH;AAAA,IACD;AACA,QAAI;AAAA,MACH;AAAA,IACD;AAAA,EACD;AAAA,EAEA,MAAM,OAAO;AACZ,QAAI,MAAM,KAAK,WAAW,OAAO,GAAG;AACnC,qBAAO,MAAM,2CAA2C;AAAA,IACzD,OAAO;AACN,qBAAO,MAAM,+CAA+C;AAC5D,6BAAuB,gCAAgC;AACvD;AAAA,IACD;AAEA,QAAI,MAAM,KAAK,WAAW,mBAAmB,GAAG;AAC/C,qBAAO,MAAM,kCAAkC;AAAA,IAChD,OAAO;AACN,qBAAO,MAAM,sCAAsC;AACnD,6BAAuB,sCAAsC;AAC7D;AAAA,IACD;AAEA,QAAI,MAAM,KAAK,WAAW,WAAW,GAAG;AACvC,qBAAO,MAAM,8BAA8B;AAE3C,YAAM,KAAK,WAAW,aAAa;AAAA,IACpC;AAEA,UAAM,KAAK,kBAAkB;AAAA,EAC9B;AACD;;;ACrHA,mBAAkB;;;AKHlB,yBAAA;AkBAA,mBAAA;AEAA,2BAAA;AgCCA,8BAAA;A4BDA,IAAAC,2BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ApFEO,SAAA,YAAqB,OAAiB;AAC1C,QAAM,MAAM,IAAI,OAAO,KAAA;AACvB,QAAM,IAAI,KAAK,KAAA;AAEf,SAAO;AAAA;AAGH,SAAA,WAAoB,MAAwC;AAChE,SAAO,gBAAgB,UAAU,MAAM,IAAI,IAAA;AAAA;AAGvC,SAAA,QAAiB,UAA4B;AACjD,SAAO,MAAM,IAAI,QAAA,KAAa,CAAA;AAAA;AAdjC,IAAM;AAAN,IAAA,gBAAA,MAAA;EAAA,6BAAA;AAAM,YAAQ,oBAAI,QAAA;EAAA;AAAA,CAAA;ACAlB,IA2BO;AA3BP,IAAA,iBAAA,MAAA;EAAA,gCAAA;AA2BO,eAAA,cAAuB,MAAM;MACjC,YACU,MACP,SACD;AACC,cAAM,OAAA;AAHC,aAAA,OAAA;AAIP,eAAO,eAAe,MAAM,WAAW,SAAA;MAAA;IAAA;EAAA;AAAA,CAAA;ACjC7C,IAsBO;AAtBP,IAAA,0BAAA,MAAA;EAAA,yCAAA;AAAA,mBAAA;AAsBO,uBAAA,cAAwC,SAAS;MACrD,YAImB,KAChB,SACD;AACC,cAAM,QAAW,WAAW,OAAO,GAAA,CAAA;AAHnB,aAAA,MAAA;MAAA;IAAA;EAAA;AAAA,CAAA;AC3BtB,IAUO;AAVP,IAAA,gCAAA,MAAA;EAAA,+CAAA;AAAA,mBAAA;AAUO,6BAAA,cAAqC,SAAS;MAClD,YAAY,SAAkB;AAC3B,cAAM,QAAW,OAAA;MAAA;IAAA;EAAA;AAAA,CAAA;ACDhB,SAAA,WAAyC,QAAoB;AACjE,SAAO,OAAO,WAAW,aAAa,SAAS;AAAA;AAO3C,SAAA,eAA4C,QAA8B;AAC9E,SAAO,OAAO,WAAW,cAAc,WAAW;AAAA;AAG9C,SAAA,QAAiB,OAAe,MAAgC;AACpE,QAAM,QAAQ,MAAM,QAAQ,IAAA;AAC5B,MAAI,SAAS,GAAG;AACb,WAAO,CAAC,OAAO,EAAA;EAAA;AAGlB,SAAO,CAAC,MAAM,OAAO,GAAG,KAAA,GAAQ,MAAM,OAAO,QAAQ,CAAA,CAAA;AAAA;AAKjD,SAAA,MAAe,OAA2B,SAAS,GAAmB;AAC1E,SAAO,YAAY,KAAA,KAAU,MAAM,SAAS,SAAS,MAAM,MAAA,IAAU;AAAA;AAMjE,SAAA,KAAc,OAAgB,SAAS,GAAG;AAC9C,MAAI,YAAY,KAAA,KAAU,MAAM,SAAS,QAAQ;AAC9C,WAAO,MAAM,MAAM,SAAS,IAAI,MAAA;EAAA;AAAA;AAMtC,SAAA,YAAqB,OAAgC;AAClD,SAAO,CAAC,EAAE,SAAS,OAAO,MAAM,WAAW;AAAA;AAGvC,SAAA,mBAA4B,QAAQ,IAAI,WAAU,MAAM,YAAY,MAAgB;AACxF,SAAO,MAAM,MAAM,SAAA,EAAW,OAAO,CAAC,QAAQ,SAAS;AACpD,UAAM,cAAc,WAAU,KAAK,KAAA,IAAS;AAC5C,QAAI,aAAa;AACd,aAAO,KAAK,WAAA;IAAA;AAEf,WAAO;EAAA,GACP,CAAA,CAAA;AAAA;AAKC,SAAA,uBACJ,OACA,UACI;AACJ,SAAO,mBAAmB,OAAO,IAAA,EAAM,IAAI,CAAC,SAAS,SAAS,IAAA,CAAA;AAAA;AAG1D,SAAA,aAAsB,MAAuB;AACjD,aAAO,2BAAO,MAAM,yBAAA;AAAA;AAMhB,SAAA,OAAmB,QAAsB,MAAsB;AACnE,MAAI,MAAM,QAAQ,MAAA,GAAS;AACxB,QAAI,CAAC,OAAO,SAAS,IAAA,GAAO;AACzB,aAAO,KAAK,IAAA;IAAA;EAAA,OAEX;AACJ,WAAO,IAAI,IAAA;EAAA;AAEd,SAAO;AAAA;AAMH,SAAA,UAAsB,QAAa,MAAwB;AAC/D,MAAI,MAAM,QAAQ,MAAA,KAAW,CAAC,OAAO,SAAS,IAAA,GAAO;AAClD,WAAO,KAAK,IAAA;EAAA;AAGf,SAAO;AAAA;AAGH,SAAA,OAAmB,QAAsB,MAAY;AACzD,MAAI,MAAM,QAAQ,MAAA,GAAS;AACxB,UAAM,QAAQ,OAAO,QAAQ,IAAA;AAC7B,QAAI,SAAS,GAAG;AACb,aAAO,OAAO,OAAO,CAAA;IAAA;EAAA,OAEpB;AACJ,WAAO,OAAO,IAAA;EAAA;AAEjB,SAAO;AAAA;AAOH,SAAA,QAAoB,QAAsB;AAC9C,SAAO,MAAM,QAAQ,MAAA,IAAU,SAAS,CAAC,MAAA;AAAA;AAGrC,SAAA,cAA0B,QAA2B;AACzD,SAAO,QAAQ,MAAA,EAAQ,IAAI,MAAA;AAAA;AAGvB,SAAA,SAAkB,QAAmC,QAAQ,GAAG;AACpE,MAAI,UAAU,MAAM;AACjB,WAAO;EAAA;AAGV,QAAM,MAAM,SAAS,QAAQ,EAAA;AAC7B,SAAO,MAAM,GAAA,IAAO,QAAQ;AAAA;AAGxB,SAAA,cAA0B,OAAY,QAAgB;AAC1D,QAAM,SAAc,CAAA;AACpB,WAAS,IAAI,GAAG,MAAM,MAAM,QAAQ,IAAI,KAAK,KAAK;AAC/C,WAAO,KAAK,QAAQ,MAAM,CAAA,CAAA;EAAA;AAE7B,SAAO;AAAA;AAGH,SAAA,eAAwB,OAAkC;AAC9D,UAAQ,MAAM,QAAQ,KAAA,IAAS,OAAO,OAAO,KAAA,IAAS,OAAO,SAAS,OAAA;AAAA;AAMlE,SAAA,KAAc,QAA6B,YAAsB;AACrE,SAAO,OAAO,OACX,CAAA,GACA,GAAG,WAAW,IAAI,CAAC,aAAc,YAAY,SAAS,EAAA,CAAG,QAAA,GAAW,OAAO,QAAA,EAAA,IAAc,CAAA,CAAA,CAAA;AAAA;AAIxF,SAAA,MAAe,WAAW,GAAkB;AAChD,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW,MAAM,QAAA,CAAA;AAAA;AAG1C,SAAA,OAAmB,OAAkB;AACzC,MAAI,UAAU,OAAO;AAClB,WAAO;EAAA;AAEV,SAAO;AAAA;AApKV,IAGa;AAHb,IAKa;AALb,IAiHa;AAjHb,IAAA,YAAA,MAAA;EAAA,0BAAA;AAGa,WAAO;AAEP,WAAiC,MAAM;IAAA;AA4GvC,qBAAiB,OAAO,UAAU,SAAS,KAAK,KAAK,OAAO,UAAU,QAAA;EAAA;AAAA,CAAA;ACpG5E,SAAA,WAA0B,OAAU,QAAoC,KAAmB;AAC/F,MAAI,OAAO,KAAA,GAAQ;AAChB,WAAO;EAAA;AAEV,SAAO,UAAU,SAAS,IAAI,MAAM;AAAA;AAOhC,SAAA,iBACJ,OACA,MACoB;AACpB,QAAM,OAAO,WAAW,KAAA,IAAS,WAAW,OAAO;AAEnD,SACG,wBAAwB,KAAK,IAAA,MAC5B,CAAC,QAAQ,CAAC,KAAK,SAAS,IAAA;AAAA;AAmBxB,SAAA,kBAA6C,OAAgC;AACjF,SAAO,CAAC,CAAC,SAAS,eAAe,KAAA,MAAW;AAAA;AAGxC,SAAA,eAAwB,OAAmC;AAC/D,SAAO,OAAO,UAAU;AAAA;AAxD3B,IAoBa;AApBb,IAoCa;AApCb,IAwCa;AAxCb,IA4Ca;AA5Cb,IA2Da;AA3Db,IAAA,wBAAA,MAAA;EAAA,sCAAA;AACA,cAAA;AACA,kBAAA;AAkBa,kBAAmD,CAAC,UAA+B;AAC7F,aAAO,MAAM,QAAQ,KAAA;IAAA;AAeX,mBAAgD,CAAC,UAA2B;AACtF,aAAO,OAAO,UAAU;IAAA;AAGd,wBAAuD,CAAC,UAA6B;AAC/F,aAAO,MAAM,QAAQ,KAAA,KAAU,MAAM,MAAM,YAAA;IAAA;AAGjC,gCAAwE,CAClF,UAC8B;AAC9B,aAAO,aAAa,KAAA,KAAW,MAAM,QAAQ,KAAA,KAAU,MAAM,MAAM,YAAA;IAAA;AAYzD,sBAA+D,CACzE,UAC+B;AAC/B,UAAI,SAAS,QAAQ,0BAA0B,SAAS,OAAO,KAAA,GAAQ;AACpE,eAAO;MAAA;AAEV,aAAO,MAAM,QAAQ,KAAA,KAAU,OAAO,UAAU,YAAY,OAAO,MAAM,WAAW;IAAA;EAAA;AAAA,CAAA;ACjEvF,IAIY;AAJZ,IAAA,kBAAA,MAAA;EAAA,gCAAA;AAIY,gBAAL,kBAAK,eAAL;AACJ,iBAAA,WAAA,SAAA,IAAA,CAAA,IAAA;AACA,iBAAA,WAAA,OAAA,IAAA,CAAA,IAAA;AACA,iBAAA,WAAA,WAAA,IAAY,EAAA,IAAZ;AACA,iBAAA,WAAA,SAAA,IAAU,GAAA,IAAV;AAJS,aAAA;IAAA,GAAA,aAAA,CAAA,CAAA;EAAA;AAAA,CAAA;ACJZ,IAEO;AAFP,IAAA,0BAAA,MAAA;EAAA,wCAAA;AAEO,uBAAA,MAA8D;MAClE,YACmB,QACA,QACjB;AAFiB,aAAA,SAAA;AACA,aAAA,SAAA;MAAA;MAGnB,YAAsC;AACnC,eAAO,IAAI,iBAAiB,KAAK,OAAO,SAAS,MAAA,GAAS,KAAK,OAAO,SAAS,MAAA,CAAA;MAAA;IAAA;EAAA;AAAA,CAAA;ACTrF,IAAO;AAAP,IAoDO;AApDP,IAAA,mBAAA,MAAA;EAAA,iCAAA;AAAO,iBAAA,MAAoB;MAKxB,YACG,QACA,YACD;AAPQ,aAAA,UAAoB,CAAA;AAc9B,aAAA,QAAQ,CAAC,MAA8C,WAAuB;AAC3E,eAAK,aAAA;AAEL,cAAI,CAAC,KAAK,QAAQ,MAAM,CAAC,KAAK,UAAU,KAAK,SAAS,KAAK,OAAO,KAAK,KAAA,CAAA,CAAA,GAAU;AAC9E,mBAAO;UAAA;AAGV,iBAAO,KAAK,WAAW,QAAQ,KAAK,eAAA,CAAA,MAAsB;QAAA;AAb1D,aAAK,UAAU,MAAM,QAAQ,MAAA,IAAU,SAAS,CAAC,MAAA;AACjD,YAAI,YAAY;AACb,eAAK,aAAa;QAAA;MAAA;MAed,WAAW,QAAW,OAAiC;AAC9D,cAAM,IAAI,MAAM,uCAAA;MAAA;MAGT,eAAe;AACtB,aAAK,QAAQ,SAAS;MAAA;MAGf,iBAAiB;AACxB,eAAO,KAAK;MAAA;MAGL,SAAS,KAAa,OAAe,MAAe;AAC3D,cAAM,UAAU,QAAQ,IAAI,KAAK,IAAA;AACjC,YAAI,SAAS;AACV,eAAK,UAAU,OAAO,OAAA;QAAA;AAGzB,eAAO,CAAC,CAAC;MAAA;MAGF,UAAU,QAAgB,SAAmB;AACpD,aAAK,QAAQ,KAAK,GAAG,QAAQ,MAAM,CAAA,CAAA;MAAA;IAAA;AAIlC,uBAAA,cAAkC,WAAc;MAC1C,SAAS,KAAa,OAAe,MAAwB;AACpE,eAAO,aAAa,KAAK,OAAO,IAAA,CAAA,KAAU,MAAM,SAAS,KAAK,OAAO,IAAA;MAAA;MAG9D,UAAU,OAAe,SAAmB;AACnD,YAAI,QAAQ,KAAK,QAAQ,SAAS,GAAG;AAClC,gBAAM,UAAU,OAAO,OAAA;QAAA;MAAA;IAAA;EAAA;AAAA,CAAA;AClDzB,SAAA,wBACD,SACc;AACjB,QAAM,UAAU,QAAQ,IAAA;AACxB,QAAM,SAA2B,OAAO,OACrC,eAAA,EAAE,QAAA,GAAY,cAAA,GACd,GAAG,QAAQ,OAAO,CAAC,MAAM,OAAO,MAAM,YAAY,CAAA,CAAA;AAGrD,SAAO,UAAU,OAAO,WAAW;AACnC,SAAO,UAAU,OAAO,YAAY;AAEpC,SAAO;AAAA;AArBV,IAEM;AAFN,IAAA,0BAAA,MAAA;EAAA,wCAAA;AAEM,qBAAoD;MACvD,QAAQ;MACR,wBAAwB;MACxB,QAAQ,CAAA;MACR,SAAS;IAAA;EAAA;AAAA,CAAA;ACKL,SAAA,kBACJ,SACA,WAAqB,CAAA,GACZ;AACT,MAAI,CAAC,kBAA2B,OAAA,GAAU;AACvC,WAAO;EAAA;AAGV,SAAO,OAAO,KAAK,OAAA,EAAS,OAAO,CAAC,WAAoB,QAAgB;AACrE,UAAM,QAAuB,QAAQ,GAAA;AAErC,QAAI,WAAW,KAAA,GAAQ;AACpB,gBAAS,KAAK,KAAA;IAAA,WACN,iBAAiB,OAAO,CAAC,SAAA,CAAA,GAAa;AAC9C,gBAAS,KAAK,MAAM,MAAM,KAAA;IAAA,OACtB;AACJ,gBAAS,KAAK,GAAA;IAAA;AAGjB,WAAO;EAAA,GACP,QAAA;AAAA;AAGC,SAAA,mBACJ,MACA,mBAAmB,GACnB,aAAa,OACJ;AACT,QAAM,UAAoB,CAAA;AAE1B,WAAS,IAAI,GAAG,MAAM,mBAAmB,IAAI,KAAK,SAAS,kBAAkB,IAAI,KAAK,KAAK;AACxF,QAAI,gBAAgB,SAAS,OAAO,KAAK,CAAA,CAAA,GAAK;AAC3C,cAAQ,KAAK,OAAO,KAAK,CAAA,CAAA,CAAA;IAAA;EAAA;AAI/B,oBAAkB,wBAAwB,IAAA,GAAO,OAAA;AACjD,MAAI,CAAC,YAAY;AACd,YAAQ,KAAK,GAAG,sBAAsB,IAAA,CAAA;EAAA;AAGzC,SAAO;AAAA;AAGV,SAAA,sBAA+B,MAAkB;AAC9C,QAAM,sBAAsB,OAAO,KAAK,IAAA,MAAU;AAClD,SAAO,WAAW,KAAK,MAAM,sBAAsB,IAAI,CAAA,GAAI,aAAa,CAAA,CAAA;AAAA;AAOpE,SAAA,wBAAiC,MAAkC;AACvE,QAAM,sBAAsB,eAAe,KAAK,IAAA,CAAA;AAChD,SAAO,WAAW,KAAK,MAAM,sBAAsB,IAAI,CAAA,GAAI,iBAAA;AAAA;AAOvD,SAAA,yBACJ,MACA,cAAc,MACqB;AACnC,QAAM,WAAW,WAAW,KAAK,IAAA,CAAA;AACjC,SAAO,eAAe,eAAe,QAAA,IAAY,WAAW;AAAA;AA9E/D,IAAA,oBAAA,MAAA;EAAA,kCAAA;AAAA,0BAAA;AAOA,cAAA;AAEA,kBAAA;EAAA;AAAA,CAAA;ACJO,SAAA,eACJ,SACA,SACD;AACC,SAAO,QAAO,QAAQ,QAAQ,QAAQ,MAAA;AAAA;AAGlC,SAAA,oBACJ,QACA,WACA,OACA,OAAO,MACL;AACF,UAAQ,KAAA,EAAO,QAAQ,CAAC,SAAS;AAC9B,aAAS,QAAQ,mBAAmB,MAAM,IAAA,GAAO,IAAI,GAAG,MAAM,MAAM,QAAQ,IAAI,KAAK,KAAK;AACvF,YAAM,OAAO,CAAC,SAAS,MAAM;AAC1B,YAAI,IAAI,UAAU,KAAK;AACpB;QAAA;AAEH,eAAO,MAAM,IAAI,MAAA;MAAA;AAGpB,gBAAQ,KAAK,CAAC,EAAE,MAAA,MAAY,MAAM,MAAM,MAAA,CAAA;IAAA;EAAA,CAAA;AAI9C,SAAO;AAAA;AA/BV,IAAA,mBAAA,MAAA;EAAA,iCAAA;AAGA,cAAA;EAAA;AAAA,CAAA;ACHA,IAAA,gBAAA,CAAA;AAAAC,UAAA,eAAA;EAAA,WAAA,MAAA;EAAA,kBAAA,MAAA;EAAA,YAAA,MAAA;EAAA,MAAA,MAAA;EAAA,MAAA,MAAA;EAAA,kBAAA,MAAA;EAAA,QAAA,MAAA;EAAA,mBAAA,MAAA;EAAA,SAAA,MAAA;EAAA,YAAA,MAAA;EAAA,UAAA,MAAA;EAAA,eAAA,MAAA;EAAA,gBAAA,MAAA;EAAA,gBAAA,MAAA;EAAA,sBAAA,MAAA;EAAA,OAAA,MAAA;EAAA,aAAA,MAAA;EAAA,gBAAA,MAAA;EAAA,iBAAA,MAAA;EAAA,mBAAA,MAAA;EAAA,kBAAA,MAAA;EAAA,cAAA,MAAA;EAAA,mBAAA,MAAA;EAAA,2BAAA,MAAA;EAAA,YAAA,MAAA;EAAA,OAAA,MAAA;EAAA,cAAA,MAAA;EAAA,wBAAA,MAAA;EAAA,oBAAA,MAAA;EAAA,WAAA,MAAA;EAAA,gBAAA,MAAA;EAAA,MAAA,MAAA;EAAA,gBAAA,MAAA;EAAA,QAAA,MAAA;EAAA,qBAAA,MAAA;EAAA,MAAA,MAAA;EAAA,eAAA,MAAA;EAAA,QAAA,MAAA;EAAA,SAAA,MAAA;EAAA,oBAAA,MAAA;EAAA,0BAAA,MAAA;EAAA,yBAAA,MAAA;AAAA,CAAA;AAAA,IAAA,aAAA,MAAA;EAAA,2BAAA;AAAA,0BAAA;AACA,oBAAA;AACA,4BAAA;AACA,qBAAA;AACA,4BAAA;AACA,sBAAA;AACA,qBAAA;AACA,cAAA;EAAA;AAAA,CAAA;ACPA,IAAA,wBAAA,CAAA;AAAAA,UAAA,uBAAA;EAAA,kBAAA,MAAA;EAAA,qBAAA,MAAA;EAAA,qBAAA,MAAA;EAAA,iBAAA,MAAA;AAAA,CAAA;AAqBO,SAAA,gBAAyB,QAAsD;AACnF,UAAQ,QAAA;IAAA,KACA;AACF,aAAO,oBAAA;IAAA,KACL;AACF,aAAO,oBAAA;EAAA;AAGb,QAAM,WAAW,CAAC,aAAa,uBAAA;AAE/B,SAAO;IACJ;IACA,QAAQ;IACR;IACA;EAAA;AAAA;AAIC,SAAA,sBAAoD;AACxD,QAAM,WAAW,CAAC,aAAa,WAAA;AAE/B,SAAO;IACJ;IACA,QAAQ;IACR;IACA,OAAO,MAAM;AACV,aAAO,aAAa,KAAK,KAAK,KAAA,CAAA;IAAA;EAAA;AAAA;AAKhC,SAAA,sBAAoD;AACxD,QAAM,WAAW,CAAC,aAAa,sBAAA;AAE/B,SAAO;IACJ;IACA,QAAQ;IACR;IACA;EAAA;AAAA;AAIN,SAAA,iBAA0B,OAAuB;AAC9C,SAAO,8CAA8C,KAAK,OAAO,KAAA,CAAA;AAAA;AAhEpE,IAGY;AAHZ,IASM;AATN,IAiBM;AAjBN,IAAA,qBAAA,MAAA;EAAA,mCAAA;AAAA,eAAA;AAGY,uBAAL,kBAAK,sBAAL;AACJ,wBAAA,MAAA,IAAO;AACP,wBAAA,SAAA,IAAU;AACV,wBAAA,cAAA,IAAe;AAHN,aAAA;IAAA,GAAA,oBAAA,CAAA,CAAA;AAMN,cAA0C,CAAC,EAAE,SAAA,GAAY,OAAO,MAAM,SAAS;AAClF,UAAI,aAAa,OAAqB,iBAAiB,KAAA,GAAQ;AAC5D,eAAO,KAAK,OAAO,KAAK,OAAA,CAAA;MAAA;AAG3B,WAAK,KAAA;IAAA;AAGF,aAAwC,CAAC,SAAS;AACrD,aAAO,KAAK,KAAA,MAAW;IAAA;EAAA;AAAA,CAAA;ACHnB,SAAA,mBAA4B,QAAiB,MAA4B;AAC7E,QAAM,UAAU,IAAI,cAAc,MAAA;AAClC,QAAM,SAAS,SAAS,sBAAsB;AAE9C,qBAAmB,IAAA,EAAM,QAAQ,CAAC,SAAS;AACxC,UAAM,UAAU,KAAK,QAAQ,QAAQ,EAAA;AAErC,YAAQ,MAAM,KAAK,OAAA;AAClB,KAAA,eAAe,KAAK,OAAA,IAAW,QAAQ,UAAU,QAAQ,OAAO,KAAK,OAAA;EAAA,CAAA;AAGzE,SAAO;AAAA;AA1BV,IAGO;AAHP,IAWM;AAXN,IAYM;AAZN,IAaM;AAbN,IAAA,oBAAA,MAAA;EAAA,sCAAA;AACA,eAAA;AAEO,oBAAA,MAA4C;MAKhD,YAA4B,QAAiB;AAAjB,aAAA,SAAA;AAJrB,aAAA,QAAkB,CAAA;AAClB,aAAA,QAAkB,CAAA;AAClB,aAAA,UAAoB,CAAA;MAAA;IAAA;AAKxB,oBAAgB;AAChB,0BAAsB;AACtB,qBAAiB;EAAA;AAAA,CAAA;ACbvB,IAAA,eAAA,CAAA;AAAAA,UAAA,cAAA;EAAA,gBAAA,MAAA;EAAA,eAAA,MAAA;EAAA,wBAAA,MAAA;EAAA,cAAA,MAAA;EAAA,aAAA,MAAA;EAAA,2BAAA,MAAA;EAAA,2BAAA,MAAA;AAAA,CAAA;AAYO,SAAA,cAAuB,SAAoC;AAC/D,SAAO;IACJ,UAAU;IACV,QAAQ;IACR,QAAA;EAAA;AAAA;AAIC,SAAA,uBAAgC,OAAkC;AACtE,SAAO;IACJ,UAAU;IACV,QAAQ;IACR,SAAS;AACN,YAAM,OAAO,UAAU,WAAW,IAAI,uBAAuB,KAAA,IAAS;IAAA;EAAA;AAAA;AAKxE,SAAA,0BAAmC,UAAoB,WAAU,OAA2B;AAChG,SAAO;IACJ;IACA,QAAQ;IACR,OAAO,MAAM;AACV,aAAO,WAAU,OAAO,IAAA,EAAM,KAAA,IAAS;IAAA;EAAA;AAAA;AAKzC,SAAA,0BAAmC,UAAqC;AAC5E,SAAO;IACJ;IACA,QAAQ;IACR,OAAO,QAAQ;AACZ,aAAO;IAAA;EAAA;AAAA;AAKT,SAAA,aAAyB,MAA+C;AAC5E,SAAO,KAAK,WAAW;AAAA;AAGnB,SAAA,YAAwB,MAA2C;AACvE,SAAO,KAAK,WAAW,WAAW,CAAC,KAAK,SAAS;AAAA;AAvDpD,IAGa;AAHb,IAAA,YAAA,MAAA;EAAA,0BAAA;AAAA,kCAAA;AAGa,qBAAqB,CAAA;EAAA;AAAA,CAAA;ACHlC,IAAA,gBAAA,CAAA;AAAAA,UAAA,eAAA;EAAA,+BAAA,MAAA;EAAA,4BAAA,MAAA;EAAA,6BAAA,MAAA;EAAA,cAAA,MAAA;EAAA,WAAA,MAAA;EAAA,sBAAA,MAAA;EAAA,qBAAA,MAAA;AAAA,CAAA;AAkCO,SAAA,qBAA8B,MAA0B,YAAsB;AAClF,QAAM,EAAE,WAAW,SAAS,MAAA,IAAU,gBAAgB,IAAA;AAEtD,MAAI,CAAC,WAAW;AACb,WAAO,uBAAuB,0BAAA;EAAA;AAGjC,MAAI,CAAC,MAAM,SAAS;AACjB,WAAO,uBAAuB,8BAA8B,KAAK,UAAU,IAAA,CAAA;EAAA;AAG9E,UAAQ,KAAK,GAAG,UAAA;AAEhB,MAAI,QAAQ,KAAK,iBAAA,GAAoB;AAClC,WAAO,uBAAuB,6BAAA;EAAA;AAGjC,SAAO,UAAU,WAAW,OAAA;AAAA;AAGxB,SAAA,UAAmB,MAAiB,YAAgD;AACxF,QAAM,WAAqB,CAAC,SAAS,IAAI,QAAQ,GAAG,UAAA;AAEpD,SAAO;IACJ;IACA,QAAQ;IACR,OAAO,MAA4B;AAChC,aAAO,mBAAmB,SAAS,KAAsB,IAAA;IAAA;EAAA;AAAA;AAK3D,SAAA,oBAA6B,OAA0C;AAC3E,SAAO,MAAM,QAAQ,KAAA,KAAU,MAAM,MAAM,CAAC,SAAS,kBAAkB,IAAI,IAAA,CAAA;AAAA;AAG9E,SAAA,gBAAyB,OAAe;AACrC,MAAI;AACJ,MAAI,UAAoB,CAAA;AACxB,MAAI,QAAQ,EAAE,WAAW,OAAO,SAAS,KAAA;AAEzC,QACI,QAAQ,YAAY,EAAA,EACpB,MAAM,EAAA,EACN,QAAQ,CAAC,SAAS;AAChB,QAAI,YAAY,IAAA,GAAO;AACpB,kBAAY;AACZ,YAAM,YAAY;IAAA,OACd;AACJ,YAAM,UAAU,MAAM,WAAW,cAAe,QAAQ,QAAQ,MAAA,IAAU,IAAI,MAAA;IAAA;EAAA,CAAA;AAIvF,SAAO;IACJ;IACA;IACA;EAAA;AAAA;AAIN,SAAA,YAAqB,WAA4C;AAC9D,SAAO,cAAc,OAAsB,cAAc;AAAA;AAG5D,SAAA,cAAuB,QAAyB;AAC7C,SAAO,YAAY,KAAK,MAAA,KAAW,kBAAkB,IAAI,OAAO,OAAO,CAAA,CAAA;AAAA;AAG1E,SAAA,kBAA2B,QAAyB;AACjD,MAAI,UAAU,KAAK,MAAA,GAAS;AACzB,WAAO,OAAO,QAAQ,GAAA,IAAO;EAAA;AAGhC,SAAO,WAAW;AAAA;AA3GrB,IAMa;AANb,IAOa;AAPb,IAQa;AARb,IAaY;AAbZ,IA6BM;AA7BN,IAAA,aAAA,MAAA;EAAA,2BAAA;AACA,sBAAA;AAEA,eAAA;AACA,cAAA;AAEa,oCAAgC;AAChC,iCAA6B;AAC7B,kCAA8B;AAK/B,mBAAL,kBAAK,kBAAL;AACJ,oBAAA,SAAA,IAAU;AACV,oBAAA,OAAA,IAAQ;AACR,oBAAA,kBAAA,IAAmB;AACnB,oBAAA,cAAA,IAAe;AACf,oBAAA,WAAA,IAAY;AACZ,oBAAA,OAAA,IAAQ;AACR,oBAAA,WAAA,IAAY;AAPH,aAAA;IAAA,GAAA,gBAAA,CAAA,CAAA;AAgBN,wBAAiC,oBAAI,IAAI;MAC5C;MACA,GAAG,cAAc,OAAO,OAAO,YAAA,CAAA;IAAA,CAAA;EAAA;AAAA,CAAA;ACc3B,SAAA,iBAA0B,MAA0B;AACxD,QAAM,SAAS,IAAI,WAAA;AAEnB,aAAW,QAAQ,aAAa,IAAA,GAAO;AACpC,WAAO,SAAS,KAAK,MAAM,OAAO,KAAK,GAAA,GAAM,KAAK,KAAA;EAAA;AAGrD,SAAO;AAAA;AAGH,SAAA,gBAAyB,MAAc,KAA8B;AACzE,MAAI,QAAuB;AAC3B,QAAM,SAAmB,CAAA;AACzB,QAAM,SAAgC,oBAAI,IAAA;AAE1C,aAAW,QAAQ,aAAa,MAAM,GAAA,GAAM;AACzC,QAAI,KAAK,QAAQ,KAAK;AACnB;IAAA;AAGH,WAAO,KAAM,QAAQ,KAAK,KAAA;AAE1B,QAAI,CAAC,OAAO,IAAI,KAAK,IAAA,GAAO;AACzB,aAAO,IAAI,KAAK,MAAM,CAAA,CAAA;IAAA;AAGzB,WAAO,IAAI,KAAK,IAAA,EAAO,KAAK,KAAA;EAAA;AAG/B,SAAO;IACJ;IACA,OAAO,MAAM,KAAK,OAAO,KAAA,CAAA;IACzB;IACA;IACA;EAAA;AAAA;AAIN,SAAA,eAAwB,UAA0B;AAC/C,SAAO,SAAS,QAAQ,YAAY,EAAA;AAAA;AAGvC,UAAA,aAAuB,MAAc,eAA8B,MAAM;AACtE,QAAM,QAAQ,KAAK,MAAM,IAAA;AAEzB,WAAS,IAAI,GAAG,MAAM,MAAM,SAAS,GAAG,IAAI,OAAO;AAChD,UAAM,OAAO,eAAe,MAAM,GAAA,CAAA;AAElC,QAAI,QAAQ,MAAM,GAAA;AAClB,QAAI,MAAM;AAEV,QAAI,MAAM,SAAS,IAAA,GAAO;AACvB,YAAM,OAAO,QAAQ,OAAO,IAAA;AAC5B,YAAM,KAAK,CAAA;AACX,cAAQ,KAAK,CAAA;IAAA;AAGhB,UAAM,EAAE,MAAM,KAAK,MAAA;EAAA;AAAA;AAtGzB,IAGO;AAHP,IAAA,kBAAA,MAAA;EAAA,oCAAA;AACA,eAAA;AAEO,iBAAA,MAA8C;MAA9C,cAHP;AAIU,aAAA,QAAkB,CAAA;AAClB,aAAA,SAA+C,uBAAO,OAAO,IAAA;MAAA;MAAA,IAIzD,MAAoB;AAC5B,YAAI,CAAC,KAAK,MAAM;AACb,eAAK,OAAO,KAAK,MAAM,OAAO,CAAC,KAAmB,SAAiB;AAChE,mBAAO,OAAO,OAAO,KAAK,KAAK,OAAO,IAAA,CAAA;UAAA,GACtC,CAAA,CAAA;QAAA;AAGN,eAAO,KAAK;MAAA;MAGR,QAAQ,MAA4B;AACxC,YAAI,EAAE,QAAQ,KAAK,SAAS;AACzB,gBAAM,SAAS,KAAK,KAAK,KAAA;AACzB,eAAK,OAAO,IAAA,IAAQ,SAAS,OAAO,OAAO,KAAK,OAAO,MAAA,CAAA,IAAW,CAAA;AAElE,eAAK,MAAM,KAAK,IAAA;QAAA;AAGnB,eAAO,KAAK,OAAO,IAAA;MAAA;MAGf,SAAS,MAAc,KAAa,OAAe;AACvD,cAAM,SAAS,KAAK,QAAQ,IAAA;AAE5B,YAAI,CAAC,OAAO,eAAe,GAAA,GAAM;AAC9B,iBAAO,GAAA,IAAO;QAAA,WACN,MAAM,QAAQ,OAAO,GAAA,CAAA,GAAO;AACnC,iBAAO,GAAA,EAAkB,KAAK,KAAA;QAAA,OAC3B;AACJ,iBAAO,GAAA,IAAO,CAAC,OAAO,GAAA,GAAgB,KAAA;QAAA;AAGzC,aAAK,OAAO;MAAA;IAAA;EAAA;AAAA,CAAA;AC5BlB,SAAA,cACG,OACA,UACmB;AACnB,MAAI,OAAO,UAAU,YAAY,eAAe,eAAe,KAAA,GAAQ;AACpE,WAAO;EAAA;AAEV,SAAO;AAAA;AAGV,SAAA,cACG,KACA,OACA,SACA,OACmB;AACnB,QAAM,WAAqB,CAAC,UAAU,KAAK,OAAA;AAE3C,MAAI,SAAQ;AACT,aAAS,KAAK,OAAA;EAAA;AAGjB,WAAS,KAAK,KAAK,KAAA;AAEnB,SAAO;IACJ;IACA,QAAQ;IACR,OAAO,MAAsB;AAC1B,aAAO;IAAA;EAAA;AAAA;AAKhB,SAAA,cAAuB,KAAa,OAAqD;AACtF,QAAM,WAAqB,CAAC,UAAU,UAAU,iBAAiB,aAAa,GAAA;AAE9E,MAAI,OAAO;AACR,aAAS,OAAO,GAAG,GAAG,KAAK,OAAA;EAAA;AAG9B,SAAO;IACJ;IACA,QAAQ;IACR,OAAO,MAAM;AACV,aAAO,gBAAgB,MAAM,GAAA;IAAA;EAAA;AAAA;AAKtC,SAAA,eAAwB,OAAuD;AAC5E,QAAM,WAAW,CAAC,UAAU,UAAU,iBAAiB,QAAA;AAEvD,MAAI,OAAO;AACR,aAAS,KAAK,KAAK,OAAA;EAAA;AAGtB,SAAO;IACJ;IACA,QAAQ;IACR,OAAO,MAAc;AAClB,aAAO,iBAAiB,IAAA;IAAA;EAAA;AAAA;AAKlB,SAAA,iBAAuE;AACnF,SAAO;IACJ,UAA8B,KAAa,UAAkB,MAAiB;AAC3E,aAAO,KAAK,SACT,cACG,KACA,OACA,KAAK,CAAA,MAAO,MACZ;QAAc,KAAK,CAAA;QAAI;;MAAA,CAAA,GAE1B,yBAAyB,SAAA,CAAA;IAAA;IAI/B,UAA8B,KAAa,OAAwB;AAChE,aAAO,KAAK,SACT,cAAc,KAAK,cAAc,OAAO,MAAA,CAAA,GACxC,yBAAyB,SAAA,CAAA;IAAA;IAI/B,cAAkC,MAAiB;AAChD,aAAO,KAAK,SACT,eAAe,cAAc,KAAK,CAAA,GAAI,MAAA,CAAA,GACtC,yBAAyB,SAAA,CAAA;IAAA;EAAA;AAAA;AAtGrC,IAMY;AANZ,IAAA,cAAA,MAAA;EAAA,4BAAA;AACA,oBAAA;AAGA,eAAA;AAEY,qBAAL,kBAAK,oBAAL;AACJ,sBAAA,QAAA,IAAS;AACT,sBAAA,QAAA,IAAS;AACT,sBAAA,OAAA,IAAQ;AACR,sBAAA,UAAA,IAAW;AAJF,aAAA;IAAA,GAAA,kBAAA,CAAA,CAAA;EAAA;AAAA,CAAA;ACQL,SAAA,iBAA0B,OAAwC;AACtE,SAAO,eAAe,IAAI,KAAA;AAAA;AAf7B,IAAY;AAAZ,IAYM;AAZN,IAAA,wBAAA,MAAA;EAAA,sCAAA;AAAY,qBAAL,kBAAK,oBAAL;AACJ,sBAAA,OAAA,IAAQ;AACR,sBAAA,QAAA,IAAS;AACT,sBAAA,SAAA,IAAU;AACV,sBAAA,UAAA,IAAW;AACX,sBAAA,SAAA,IAAU;AACV,sBAAA,SAAA,IAAU;AACV,sBAAA,UAAA,IAAW;AACX,sBAAA,SAAA,IAAU;AACV,sBAAA,QAAA,IAAS;AATA,aAAA;IAAA,GAAA,kBAAA,CAAA,CAAA;AAYN,qBAAiB,IAAI,IAAI,OAAO,OAAO,cAAA,CAAA;EAAA;AAAA,CAAA;ACoCtC,SAAA,oBAA6B,QAAgC;AACjE,SAAO,IAAI,UAAA,EAAY,MAAM,GAAG,MAAA;AAAA;AAGnC,SAAA,UAAmB,MAA0B;AAC1C,QAAM,QAA6B,oBAAI,IAAA;AACvC,QAAM,UAAiC,CAAA;AAEvC,yBAAuB,MAAM,CAAC,UAAU;AACrC,UAAM,CAAC,MAAM,MAAM,OAAA,IAAW,MAAM,MAAM,IAAA;AAC1C,UAAM,IAAI,IAAA;AACT,KAAA,QAAQ,IAAA,IAAQ,QAAQ,IAAA,KAAS,CAAA,GAAI,KAAK;MACxC,MAAM,SAAS,IAAA;MACf;MACA;IAAA,CAAA;EAAA,CAAA;AAIN,SAAO;IACJ;IACA;EAAA;AAAA;AAIS,SAAA,eAAqC;AACjD,SAAO;IACJ,KAAyB,YAAmC;AACzD,YAAM,OAAO,yBAAyB,SAAA;AACtC,YAAM,UAAU,mBAAmB,SAAA;AAEnC,iBAAW,UAAU,mBAAmB;AACrC,YAAI,QAAQ,SAAS,MAAA,GAAS;AAC3B,iBAAO,KAAK,SACT,uBAAuB,qBAAqB,2BAAA,GAC5C,IAAA;QAAA;MAAA;AAKT,UAAI,OAAO,eAAe,UAAU;AACjC,qBAAa,iBAAA,EAAmB,MAAM,UAAA;MAAA;AAGzC,YAAM,WAAW,CAAC,QAAQ,UAAU,MAAM,eAAe,GAAG,SAAS,GAAG,UAAA;AAExE,aAAO,KAAK,SACT;QACG;QACA,QAAQ;QACR,OAAO,QAAQ;AACZ,iBAAO,UAAU,MAAA;QAAA;MAAA,GAGvB,IAAA;IAAA;EAAA;AAAA;AArGZ,IAaM;AAbN,IAeM;AAfN,IAAA;AAAA,IAyBA;AAzBA,IAAA,YAAA,MAAA;EAAA,0BAAA;AAEA,eAAA;AASA,cAAA;AAEM,wBAAoB,CAAC,IAAA;AAErB,YAAQ,OAAO,WAAA;AAUrB,gBAAA,MAAwC;MAAxC,cAzBA;AA0BY,aAAA,EAAA,IAAmB,CAAA;MAAA;MAAA,GAAnB,KAAA,OAEP,OAAO,SAAA,IAAY;AAClB,mBAAW,SAAS,KAAK,KAAA,GAAQ;AAC9B,gBAAM;QAAA;MAAA;MAIZ,OAAO,KAAe;AACnB,YAAI,UAAU,KAAK,KAAA,EAAO,KAAK,SAAS,KAAK,GAAG,cAAc,KAAK,IAAA,GAAO,GAAA;AAC1E,eAAO;MAAA;MAGV,SAAS,OAAiB;AACvB,aAAK,KAAA,EAAO,KAAK,GAAG,cAAc,OAAO,IAAA,CAAA;AACzC,eAAO;MAAA;IAAA;EAAA;AAAA,CAAA;ACzCb,IAAA,gBAAA,CAAA;AAAAA,UAAA,eAAA;EAAA,WAAA,MAAA;EAAA,cAAA,MAAA;EAAA,WAAA,MAAA;AAAA,CAAA;AAiBO,SAAA,UAAmB,MAAwB,YAAsB;AACrE,QAAM,WAAqB,CAAC,OAAA;AAC5B,MAAI,iBAAiB,IAAA,GAAO;AACzB,aAAS,KAAK,KAAK,MAAA;EAAA;AAEtB,WAAS,KAAK,GAAG,UAAA;AAEjB,SAAO,0BAA0B,QAAA;AAAA;AAG7B,SAAA,aAAsB,MAAyC;AACnE,MAAI,iBAAiB,IAAA,GAAO;AACzB,WAAO;EAAA;AAGV,UAAQ,OAAO,MAAA;IAAA,KACP;IAAA,KACA;AACF,aAAO;EAAA;AAGb;AAAA;AAGH,SAAA,iBAA0B,MAA0C;AACjE,SAAO,WAAW,SAAS,IAAA;AAAA;AA1C9B,IAGY;AAHZ,IAWM;AAXN,IAAA,aAAA,MAAA;EAAA,2BAAA;AAAA,cAAA;AAGY,gBAAL,kBAAK,eAAL;AACJ,iBAAA,OAAA,IAAQ;AACR,iBAAA,MAAA,IAAO;AACP,iBAAA,MAAA,IAAO;AACP,iBAAA,OAAA,IAAQ;AACR,iBAAA,MAAA,IAAO;AALE,aAAA;IAAA,GAAA,aAAA,CAAA,CAAA;AAQN,iBAAa,MAAM,KAAK,OAAO,OAAO,SAAA,CAAA;EAAA;AAAA,CAAA;ACW5C,SAAA,YAAqB;AAClB,aAAO,aAAAC,SAAM,YAAA;AAAA;AAWhB,SAAA,eACG,IACA,QACA,SACqB;AACrB,MAAI,CAAC,UAAU,CAAC,OAAO,MAAA,EAAQ,QAAQ,OAAO,EAAA,GAAK;AAChD,WAAO,CAAC,UACH,KACA,CAAC,YAAY,SAAS;AACnB,SAAG,SAAS,GAAG,IAAA;AACf,cAAQ,SAAS,GAAG,IAAA;IAAA;EAAA;AAI/B,SAAO,CAAC,YAAY,SAAS;AAC1B,OAAG,MAAM,WAAW,QAAQ,GAAG,IAAA;AAC/B,QAAI,SAAS;AACV,cAAQ,SAAS,GAAG,IAAA;IAAA;EAAA;AAAA;AAK7B,SAAA,gBACG,MACA,eACA,EAAE,WAAW,gBAAA,GACN;AACP,MAAI,OAAO,SAAS,UAAU;AAC3B,WAAO;EAAA;AAEV,QAAM,iBAAkB,iBAAiB,cAAc,aAAc;AAErE,MAAI,eAAe,WAAW,eAAA,GAAkB;AAC7C,WAAO,eAAe,OAAO,gBAAgB,SAAS,CAAA;EAAA;AAGzD,SAAO,kBAAkB;AAAA;AAGrB,SAAA,aACJ,OACA,SACA,aACA,eAAe,UAAA,GACF;AACb,QAAM,cAAe,SAAS,IAAI,YAAa;AAE/C,QAAM,UAA0B,CAAA;AAChC,QAAM,gBACH,OAAO,YAAY,WAAW,aAAa,OAAO,OAAA,IAAW;AAChE,QAAM,MAAM,gBAAgB,WAAW,SAAS,YAAA,GAAe,eAAe,YAAA;AAE9E,SAAO,KAAK,WAAA;AAEZ,WAAA,QAAiB,MAAc,SAAkB;AAC9C,WAAO,OACJ,SACA,aAAa,OAAO,IAAI,QAAQ,UAAU,IAAA,GAAO,SAAS,YAAA,CAAA;EAAA;AAIhE,WAAA,KAAc,OAAgB;AAC3B,UAAM,aAAc,SAAS,IAAI,YAAa;AAC9C,UAAM,SAAS,iBAAiB,eAAe,eAAe,UAAA,KAAgB;AAC9E,UAAM,OAAO,eAAe,cAAc,GAAG,eAAe,cAAc,MAAA;AAE1E,WAAO,OAAO,OAAO,gBAAgB,SAAQ,MAAM;MAChD;MACA;MACA;MACA;IAAA,CAAA;EAAA;AAAA;AAxGT,IAAA,kBAAA,MAAA;EAAA,0BAAA;AACA,eAAA;AAWA,iBAAAA,QAAM,WAAW,IAAI,CAAC,UAAe,OAAO,gBAAgB,KAAA,IAAS,MAAM,SAAS,GAAA;AACpF,iBAAAA,QAAM,WAAW,IAAI,CAAC,UAAkB;AACrC,UAAI,OAAO,SAAS,KAAA,GAAQ;AACzB,eAAO,MAAM,SAAS,MAAA;MAAA;AAEzB,aAAO,eAAe,KAAA;IAAA;EAAA;AAAA,CAAA;ACjBzB,IAYO;AAZP,IAYO;AAZP,IAAA,2BAAA,MAAA;EAAA,2CAAA;AACA,mBAAA;AACA,oBAAA;AAUO,yBAAA,MAAwB;MAG5B,YAAoB,WAAW,eAAe;AAA1B,aAAA,WAAA;AAFZ,aAAA,SAAgD,oBAAI,IAAA;MAAA;MAIpD,aAAa,MAAwB;AAC1C,eAAO,KAAK,OAAO,IAAI,IAAA;MAAA;MAGlB,eAAe,MAAwC;AAC5D,cAAM,OAAO,mBAAkB,QAAQ,KAAK,SAAS,CAAA,CAAA;AACrD,cAAMC,UAAS,aAAa,KAAK,UAAU,IAAA;AAE3C,eAAO;UACJ;UACA,QAAAA;UACA;QAAA;MAAA;MAIN,KAAK,MAAwC;AAC1C,cAAM,WAAW,KAAK,eAAe,IAAA;AACrC,iBAAS,OAAO,2CAA2C,KAAK,QAAA;AAEhE,aAAK,OAAO,IAAI,MAAM,QAAA;AAEtB,eAAO;MAAA;MAGV,MAAM,KAAe;AAClB,mBAAW,CAAC,MAAM,EAAE,QAAAA,QAAA,CAAA,KAAa,MAAM,KAAK,KAAK,OAAO,QAAA,CAAA,GAAY;AACjE,cAAI,SAAS,IAAI,MAAM;AACpB,YAAAA,QAAO,KAAK,aAAa,GAAA;AACzB,YAAAA,QACG,8FAAA;UAAA,OAEC;AACJ,YAAAA,QAAO,KACJ,gFACA,IAAI,OAAA;UAAA;AAIV,eAAK,SAAS,IAAA;QAAA;AAGjB,YAAI,KAAK,OAAO,SAAS,GAAG;AACzB,gBAAM,IAAI,MAAM,0CAA0C,KAAK,OAAO,MAAA;QAAA;MAAA;MAI5E,SAAS,MAAwB;AAC9B,cAAM,WAAW,KAAK,aAAa,IAAA;AACnC,YAAI,UAAU;AACX,eAAK,OAAO,OAAO,IAAA;QAAA;MAAA;MAIzB,QAAQ,MAAwC;AAC7C,cAAM,WAAW,KAAK,aAAa,IAAA;AACnC,YAAI,CAAC,UAAU;AACZ,gBAAM,IAAI,SAAS,QAAW,uDAAA;QAAA;AAEjC,iBAAS,OAAO,eAAA;AAEhB,eAAO;MAAA;MAAA,OAGH,QAAQ,OAAO,SAAS;AAC5B,eAAO,QAAQ,QAAQ,EAAE,mBAAkB;MAAA;IAAA;AArE1C,wBAAA;AAAA,sBAwEW,UAAU;EAAA;AAAA,CAAA;ACuL5B,SAAA,cAA0B,MAAwB,UAAoB;AACnE,SAAO;IACJ,QAAQ,MAAM,KAAK,QAAA,KAAa;IAChC;EAAA;AAAA;AAIN,SAAA,gBAAyB,QAAkBA,SAAsB;AAC9D,SAAO,CAAC,QAAe;AACpB,IAAAA,QAAO,sCAAsC,GAAA;AAC7C,WAAO,KAAK,OAAO,KAAK,OAAO,IAAI,KAAA,GAAQ,OAAA,CAAA;EAAA;AAAA;AAIjD,SAAA,eACG,QACA,MACAA,SACA,QACD;AACC,SAAO,CAAC,WAAmB;AACxB,IAAAA,QAAO,wBAAwB,MAAM,MAAA;AACrC,WAAO,MAAM,MAAA;AACb,WAAO,KAAK,MAAA;EAAA;AAAA;AAlSlB,IAiBO;AAjBP,IAAA,0BAAA,MAAA;EAAA,0CAAA;AACA,mBAAA;AAGA,cAAA;AASA,eAAA;AAEA,6BAAA;AAEO,uBAAA,MAAoD;MAyBxD,YACW,WACA,YACA,UACT;AAHS,aAAA,YAAA;AACA,aAAA,aAAA;AACA,aAAA,WAAA;AA3BH,aAAA,SAAuB,QAAQ,QAAA;AAC/B,aAAA,SAAS,IAAI,kBAAA;MAAA;MAAA,IAGV,SAAS;AACjB,eAAO,KAAK,UAAU;MAAA;MAAA,IAGd,MAAM;AACd,eAAO,KAAK,QAAQ,KAAK,UAAU;MAAA;MAAA,IAG3B,IAAI,KAAa;AACzB,aAAK,OAAO;MAAA;MAAA,IAGJ,MAAM;AACd,eAAO,KAAK,UAAU;MAAA;MAAA,IAGd,gBAAgB;AACxB,eAAO,KAAK,UAAU;MAAA;MASlB,QAAQ;AACZ,eAAO;MAAA;MAGH,KAAQ,MAAoC;AAChD,aAAK,OAAO,KAAK,IAAA;AAEjB,eAAQ,KAAK,SAAS,KAAK,OAAO,KAAK,MAAM,KAAK,YAAY,IAAA,CAAA;MAAA;MAGnD,YAAe,MAA2C;AAAA,eAAA,QAAA,MAAA,MAAA,aAAA;AACrE,gBAAM,qBAAqB,MAAM,KAAK,WAAW,KAAA;AACjD,gBAAM,kBAAkB,MAAM,KAAK,OAAO,SAAS,IAAA;AAEnD,cAAI;AACD,kBAAM,EAAE,QAAAA,QAAA,IAAW,KAAK,OAAO,QAAQ,IAAA;AACvC,mBAAQ,MAAO,YAAY,IAAA,IACtB,KAAK,iBAAiB,MAAMA,OAAA,IAC5B,KAAK,kBAAkB,MAAMA,OAAA;UAAA,SAC5B,GAD4B;AAElC,kBAAM,KAAK,iBAAiB,MAAM,CAAA;UAAA,UAAA;AAElC,4BAAA;AACA,+BAAA;UAAA;QAAA,CAAA;MAAA;MAIE,iBAAoB,MAAwB,GAAU;AAC3D,cAAM,WACH,aAAa,WAAW,OAAO,OAAO,GAAG,EAAE,KAAA,CAAA,IAAU,IAAI,SAAS,MAAM,KAAK,OAAO,CAAA,CAAA;AAEvF,aAAK,SAAS,QAAQ,QAAA;AACtB,aAAK,OAAO,MAAM,QAAA;AAElB,eAAO;MAAA;MAGI,kBAAqB,MAAuBA,SAAsB;AAAA,eAAA,QAAA,MAAA,MAAA,aAAA;AAC7E,gBAAM,OAAO,KAAK,SAAS,KACxB,cACA,CAAC,GAAG,KAAK,QAAA,GACT,cAAc,MAAM,KAAK,QAAA,CAAA;AAG5B,gBAAM,MAAM,MAAM,KAAK,YACpB,MACA,KAAK,QACL,MACA,KAAK,eACLA,QAAO,KAAK,OAAA,CAAA;AAEf,gBAAM,gBAAgB,MAAM,KAAK,eAAe,MAAM,MAAM,KAAKA,QAAO,KAAK,QAAA,CAAA;AAE7E,UAAAA,QAAO,6CAA6C,KAAK,MAAA;AAEzD,cAAI,aAAa,IAAA,GAAO;AACrB,mBAAO,eAAe,KAAK,QAAQ,aAAA;UAAA;AAGtC,iBAAO,eAAe,KAAK,QAAQ,cAAc,UAAA,CAAA;QAAA,CAAA;MAAA;MAGtC,iBAAiB,MAAiBA,SAAsB;AAAA,eAAA,QAAA,MAAA,MAAA,aAAA;AACnE,UAAAA,QAAO,6DAAA;AACP,iBAAO,KAAK,OAAO,IAAA;QAAA,CAAA;MAAA;MAGd,eACL,MACA,MACA,QACAA,SAC0B;AAC1B,cAAM,EAAE,UAAU,WAAW,QAAQ,OAAA,IAAW;AAEhD,eAAO,IAAI,QAAQ,CAAC,MAAM,SAAS;AAChC,UAAAA,QAAO,4DAA4D,QAAA;AAEnE,gBAAM,EAAE,MAAA,IAAU,KAAK,SAAS,KAC7B,cACA,EAAE,OAAO,UAAA,GACT,eAAA,eAAA,CAAA,GACM,cAAc,MAAM,IAAA,CAAA,GACpB,MAAA,CAAA;AAIT,cAAI,SAAS,KAAK,SAAS;AACxB,YAAAA,QAAO,KAAK,gDAAA;AAEZ,mBAAO,KAAK,QACT,QACA,OACA,CAAC,cAAc;AACZ,cAAAA,QAAO,KAAK,yCAAA;AACZ,cAAAA,QAAO,8BAA8B,eAAe,SAAA,CAAA;AAEpD,mBACG,IAAI,iBACD,MAAM,QAAQ,SAAA,IAAa,OAAO,OAAO,SAAA,IAAa,WACtD,OAAO,OAAO,MAAA,CAAA,CAAA;YAAA,GAIvB,IAAA;UAAA;AAIN,cAAI,OAAO;AACR,YAAAA,QAAO,KACJ,yDACA,UACA,OAAO,QACP,SAAA;AAEH,mBAAO,KAAK,KAAA;UAAA;AAGf,UAAAA,QAAO,KAAK,iCAAA;AACZ,eAAK,IAAI,iBAAiB,OAAO,OAAO,MAAA,GAAS,OAAO,OAAO,MAAA,CAAA,CAAA;QAAA,CAAA;MAAA;MAIvD,YACX,MACA,SACA,MACA,eACAA,SAC2B;AAAA,eAAA,QAAA,MAAA,MAAA,aAAA;AAC3B,gBAAM,eAAeA,QAAO,QAAQ,QAAA;AACpC,gBAAM,eAA6B,KAAK,SAAS,KAC9C,iBACA;YACG,KAAK,KAAK;YACV,KAAK,KAAK;YACV,aAAa;UAAA,GAEhB,cAAc,MAAM,KAAK,QAAA,CAAA;AAG5B,iBAAO,IAAI,QAAQ,CAAC,SAAS;AAC1B,kBAAM,SAAmB,CAAA;AACzB,kBAAM,SAAmB,CAAA;AAEzB,YAAAA,QAAO,KAAK,SAAS,SAAS,IAAA;AAC9B,YAAAA,QAAO,MAAM,YAAA;AAEb,gBAAI,YAAY,KAAK,aAAa,MAAM,IAAA;AACxC,gBAAI,WAAW;AACZ,qBAAO,KAAK;gBACT;gBACA;gBACA,UAAU;gBACV;cAAA,CAAA;YAAA;AAIN,iBAAK,SAAS,KAAK,gBAAgB,QAAW,cAAA,eAAA,CAAA,GACxC,cAAc,MAAM,IAAA,CAAA,GADoB;cAE3C,KAAK,QAAQ;AACV,4BAAY,UAAU;cAAA;YAAA,CAAA,CAAA;AAI5B,kBAAM,cAAU,4BAAM,SAAS,MAAM,YAAA;AAErC,oBAAQ,OAAQ,GACb,QACA,eAAe,QAAQ,UAAUA,SAAQ,aAAa,KAAK,QAAA,CAAA,CAAA;AAE9D,oBAAQ,OAAQ,GACb,QACA,eAAe,QAAQ,UAAUA,SAAQ,aAAa,KAAK,QAAA,CAAA,CAAA;AAG9D,oBAAQ,GAAG,SAAS,gBAAgB,QAAQA,OAAA,CAAA;AAE5C,gBAAI,eAAe;AAChB,cAAAA,QAAO,6DAAA;AACP,4BAAc,SAAS,QAAQ,QAAS,QAAQ,QAAS,CAAC,GAAG,IAAA,CAAA;YAAA;AAGhE,iBAAK,SAAS,KAAK,eAAe,QAAW,cAAA,eAAA,CAAA,GACvC,cAAc,MAAM,IAAA,CAAA,GADmB;cAE1C;cACA,MAAM,UAAkB,QAAgB;AACrC,qBAAK;kBACF;kBACA;kBACA;kBACA,WAAW,aAAa;gBAAA,CAAA;cAAA;cAG9B,KAAK,QAAe;AACjB,oBAAI,QAAQ,QAAQ;AACjB;gBAAA;AAGH,4BAAY;AACZ,wBAAQ,KAAK,QAAA;cAAA;YAAA,CAAA,CAAA;UAAA,CAAA;QAAA,CAAA;MAAA;MAMjB,aAAgB,MAAwB,MAAgB;AAC7D,YAAI;AACJ,aAAK,SAAS,KAAK,gBAAgB,QAAW,cAAA,eAAA,CAAA,GACxC,cAAc,MAAM,IAAA,CAAA,GADoB;UAE3C,KAAK,QAAQ;AACV,wBAAY,UAAU;UAAA;QAAA,CAAA,CAAA;AAI5B,eAAO;MAAA;IAAA;EAAA;AAAA,CAAA;ACvQb,IAAA,uBAAA,CAAA;AAAAF,UAAA,sBAAA;EAAA,aAAA,MAAA;AAAA,CAAA;AAAA,IAMO;AANP,IAAA,oBAAA,MAAA;EAAA,oCAAA;AAGA,4BAAA;AAGO,kBAAA,MAA+C;MAMnD,YACU,SAAiB,OACjB,KACC,YACA,UACT;AAJQ,aAAA,SAAA;AACA,aAAA,MAAA;AACC,aAAA,aAAA;AACA,aAAA,WAAA;AATH,aAAA,SAAS,IAAI,iBAAiB,MAAM,KAAK,YAAY,KAAK,QAAA;MAAA;MAYlE,QAA2B;AACxB,eAAO,IAAI,iBAAiB,MAAM,KAAK,YAAY,KAAK,QAAA;MAAA;MAG3D,KAAQ,MAAoC;AACzC,eAAO,KAAK,OAAO,KAAK,IAAA;MAAA;IAAA;EAAA;AAAA,CAAA;ACnBvB,SAAA,aACJ,MACA,UACA,WAAqC,MACtC;AACC,QAAM,YAAY,CAAC,SAAY;AAC5B,aAAS,MAAM,IAAA;EAAA;AAGlB,QAAM,WAAU,CAAC,QAAqC;AACnD,SAAI,OAAA,OAAA,SAAA,IAAK,UAAS,MAAM;AACrB,eACG,eAAe,mBAAmB,4BAA4B,GAAA,IAAO,KACrE,MAAA;IAAA;EAAA;AAKT,WAAS,KAAK,WAAW,QAAA;AAAA;AAG5B,SAAA,4BAAqC,KAAuB;AACzD,MAAI,MAAM,CAAC,SAAiB;AACzB,YAAQ,KACL,6DAA6D,uCAAuC,qDAAA;AAEvG,UAAM;EAAA;AAGT,SAAO,OAAO,OAAO,KAAK,OAAO,oBAAoB,IAAI,GAAA,EAAK,OAAO,mBAAmB,CAAA,CAAA,CAAA;AAExF,WAAA,kBAA2B,KAA4B,MAA0B;AAC9E,QAAI,QAAQ,KAAK;AACd,aAAO;IAAA;AAGV,QAAI,IAAA,IAAQ;MACT,YAAY;MACZ,cAAc;MACd,MAAM;AACH,YAAI,IAAA;AACJ,eAAO,IAAI,IAAI,IAAA;MAAA;IAAA;AAIrB,WAAO;EAAA;AAAA;AAlDb,IAAA,qBAAA,MAAA;EAAA,6BAAA;AACA,4BAAA;AAEA,eAAA;EAAA;AAAA,CAAA;ACCO,SAAA,2BAAoC,WAAmB,MAA0B;AACrF,SAAO,cAAc,CAAC,aAAgC;AACnD,QAAI,CAAC,aAAa,SAAA,GAAY;AAC3B,YAAM,IAAI,MAAM,4CAA4C,YAAA;IAAA;AAG/D,YAAS,QAAQ,UAAU,MAAM;EAAA,CAAA;AAAA;AAVvC,IAAA,gCAAA,MAAA;EAAA,8CAAA;AAAA,eAAA;AAEA,cAAA;EAAA;AAAA,CAAA;ACGA,SAAA,aAAsB,MAAgB;AACnC,QAAM,WAAW,CAAC,YAAY,GAAG,IAAA;AACjC,MAAI,SAAS,CAAA,MAAO,QAAQ,SAAS,SAAS,IAAA,GAAO;AAClD,aAAS,CAAA,IAAK,OAAO,UAAU,IAAA;EAAA;AAGlC,SAAO,0BAA0B,QAAA;AAAA;AAGrB,SAAA,mBAAoF;AAChG,SAAO;IACJ,WAA6B;AAC1B,aAAO,KAAK,SACT,aAAa,mBAAmB,WAAW,CAAA,CAAA,GAC3C,yBAAyB,SAAA,CAAA;IAAA;IAI/B,eAAmC,YAAY,YAAY;AACxD,aAAO,KAAK,SACT,aAAa,CAAC,MAAM,YAAY,YAAY,GAAG,mBAAmB,SAAA,CAAA,CAAA,GAClE,yBAAyB,SAAA,CAAA;IAAA;IAI/B,oBAAwC,YAAY;AACjD,aAAO,KAAK,SACT,aAAa,CAAC,MAAM,YAAY,GAAG,mBAAmB,SAAA,CAAA,CAAA,GACtD,yBAAyB,SAAA,CAAA;IAAA;EAAA;AAAA;AAjCrC,IAAA,gBAAA,MAAA;EAAA,8BAAA;AAEA,eAAA;AACA,cAAA;EAAA;AAAA,CAAA;ACyCO,SAAA,kBAA2B,QAA8B;AAC7D,QAAM,SAAuB;IAC1B,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,MAAM;IACN,SAAS;MACN,SAAS;MACT,YAAY;MACZ,WAAW;IAAA;EAAA;AAGjB,SAAO,oBAAoB,QAAQ,SAAS,MAAA;AAAA;AAxD/C,IAGM;AAHN,IAAA,oBAAA,MAAA;EAAA,oCAAA;AACA,eAAA;AAEM,cAAsC;MACzC,IAAI,WAAW,qCAAqC,CAAC,QAAQ,CAAC,QAAQ,MAAM,MAAA,MAAY;AACrF,eAAO,SAAS;AAChB,eAAO,SAAS;AAChB,eAAO,OAAO,CAAC,CAAC;MAAA,CAAA;MAEnB,IAAI,WAAW,qBAAqB,CAAC,QAAQ,CAAC,MAAA,MAAY;AACvD,cAAM,QAAQ,OAAO,MAAM,GAAA;AAC3B,cAAM,QAAQ,MAAM,IAAA;AAEpB,YAAI,CAAC,SAAS,CAAC,MAAM,SAAS,GAAA,GAAM;AACjC;QAAA;AAGH,eAAO,SAAS;UACb,OAAO,MAAM,OAAO,GAAG,MAAM,SAAS,CAAA;UACtC,MAAM,MAAM,KAAK,GAAA,EAAK,KAAA;QAAA;MAAA,CAAA;MAG5B,IAAI,WACD,8CACA,CAAC,QAAQ,CAAC,SAAS,YAAY,SAAA,MAAe;AAC3C,eAAO,QAAQ,UAAU,SAAS,SAAS,EAAA,KAAO;AAClD,eAAO,QAAQ,aAAa,SAAS,YAAY,EAAA,KAAO;AACxD,eAAO,QAAQ,YAAY,SAAS,WAAW,EAAA,KAAO;MAAA,CAAA;MAG5D,IAAI,WACD,0CACA,CAAC,QAAQ,CAAC,SAAS,OAAO,SAAA,MAAe;AACtC,eAAO,QAAQ,UAAU,SAAS,SAAS,EAAA,KAAO;AAClD,cAAM,QAAQ,SAAS,OAAO,EAAA,KAAO;AACrC,YAAI,cAAc,KAAK;AACpB,iBAAO,QAAQ,YAAY;QAAA,WACnB,cAAc,KAAK;AAC3B,iBAAO,QAAQ,aAAa;QAAA;MAAA,CAAA;IAAA;EAAA;AAAA,CAAA;ACvBjC,SAAA,WACJ,SACA,OACA,YACyB;AACzB,QAAM,WAAqB;IACxB;IACA;IACA;IACA,GAAG,cAAc,SAAS,IAAA;IAC1B,GAAG;IACH,GAAG;EAAA;AAGN,SAAO;IACJ;IACA,QAAQ;IACR,QAAQ;EAAA;AAAA;AAIC,SAAA,iBAAuC;AACnD,SAAO;IACJ,OAA2B,YAA+B,MAAiB;AACxE,YAAM,OAAO,yBAAyB,SAAA;AACtC,YAAM,OACH,2BAA2B,OAAA,KAC3B,WACG,QAAQ,OAAA,GACR,QAAQ,WAAW,KAAK,CAAA,GAAI,2BAA2B,CAAA,CAAA,CAAA,GACvD,CAAC,GAAG,WAAW,KAAK,CAAA,GAAI,aAAa,CAAA,CAAA,GAAK,GAAG,mBAAmB,WAAW,GAAG,IAAA,CAAA,CAAA;AAGpF,aAAO,KAAK,SAAS,MAAM,IAAA;IAAA;EAAA;AAIjC,WAAA,2BAAoC,SAAmB;AACpD,WACG,CAAC,0BAA0B,OAAA,KAC3B,uBACG,6EAAA;EAAA;AAAA;AAxDZ,IAAA,cAAA,MAAA;EAAA,4BAAA;AAGA,sBAAA;AACA,eAAA;AASA,cAAA;EAAA;AAAA,CAAA;ACRe,SAAA,uBAA4C;AACxD,SAAO;IACJ,cAAkD;AAC/C,aAAO,KAAK,SACT,0BAA0B,CAAC,YAAY,mBAAmB,MAAA,GAAS,IAAA,GACnE,yBAAyB,SAAA,CAAA;IAAA;EAAA;AAAA;AAVrC,IAAA,oBAAA,MAAA;EAAA,kCAAA;AAEA,eAAA;AACA,cAAA;EAAA;AAAA,CAAA;ACGO,SAAA,eAAwB,UAAkB,OAAoC;AAClF,QAAM,WAAW,CAAC,eAAe,QAAA;AACjC,MAAI,OAAO;AACR,aAAS,KAAK,IAAA;EAAA;AAGjB,SAAO,0BAA0B,UAAU,IAAA;AAAA;AAZ9C,IAAA,mBAAA,MAAA;EAAA,iCAAA;AAAA,cAAA;EAAA;AAAA,CAAA;ACcO,SAAA,UAAmB,MAAe,MAAc,MAAc;AAClE,QAAM,WAAW,OAAO,IAAA,EAAM,KAAA;AAC9B,MAAI;AAEJ,MAAK,SAAS,kBAAkB,KAAK,QAAA,GAAY;AAC9C,WAAO,IAAI,YAAY,MAAM,MAAM,OAAO,OAAO,CAAA,CAAA;EAAA;AAGpD,MAAK,SAAS,oBAAoB,KAAK,QAAA,GAAY;AAChD,WAAO,IAAI,YAAY,MAAM,MAAM,MAAM,OAAO,CAAA,CAAA;EAAA;AAGnD,MAAI,SAAS;AACb,QAAM,SAAS,SAAS,MAAM,GAAA;AAC9B,SAAO,OAAO,QAAQ;AACnB,UAAM,QAAQ,OAAO,MAAA;AACrB,QAAI,UAAU,MAAM;AACjB,eAAS,OAAO,KAAK,GAAA;AACrB;IAAA;EAAA;AAIN,SAAO,IAAI,YAAY,MAAM,MAAM,OAAO,KAAK,QAAA,GAAW,MAAA;AAAA;AApC7D,IAEO;AAFP,IAWM;AAXN,IAYM;AAZN,IAAA,mBAAA,MAAA;EAAA,qCAAA;AAEO,kBAAA,MAAwC;MAC5C,YACmB,MACA,MACA,UACA,QACjB;AAJiB,aAAA,OAAA;AACA,aAAA,OAAA;AACA,aAAA,WAAA;AACA,aAAA,SAAA;MAAA;IAAA;AAIhB,wBAAoB;AACpB,0BAAsB;EAAA;AAAA,CAAA;ACN5B,SAAA,eAAwB,SAAmB;AACxC,SAAO,QAAQ,SAAS,WAAA;AAAA;AAGpB,SAAA,SAAkB,OAAO,OAAO,MAAc,YAA8C;AAChG,QAAM,WAAW,CAAC,QAAQ,GAAG,UAAA;AAC7B,MAAI,QAAQ,CAAC,eAAe,QAAA,GAAW;AACpC,aAAS,OAAO,GAAG,GAAG,WAAA;EAAA;AAGzB,SAAO;IACJ;IACA,QAAQ;IACR,OAAO,MAA0B;AAC9B,aAAO,UAAU,SAAS,SAAS,QAAA,GAAW,MAAM,IAAA;IAAA;EAAA;AAAA;AApB7D,IAIM;AAJN,IAAA,YAAA,MAAA;EAAA,0BAAA;AACA,qBAAA;AAGM,kBAAc;EAAA;AAAA,CAAA;ACMb,SAAA,qBAA8B,YAAsB;AACxD,WAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;AACzC,UAAM,SAAS,eAAe,KAAK,WAAW,CAAA,CAAA;AAC9C,QAAI,QAAQ;AACT,aAAO,KAAK,OAAO,CAAA;IAAA;EAAA;AAIzB,SAAO;AAAA;AAGH,SAAA,YAAqB,WAA6B;AACtD,SAAO,eAAe,KAAK,SAAA;AAAA;AAtB9B,IAQM;AARN,IAAA,kBAAA,MAAA;EAAA,+BAAA;AAQM,qBAAiB;EAAA;AAAA,CAAA;ACRvB,IAKO;AALP,IAAA,mBAAA,MAAA;EAAA,qCAAA;AAKO,kBAAA,MAAwC;MAAxC,cALP;AAMG,aAAA,UAAU;AACV,aAAA,YAAY;AACZ,aAAA,aAAa;AAEb,aAAA,QAA0D,CAAA;MAAA;IAAA;EAAA;AAAA,CAAA;ACuGtD,SAAA,cAAuB,SAAS,IAAgB;AACpD,QAAM,UAAS,mBAAmB,MAAA;AAElC,SAAO,CAAC,WAAmB,oBAAoB,IAAI,YAAA,GAAe,SAAQ,QAAQ,KAAA;AAAA;AApHrF,IAMM;AANN,IA2CM;AA3CN,IA2EM;AA3EN,IAwFM;AAxFN,IAyGM;AAzGN,IAAA,0BAAA,MAAA;EAAA,0CAAA;AACA,oBAAA;AACA,qBAAA;AACA,0BAAA;AACA,eAAA;AAEM,iBAAa;MAChB,IAAI,WACD,kCACA,CAAC,QAAQ,CAAC,MAAM,SAAS,cAAc,EAAA,MAAQ;AAC5C,eAAO,MAAM,KAAK;UACf,MAAM,KAAK,KAAA;UACX,SAAS,SAAS,OAAA;UAClB,YAAY,YAAY,QAAQ,SAAS,EAAA,EAAI;UAC7C,WAAW,YAAY,QAAQ,SAAS,EAAA,EAAI;UAC5C,QAAQ;QAAA,CAAA;MAAA,CAAA;MAIjB,IAAI,WACD,iDACA,CAAC,QAAQ,CAAC,MAAM,QAAQ,KAAA,MAAW;AAChC,eAAO,MAAM,KAAK;UACf,MAAM,KAAK,KAAA;UACX,QAAQ,SAAS,MAAA;UACjB,OAAO,SAAS,KAAA;UAChB,QAAQ;QAAA,CAAA;MAAA,CAAA;MAIjB,IAAI,WACD,iDACA,CAAC,QAAQ,CAAC,SAAS,OAAA,MAAa;AAC7B,cAAM,WAAW,UAAU,KAAK,OAAA;AAChC,cAAM,UAAU,UAAU,KAAK,OAAA;AAE/B,eAAO,UAAU,SAAS,OAAA;AAC1B,eAAO,aAAa,SAAS,YAAA,OAAA,SAAA,SAAW,CAAA,CAAA;AACxC,eAAO,YAAY,SAAS,WAAA,OAAA,SAAA,QAAU,CAAA,CAAA;MAAA,CAAA;IAAA;AAKzC,oBAAgB;MACnB,IAAI,WACD,uBACA,CAAC,QAAQ,CAAC,eAAe,eAAe,IAAA,MAAU;AAC/C,cAAM,aAAa,SAAS,aAAA;AAC5B,cAAM,YAAY,SAAS,aAAA;AAE3B,eAAO;AACP,eAAO,cAAc;AACrB,eAAO,aAAa;AAEpB,eAAO,MAAM,KAAK;UACf;UACA,SAAS,aAAa;UACtB;UACA;UACA,QAAQ;QAAA,CAAA;MAAA,CAAA;MAIjB,IAAI,WAAuB,eAAe,CAAC,QAAQ,CAAC,IAAA,MAAU;AAC3D,eAAO;AAEP,eAAO,MAAM,KAAK;UACf;UACA,OAAO;UACP,QAAQ;UACR,QAAQ;QAAA,CAAA;MAAA,CAAA;IAAA;AAKX,qBAAiB;MACpB,IAAI,WAAuB,SAAS,CAAC,QAAQ,CAAC,IAAA,MAAU;AACrD,eAAO;AACP,eAAO,MAAM,KAAK;UACf;UACA,SAAS;UACT,YAAY;UACZ,WAAW;UACX,QAAQ;QAAA,CAAA;MAAA,CAAA;IAAA;AAKX,uBAAmB;MACtB,IAAI,WACD,uDACA,CAAC,QAAQ,CAAC,QAAQ,aAAa,MAAM,KAAK,EAAA,MAAQ;AAC/C,eAAO;AACP,eAAO,MAAM,KAAK;UACf,MAAM,MAAA,OAAA,KAAM;UACZ,SAAS;UACT,QAAQ,OAAO,iBAAiB,MAAA,KAAW,MAAA;UAC3C,YAAY;UACZ,WAAW;UACX,QAAQ;QAAA,CAAA;MAAA,CAAA;IAAA;AAMd,yBAAkE;MAAA;QACpE;;MAAA,GAAiB;MAAA;QACjB;;MAAA,GAAiB;MAAA;QACjB;;MAAA,GAAqB;MAAA;QACrB;;MAAA,GAAwB;MAAA;QACxB;;MAAA,GAAsB;IAAA;EAAA;AAAA,CAAA;ACjG1B,SAAA,YAAqB,QAAkB,QAAuB;AAC3D,SAAO,OAAO,OACX,CAAC,MAAM,OAAO,UAAU;AACrB,SAAK,KAAA,IAAS,OAAO,KAAA,KAAU;AAC/B,WAAO;EAAA,GAEV,uBAAO,OAAO,EAAE,MAAM,KAAA,CAAA,CAAA;AAAA;AAIrB,SAAA,2BACJ,WAAW,UACX,SAAS,mBACT,YAAY,IACb;AACC,QAAM,kBAAkB,cAAc,SAAA;AAEtC,SAAO,SAAU,QAA8B;AAC5C,UAAM,MAAsC,mBACzC,QACA,MACA,cAAA,EACD,IAAI,SAAU,MAAM;AACnB,YAAM,aAAa,KAAK,KAAA,EAAO,MAAM,eAAA;AACrC,YAAM,cAA+B,YAClC,WAAW,CAAA,EAAG,KAAA,EAAO,MAAM,QAAA,GAC3B,MAAA;AAGH,UAAI,WAAW,SAAS,KAAK,CAAC,CAAC,WAAW,CAAA,EAAG,KAAA,GAAQ;AAClD,oBAAY,OAAO,gBAAgB,WAAW,CAAA,CAAA;MAAA;AAGjD,aAAO;IAAA,CAAA;AAGV,WAAO;MACJ;MACA,QAAS,IAAI,UAAU,IAAI,CAAA,KAAO;MAClC,OAAO,IAAI;IAAA;EAAA;AAAA;AApDpB,IAKa;AALb,IAOa;AAPb,IASa;AATb,IAWM;AAXN,IAAA,8BAAA,MAAA;EAAA,8CAAA;AACA,eAAA;AACA,4BAAA;AACA,oBAAA;AAEa,qBAAiB;AAEjB,sBAAkB;AAElB,eAAW;AAElB,wBAAoB,CAAC,QAAQ,QAAQ,WAAW,QAAQ,eAAe,cAAA;EAAA;AAAA,CAAA;ACX7E,IAAA,eAAA,CAAA;AAAAA,UAAA,cAAA;EAAA,iBAAA,MAAA;EAAA,yBAAA,MAAA;AAAA,CAAA;AAMO,SAAA,gBAAyB,YAA0D;AACvF,MAAI,YAAY,qBAAqB,UAAA;AAErC,QAAM,WAAW,CAAC,MAAA;AAElB,MAAI,cAAc,IAAgB;AAC/B,gBAAY;AACZ,aAAS,KAAK,aAAA;EAAA;AAGjB,WAAS,KAAK,GAAG,UAAA;AAEjB,SACG,wBAAwB,QAAA,KAAa;IAClC;IACA,QAAQ;IACR,QAAQ,cAAc,SAAA;EAAA;AAAA;AAKxB,SAAA,wBAAiC,YAAyC;AAC9E,QAAM,QAAQ,WAAW,OAAO,WAAA;AAEhC,MAAI,MAAM,SAAS,GAAG;AACnB,WAAO,uBACJ,sDAAsD,MAAM,KAAK,GAAA,GAAA;EAAA;AAIvE,MAAI,MAAM,UAAU,WAAW,SAAS,IAAA,GAAO;AAC5C,WAAO,uBACJ,gBAAgB,mEAAA;EAAA;AAAA;AAtCzB,IAAA,YAAA,MAAA;EAAA,0BAAA;AAEA,oBAAA;AACA,4BAAA;AACA,cAAA;EAAA;AAAA,CAAA;ACgEA,SAAA,aACG,QACA,UACmB;AACnB,QAAM,SAAmB,CAAA;AACzB,QAAM,YAAsB,CAAA;AAE5B,SAAO,KAAK,MAAA,EAAQ,QAAQ,CAAC,UAAU;AACpC,WAAO,KAAK,KAAA;AACZ,cAAU,KAAK,OAAO,OAAO,KAAA,CAAA,CAAA;EAAA,CAAA;AAGhC,SAAO,CAAC,QAAQ,UAAU,KAAK,QAAA,CAAA;AAAA;AAGlC,SAAA,YAAwC,OAAmB;AACxD,SAAO,OAAO,KAAK,KAAA,EAAO,OAAO,CAAC,KAAK,QAAQ;AAC5C,QAAI,EAAE,OAAO,iBAAiB;AAC3B,UAAI,GAAA,IAAO,MAAM,GAAA;IAAA;AAEpB,WAAO;EAAA,GACP,CAAA,CAAA;AAAA;AAGC,SAAA,gBACJ,MAA+B,CAAA,GAC/B,aAAuB,CAAA,GACN;AACjB,QAAM,WAAW,WAAW,IAAI,UAAU,cAAc,QAAA;AACxD,QAAM,SACH,CAAC,iBAAiB,IAAI,MAAA,KAAW,IAAI,SAChC,IAAI,SACJ;IACG,MAAM;IACN,MAAM,IAAI,eAAe,QAAQ,QAAQ;IACzC,SAAS;IACT,MAAM;IACN,MAAM,IAAI,YAAY,OAAO;IAC7B,aAAa,IAAI,YAAY,QAAQ,QAAQ;IAC7C,cAAc,IAAI,YAAY,QAAQ,QAAQ;EAAA;AAGzD,QAAM,CAAC,QAAQ,SAAA,IAAa,aAAa,QAAQ,QAAA;AAEjD,QAAM,SAAmB,CAAA;AACzB,QAAM,UAAoB;IACvB,mBAAmB,iBAAiB,YAAY;IAChD,GAAG;EAAA;AAGN,QAAM,WAAgC,IAAY,KAAM,IAAY,WAAA,KAAgB,IAAI;AACxF,MAAI,UAAU;AACX,YAAQ,KAAK,eAAe,UAAA;EAAA;AAG/B,MAAI,IAAI,QAAQ,IAAI,IAAI;AACrB,UAAM,gBAAgB,IAAI,cAAc,QAAQ,QAAQ;AACxD,WAAO,KAAK,GAAG,IAAI,QAAQ,KAAK,gBAAgB,IAAI,MAAM,IAAA;EAAA;AAG7D,MAAI,aAAa,IAAI,IAAA,GAAO;AACzB,YAAQ,KAAK,YAAY,SAAS,IAAI,IAAA,CAAA;EAAA;AAGzC,oBAAkB,YAAY,GAAA,GAAiB,OAAA;AAE/C,SAAO;IACJ;IACA;IACA,UAAU,CAAC,GAAG,SAAS,GAAG,MAAA;EAAA;AAAA;AAIzB,SAAA,QACJ,UACA,QACA,YACyB;AACzB,QAAM,UAAS,2BAA2B,UAAU,QAAQ,qBAAqB,UAAA,CAAA;AAEjF,SAAO;IACJ,UAAU,CAAC,OAAO,GAAG,UAAA;IACrB,QAAQ;IACR,QAAA;EAAA;AAAA;AAIS,SAAA,cAAoC;AAChD,SAAO;IACJ,OAA8C,MAAiB;AAC5D,YAAM,OAAO,yBAAyB,SAAA;AACtC,YAAM,UAAU,gBACb,wBAAwB,SAAA,GACxB,WAAW,UAAU,CAAA,GAAI,WAAA,CAAA;AAE5B,YAAM,OACH,2BAA2B,GAAG,IAAA,KAC9B,wBAAwB,QAAQ,QAAA,KAChC,cAAc,OAAA;AAEjB,aAAO,KAAK,SAAS,MAAM,IAAA;IAAA;EAAA;AAIjC,WAAA,cAAuB,SAA2B;AAC/C,WAAO,QAAQ,QAAQ,UAAU,QAAQ,QAAQ,QAAQ,QAAA;EAAA;AAG5D,WAAA,2BAAoC,MAAgB,IAAc;AAC/D,WACG,aAAa,IAAA,KACb,aAAa,EAAA,KACb,uBACG,uFAAA;EAAA;AAAA;AArLZ,IAuBK;AAvBL,IAAA,WAAA,MAAA;EAAA,yBAAA;AAEA,oBAAA;AACA,kBAAA;AACA,gCAAA;AAMA,eAAA;AAUA,cAAA;AACA,cAAA;AAEK,qBAAL,kBAAK,oBAAL;AACG,sBAAA,gBAAA,UAAA,IAAA,CAAA,IAAA;AACA,sBAAA,gBAAA,WAAA,IAAA,CAAA,IAAA;AACA,sBAAA,gBAAA,UAAA,IAAA,CAAA,IAAA;AACA,sBAAA,gBAAA,GAAA,IAAA,CAAA,IAAA;AACA,sBAAA,gBAAA,MAAA,IAAA,CAAA,IAAA;AACA,sBAAA,gBAAA,QAAA,IAAA,CAAA,IAAA;AACA,sBAAA,gBAAA,MAAA,IAAA,CAAA,IAAA;AACA,sBAAA,gBAAA,IAAA,IAAA,CAAA,IAAA;AACA,sBAAA,gBAAA,UAAA,IAAA,CAAA,IAAA;AACA,sBAAA,gBAAA,WAAA,IAAA,CAAA,IAAA;AACA,sBAAA,gBAAA,SAAA,IAAA,EAAA,IAAA;AACA,sBAAA,gBAAA,WAAA,IAAA,EAAA,IAAA;AACA,sBAAA,gBAAA,YAAA,IAAA,EAAA,IAAA;AAbE,aAAA;IAAA,GAAA,kBAAA,CAAA,CAAA;EAAA;AAAA,CAAA;ACvBL,IAOO;AAPP,IAmBO;AAnBP,IAAA,oBAAA,MAAA;EAAA,sCAAA;AAOO,2BAAA,MAAoD;MACxD,YACmB,QACA,OAAsB,MACtB,MACjB;AAHiB,aAAA,SAAA;AACA,aAAA,OAAA;AACA,aAAA,OAAA;MAAA;MAGnB,WAAW;AACR,eAAO,GAAG,KAAK,QAAQ,KAAK;MAAA;IAAA;AAI3B,yBAAA,MAAgD;MAAhD,cAnBP;AAoBU,aAAA,YAA6B,CAAA;AAC7B,aAAA,SAAmB,CAAA;AACnB,aAAA,SAA4B;MAAA;MAAA,IAE/B,SAAS;AACV,eAAO,KAAK,UAAU,SAAS;MAAA;MAAA,IAG9B,SAAS;AACV,eAAO,KAAK;MAAA;MAGf,WAAW;AACR,YAAI,KAAK,UAAU,QAAQ;AACxB,iBAAO,cAAc,KAAK,UAAU,KAAK,IAAA;QAAA;AAG5C,eAAO;MAAA;IAAA;EAAA;AAAA,CAAA;ACrCb,IAOO;AAPP,IAuBO;AAvBP,IAAA,mBAAA,MAAA;EAAA,qCAAA;AAOO,kBAAA,MAAwC;MAAxC,cAPP;AAQU,aAAA,iBAAiB;UACrB,KAAK,CAAA;QAAA;AAED,aAAA,UAAU,CAAA;AACV,aAAA,UAAoB,CAAA;AACpB,aAAA,QAAkB,CAAA;AAClB,aAAA,YAAmC,CAAA;AACnC,aAAA,aAAoC,CAAA;AACpC,aAAA,UAA6B;UACjC,SAAS;UACT,WAAW;UACX,YAAY;QAAA;MAAA;IAAA;AAIX,wBAAA,MAAoD;MAApD,cAvBP;AAwBG,aAAA,SAAS;AACT,aAAA,OAAO;UACJ,OAAO;UACP,QAAQ;QAAA;AAEX,aAAA,SAAS;UACN,OAAO;UACP,QAAQ;QAAA;AAEX,aAAA,UAAU;MAAA;MAEV,WAAW;AACR,eAAO,KAAK;MAAA;IAAA;EAAA;AAAA,CAAA;AC7BlB,SAAA,wBACG,gBACgC;AAChC,SAAQ,eAAe,UAAU,eAAe,WAAW;IACxD,aAAa;IACb,UAAU;IACV,aAAa;IACb,YAAY;IACZ,QAAQ,EAAE,OAAO,GAAG,OAAO,EAAA;IAC3B,OAAO,EAAE,OAAO,GAAG,OAAO,EAAA;EAAA;AAAA;AAIhC,SAAA,cAAuB,QAAgB;AACpC,QAAM,QAAQ,YAAY,KAAK,MAAA;AAC/B,QAAM,QAAQ,eAAe,KAAK,MAAA;AAElC,SAAO;IACJ,OAAO,SAAU,SAAS,MAAM,CAAA,KAAO,GAAA;IACvC,OAAO,SAAU,SAAS,MAAM,CAAA,KAAO,GAAA;EAAA;AAAA;AA1B7C,IA8Ba;AA9Bb,IAAA,4BAAA,MAAA;EAAA,4CAAA;AAKA,eAAA;AAyBa,kCACV;MACG,IAAI,iBACD,kEACA,CAAC,QAAQ,CAAC,QAAQ,KAAA,MAAW;AAC1B,cAAM,MAAM,OAAO,YAAA;AACnB,cAAM,cAAc,wBAAwB,OAAO,cAAA;AAEnD,eAAO,OAAO,aAAa,EAAA,CAAG,GAAA,GAAM,SAAS,KAAA,EAAA,CAAA;MAAA,CAAA;MAGnD,IAAI,iBACD,gFACA,CAAC,QAAQ,CAAC,QAAQ,KAAA,MAAW;AAC1B,cAAM,MAAM,OAAO,YAAA;AACnB,cAAM,cAAc,wBAAwB,OAAO,cAAA;AAEnD,eAAO,OAAO,aAAa,EAAA,CAAG,GAAA,GAAM,SAAS,KAAA,EAAA,CAAA;MAAA,CAAA;MAGnD,IAAI,iBACD,qDACA,CAAC,QAAQ,CAAC,OAAO,QAAQ,UAAA,MAAgB;AACtC,cAAM,UAAU,wBAAwB,OAAO,cAAA;AAC/C,gBAAQ,QAAQ,cAAc,KAAA;AAC9B,gBAAQ,SAAS,cAAc,MAAA;AAC/B,gBAAQ,aAAa,SAAS,UAAA;MAAA,CAAA;IAAA;EAAA;AAAA,CAAA;AC3BnC,SAAA,oBACJ,SACA,QACoB;AACpB,SAAO,oBAAoB,EAAE,gBAAgB,IAAI,qBAAA,EAAA,GAA+B,UAAS,MAAA;AAAA;AAjC5F,IAIM;AAJN,IAoCO;AApCP,IAAA,6BAAA,MAAA;EAAA,6CAAA;AACA,eAAA;AACA,8BAAA;AAEM,eACH;MACG,IAAI,iBAAiB,oBAAoB,CAAC,QAAQ,CAAC,IAAA,MAAU;AAC1D,eAAO,eAAe,IAAI,KAAK,KAAK,KAAA,CAAA;AACpC,eAAO;MAAA,CAAA;MAEV,GAAG;MACH,IAAI,iBACD,CAAC,oCAAoC,qBAAA,GACrC,CAAC,QAAQ,CAAC,cAAA,MAAoB;AAC1B,eAAO,eAA4C,iBAAiB;MAAA,CAAA;MAG3E,IAAI,iBACD,CAAC,6CAA6C,qBAAA,GAC9C,CAAC,QAAQ,CAAC,OAAO,SAAS,GAAA,MAAS;AAC/B,eAAO,eAA4C,kBAAkB;UACnE,OAAO,SAAS,KAAA;UAChB;UACA;QAAA;MAAA,CAAA;IAAA;AAaR,2BAAA,MAAqD;MAArD,cApCP;AAqCmB,aAAA,MAAgB,CAAA;MAAA;IAAA;EAAA;AAAA,CAAA;AC0B5B,SAAA,qBAA8B,QAAgB,QAAgB;AAClE,QAAM,YAAY,oBAAoB,IAAI,kBAAA,GAAqB,cAAc,CAAC,QAAQ,MAAA,CAAA;AAEtF,SAAO,UAAU,WAAW;AAAA;AAlE/B,IAMM;AANN,IAOM;AAPN,IAQM;AARN,IAUM;AAVN,IAqCM;AArCN,IAmDa;AAnDb,IAuDa;AAvDb,IAAA,kBAAA,MAAA;EAAA,kCAAA;AACA,qBAAA;AAEA,eAAA;AACA,+BAAA;AAEM,wBAAoB;AACpB,oBAAgB;AAChB,mBAAe;AAEf,eAAoC;MACvC,IAAI,WAAW,mBAAmB,CAAC,QAAQ,CAAC,MAAM,YAAY,SAAA,MAAe;AAC1E,eAAO,MAAM,KAAK,IAAA;AAElB,YAAI,YAAY;AACb,iBAAO,WAAW,IAAA,IAAQ,WAAW;QAAA;AAGxC,YAAI,WAAW;AACZ,iBAAO,UAAU,IAAA,IAAQ,UAAU;QAAA;MAAA,CAAA;MAGzC,IAAI,WAAW,eAAe,CAAC,QAAQ,CAAC,SAAS,EAAE,YAAY,EAAE,SAAA,MAAe;AAC7E,YAAI,eAAe,UAAa,cAAc,QAAW;AACtD,iBAAO,QAAQ,UAAU,CAAC,WAAW;AACrC,iBAAO,QAAQ,aAAa,CAAC,cAAc;AAC3C,iBAAO,QAAQ,YAAY,CAAC,aAAa;AACzC,iBAAO;QAAA;AAEV,eAAO;MAAA,CAAA;MAEV,IAAI,WAAW,cAAc,CAAC,QAAQ,CAAC,QAAQ,IAAA,MAAU;AACtD,eAAO,OAAO,OAAO,IAAA;AACrB,eAAO,WAAW,WAAW,OAAO,UAAU,OAAO,SAAS,IAAA;MAAA,CAAA;IAAA;AAI9D,mBAA+C;MAClD,IAAI,WAAW,iBAAiB,CAAC,QAAQ,CAAC,MAAA,MAAY,MAAM,OAAO,SAAS,OAAA;MAC5E,IAAI,WAAW,kBAAkB,CAAC,QAAQ,CAAC,OAAA,MAAa,MAAM,OAAO,UAAU,QAAA;MAC/E,IAAI,WACD,oDACA,CAAC,QAAQ,CAAC,WAAW,YAAY,aAAa,YAAA,MAAkB;AAC7D,eAAO,OAAO,QAAQ;AACtB,eAAO,KAAK,QAAQ;AACpB,eAAO,OAAO,SAAS;AACvB,eAAO,KAAK,SAAS;MAAA,CAAA;IAAA;AAKjB,sBAAkD,CAAC,QAAQ,WAAW;AAChF,aAAO,oBAAoB,IAAI,YAAA,GAAe,UAAS,CAAC,QAAQ,MAAA,CAAA;IAAA;AAGtD,sBAAkD,CAAC,QAAQ,WAAW;AAChF,aAAO,OAAO,OACX,IAAI,YAAA,GACJ,gBAAgB,QAAQ,MAAA,GACxB,oBAAoC,QAAQ,MAAA,CAAA;IAAA;EAAA;AAAA,CAAA;AC3DlD,IAMM;AANN,IA8Ba;AA9Bb,IAsCa;AAtCb,IAAA,mBAAA,MAAA;EAAA,mCAAA;AACA,sBAAA;AAEA,eAAA;AACA,oBAAA;AAEM,eAAqC;MACxC,IAAI,WAAW,yBAAyB,CAAC,SAAS,CAAC,SAAA,MAAe;AAC/D,gBAAQ,OAAO,KAAK,SAAA;MAAA,CAAA;MAEvB,IAAI,WAAW,iDAAiD,CAAC,SAAS,CAAC,QAAQ,IAAA,MAAU;AAC1F,gBAAQ,UAAU,KAAK,IAAI,qBAAqB,QAAQ,IAAA,CAAA;MAAA,CAAA;MAE3D,IAAI,WACD,0DACA,CAAC,SAAS,CAAC,QAAQ,MAAM,SAAA,MAAe;AACrC,gBAAQ,UAAU,KAAK,IAAI,qBAAqB,QAAQ,MAAM,EAAE,UAAA,CAAA,CAAA;MAAA,CAAA;MAGtE,IAAI,WAAW,yBAAyB,CAAC,SAAS,CAAC,MAAA,MAAY;AAC5D,gBAAQ,UAAU,KAAK,IAAI,qBAAqB,QAAQ,IAAA,CAAA;MAAA,CAAA;MAE3D,IAAI,WAAW,oCAAoC,CAAC,SAAS,CAAC,MAAA,MAAY;AACvE,gBAAQ,SAAS;MAAA,CAAA;IAAA;AAOV,uBAAoD,CAAC,QAAQ,WAAW;AAClF,aAAO,OAAO,OAAO,iBAAiB,QAAQ,MAAA,GAAS,gBAAgB,QAAQ,MAAA,CAAA;IAAA;AAOrE,uBAAoD,CAAC,WAAW;AAC1E,aAAO,oBAAoB,IAAI,mBAAA,GAAsB,UAAS,MAAA;IAAA;EAAA;AAAA,CAAA;ACjC1D,SAAA,UAAmB,YAA2D;AAClF,MAAI,CAAC,WAAW,QAAQ;AACrB,WAAO,uBAAuB,wCAAA;EAAA;AAGjC,SAAO;IACJ,UAAU,CAAC,SAAS,GAAG,UAAA;IACvB,QAAQ;IACR,OAAO,QAAQ,QAAqB;AACjC,YAAM,QAAQ,iBAAiB,QAAQ,MAAA;AACvC,UAAI,MAAM,QAAQ;AACf,cAAM,IAAI,iBAAiB,KAAA;MAAA;AAG9B,aAAO;IAAA;EAAA;AAAA;AApBhB,IAAA,aAAA,MAAA;EAAA,2BAAA;AACA,4BAAA;AACA,qBAAA;AAEA,cAAA;EAAA;AAAA,CAAA;ACMA,SAAA,qBAA8B,OAAe,QAAgB,QAAsC;AAChG,QAAM,UAAU,OAAO,SAAS,SAAA;AAChC,QAAM,MAAM,OAAO,SAAS,KAAA,KAAU,cAAc,KAAK,KAAA;AACzD,QAAM,iBAAiB,CAAC,OAAO,SAAS,KAAA;AAExC,SAAO;IACJ;IACA;IACA,QAAQ,CAAC;IACT,KAAK,CAAC;IACN;IACA;IACA;EAAA;AAAA;AAtBN,IA0BM;AA1BN,IAmEa;AAnEb,IA6Ea;AA7Eb,IAAA,kBAAA,MAAA;EAAA,kCAAA;AAOA,eAAA;AACA,+BAAA;AAkBM,eAAoC;MACvC,IAAI,WAAW,qBAAqB,CAAC,QAAQ,CAAC,IAAA,MAAU;AACrD,eAAO,OAAO;MAAA,CAAA;MAEjB,IAAI,WAAW,uCAAuC,CAAC,QAAQ,CAAC,KAAA,MAAW;AACxE,eAAO,MAAM,cAAA,eAAA,CAAA,GACN,OAAO,OAAO,CAAA,CAAA,GADR;UAEV;QAAA,CAAA;MAAA,CAAA;MAGN,IAAI,WAAW,qCAAqC,CAAC,QAAQ,CAAC,OAAO,QAAQ,IAAA,MAAU;AACpF,eAAO,OAAO,KAAK,qBAAqB,OAAO,QAAQ,IAAA,CAAA;MAAA,CAAA;MAE1D,IAAI,WACD,4EACA,CAAC,QAAQ,CAAC,OAAO,QAAQ,UAAA,MAAgB;AACtC,eAAO,SAAS,cAAA,eAAA,CAAA,GACT,OAAO,UAAU,CAAA,CAAA,GADR;UAEb;UACA;UACA;QAAA,CAAA;MAAA,CAAA;MAIT,IAAI,WACD,gDACA,CAAC,QAAQ,CAAC,OAAO,QAAQ,MAAM,EAAA,MAAQ;AACpC,eAAO,SAAS;UACb,MAAM;YACH;YACA;UAAA;UAEH,MAAM;YACH;YACA;UAAA;QAAA;MAAA,CAAA;IAAA;AAOF,sBAAkD,CAAC,QAAQ,WAAW;AAChF,YAAM,aAAa,gBAAgB,QAAQ,MAAA;AAC3C,YAAM,iBAAiB,oBAA8C,QAAQ,MAAA;AAE7E,aAAO,eAAA,eAAA,CAAA,GACD,UAAA,GACA,cAAA;IAAA;AAII,sBAAkD,CAAC,QAAQ,WAAW;AAChF,aAAO,oBAAoB,EAAE,QAAQ,CAAA,EAAA,GAAM,UAAS,CAAC,QAAQ,MAAA,CAAA;IAAA;EAAA;AAAA,CAAA;AC9EhE,IAAA,eAAA,CAAA;AAAAA,UAAA,cAAA;EAAA,cAAA,MAAA;EAAA,UAAA,MAAA;AAAA,CAAA;AAOO,SAAA,aAAsB,MAAe,CAAA,GAAI,YAA8C;AAC3F,SAAO,YAAY,QAAA;AACnB,SAAO,SAAS,KAAK,UAAA;AAAA;AAGjB,SAAA,SAAkB,MAAe,CAAA,GAAI,YAA8C;AACvF,QAAM,WAAW,CAAC,QAAQ,GAAG,UAAA;AAC7B,MAAI,IAAI,QAAQ;AACb,aAAS,OAAO,GAAG,GAAG,IAAI,MAAA;EAAA;AAE7B,MAAI,IAAI,QAAQ;AACb,aAAS,OAAO,GAAG,GAAG,IAAI,MAAA;EAAA;AAG7B,SAAO,UAAU,IAAA;AACjB,SAAO,UAAU,WAAA;AACjB,SAAO,UAAU,aAAA;AAEjB,SAAO;IACJ;IACA,QAAQ;IACR,QAAA;EAAA;AAAA;AA5BN,IAAA,YAAA,MAAA;EAAA,0BAAA;AACA,oBAAA;AAEA,eAAA;EAAA;AAAA,CAAA;ACEe,SAAA,eAAoD;AAChE,SAAO;IACJ,aAA+B;AAC5B,YAAM,WAAW,CAAC,QAAQ,GAAG,mBAAmB,WAAW,CAAA,CAAA;AAC3D,UAAI,CAAC,SAAS,SAAS,UAAA,GAAa;AACjC,iBAAS,OAAO,GAAG,GAAG,UAAA;MAAA;AAGzB,aAAO,KAAK,SACT,0BAA0B,QAAA,GAC1B,yBAAyB,SAAA,CAAA;IAAA;IAI/B,OAAyB;AACtB,YAAM,WAAW,CAAC,QAAQ,GAAG,mBAAmB,WAAW,CAAA,CAAA;AAC3D,aAAO,KAAK,SACT,0BAA0B,QAAA,GAC1B,yBAAyB,SAAA,CAAA;IAAA;EAAA;AAAA;AAvBrC,IAAA,YAAA,MAAA;EAAA,0BAAA;AAEA,eAAA;AACA,cAAA;EAAA;AAAA,CAAA;ACHA,IAEa;AAFb,IAIO;AAJP,IAAA,yBAAA,MAAA;EAAA,2CAAA;AAEa,oBAAgB;AAEtB,wBAAA,MAAoD;MAGxD,YACU,MACA,OACA,aACR;AAHQ,aAAA,OAAA;AACA,aAAA,QAAA;AACA,aAAA,cAAA;AAEP,YAAY,QAAQ,gBAAhB,KAA6B;AAC9B,gBAAM,SAAS,cAAc,KAAK,IAAA,KAAS,CAAC,MAAM,MAAM,IAAA;AACxD,eAAK,OAAO,OAAO,CAAA,KAAM;AACzB,eAAK,OAAO,OAAO,CAAA,KAAM;QAAA;MAAA;IAAA;EAAA;AAAA,CAAA;ACwBlC,SAAA,YAAqB,MAAc;AAChC,QAAM,CAAC,IAAI,IAAA,IAAQ,KAAK,MAAM,IAAA;AAE9B,SAAO;IACJ,MAAM,QAAQ;IACd;EAAA;AAAA;AAIN,SAAA,QACG,QACA,QACA,SAC2B;AAC3B,SAAO,CAAC,GAAG,SAAS,UAAU,OAAA;AAAA;AAGjC,SAAA,UAAmB,WAAgC,QAA+B;AAC/E,SAAO,OAAO,IAAI,CAAC,MAAM,QAAO,QAAQ,GAAG,CAAC,QAAQ,SAAS,OAAO,OAAO,YAAY,IAAA,CAAA,CAAA;AAAA;AA6H1F,SAAA,UAAmB,QAAsB,SAAiB;AACvD,QAAM,WAAU,QAAQ,KAAA;AACxB,UAAQ,KAAA;IAAA,KACA,SAAQ,OAAO,CAAA;AACjB,aAAO,KAAK,SAAQ,OAAO,CAAA,GAAI,SAAQ,OAAO,CAAA,GAAI,SAAQ,OAAO,CAAA,CAAA;IAAA,KAC/D,SAAQ,OAAO,CAAA;AACjB,aAAO,KAAK,KAA0B,SAAQ,OAAO,CAAA,GAAI,SAAQ,OAAO,CAAA,CAAA;IAAA;AAExE;EAAA;AAGN,WAAA,KAAc,OAAe,YAAoB,MAAc;AAC5D,UAAM,MAAM,GAAG,QAAQ;AACvB,UAAM,UAAU,SAAQ,IAAI,GAAA;AAE5B,QAAI,SAAS;AACV,cAAQ,QAAQ,IAAA;IAAA;AAGnB,QAAI,QAAQ,QAAQ,QAAQ,MAAM;AAC/B,aAAO,MAAM,KAAK,IAAI,kBAAkB,KAAK,QAAQ,SAAS,EAAA,GAAK,OAAO,UAAA,CAAA;IAAA;EAAA;AAAA;AA1MnF,IAMO;AANP,IA4DM;AA5DN,IAiKa;AAjKb,IAAA,qBAAA,MAAA;EAAA,uCAAA;AACA,eAAA;AACA,2BAAA;AAIO,oBAAA,MAA4C;MAA5C,cANP;AAOU,aAAA,YAAY,CAAA;AACZ,aAAA,aAAa,CAAA;AACb,aAAA,UAAU,CAAA;AACV,aAAA,UAAU,CAAA;AACV,aAAA,UAAU;AACV,aAAA,WAAW,CAAA;AACX,aAAA,UAAU,CAAA;AACV,aAAA,QAAQ,CAAA;AACR,aAAA,SAAS,CAAA;AACT,aAAA,QAAQ;AACR,aAAA,SAAS;AACT,aAAA,UAAU;AACV,aAAA,WAAW;AACX,aAAA,WAAW;AAEX,aAAA,UAAU,MAAM;AACpB,iBAAO,CAAC,KAAK,MAAM;QAAA;MAAA;IAAA;AAqCnB,eAAyC,IAAI,IAAI;MACpD,QAAO,KAA0B,KAA2B,CAAC,QAAQ,SAClE,OAAO,OAAO,SAAS,IAAA,CAAA;MAE1B,QAAO,KAA0B,KAA6B,CAAC,QAAQ,SACpE,OAAO,OAAO,SAAS,IAAA,CAAA;MAE1B,QAAO,KAA0B,KAA8B,CAAC,QAAQ,SACrE,OAAO,OAAO,UAAU,IAAA,CAAA;MAG3B,QACG,KACA,KACA,CAAC,QAAQ,SAAS,OAAO,OAAO,SAAS,IAAA,KAAS,OAAO,OAAO,QAAQ,IAAA,CAAA;MAE3E,QACG,KACA,KACA,CAAC,QAAQ,SACN,OAAO,OAAO,SAAS,IAAA,KACvB,OAAO,OAAO,QAAQ,IAAA,KACtB,OAAO,OAAO,UAAU,IAAA,CAAA;MAG9B,QACG,KACA,KACA,CAAC,QAAQ,SAAS,OAAO,OAAO,SAAS,IAAA,KAAS,OAAO,OAAO,QAAQ,IAAA,CAAA;MAG3E,QACG,KACA,KACA,CAAC,QAAQ,SAAS,OAAO,OAAO,UAAU,IAAA,KAAS,OAAO,OAAO,QAAQ,IAAA,CAAA;MAE5E,QACG,KACA,KACA,CAAC,QAAQ,SAAS,OAAO,OAAO,UAAU,IAAA,KAAS,OAAO,OAAO,QAAQ,IAAA,CAAA;MAG5E,QAAO,KAA6B,KAA0B,CAAC,QAAQ,SAAS;AAC7E,eAAO,OAAO,SAAS,YAAY,IAAA,CAAA;MAAA,CAAA;MAEtC,QAAO,KAA6B,KAA8B,CAAC,QAAQ,SAAS;AACjF,cAAM,UAAU,YAAY,IAAA;AAC5B,eAAO,OAAO,SAAS,OAAA;AACvB,eAAO,OAAO,UAAU,QAAQ,EAAA;MAAA,CAAA;MAEnC,QAAO,KAA6B,KAA6B,CAAC,SAAS,UAAU;AAClF,eAAQ,QAAQ,UAAU,QAAQ,WAAW,CAAA,GAAK,KAAA;MAAA,CAAA;MAGrD,QAAO,KAA+B,KAA+B,CAAC,QAAQ,SAC3E,OAAO,OAAO,WAAW,IAAA,CAAA;MAG5B,GAAG;QAAU;QAA2B;QAA2B;;MAAA;MACnE,GAAG;QACA;QACA;QACA;;MAAA;MAEH,GAAG;QACA;QACA;QACA;QACA;;MAAA;MAGH;QACG;QACA,CAAC,QAAQ,SAAS;AACf,gBAAM,WAAW;AACjB,gBAAM,YAAY;AAClB,gBAAM,aAAa;AACnB,gBAAM,cAAc;AACpB,gBAAM,mBAAmB;AACzB,cAAI;AAEJ,wBAAc,SAAS,KAAK,IAAA;AAC5B,iBAAO,QAAS,eAAe,CAAC,YAAY,CAAA,KAAO;AAEnD,wBAAc,UAAU,KAAK,IAAA;AAC7B,iBAAO,SAAU,eAAe,CAAC,YAAY,CAAA,KAAO;AAEpD,wBAAc,WAAW,KAAK,IAAA;AAC9B,iBAAO,UAAU,eAAe,YAAY,CAAA;AAE5C,wBAAc,YAAY,KAAK,IAAA;AAC/B,iBAAO,WAAW,eAAe,YAAY,CAAA;AAE7C,wBAAc,iBAAiB,KAAK,IAAA;AACpC,iBAAO,UAAW,eAAe,YAAY,CAAA,KAAO,OAAO;AAE3D,iBAAO,WAAW,gBAAgB,KAAK,IAAA;QAAA;MAAA;IAAA,CAAA;AAKnC,yBAAqB,SAAU,MAA4B;AACrE,YAAM,QAAQ,KAAK,MAAM,IAAA;AACzB,YAAM,SAAS,IAAI,cAAA;AAEnB,eAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,IAAI,KAAK;AACxC,YAAI,OAAO,MAAM,GAAA,EAAK,KAAA;AAEtB,YAAI,CAAC,MAAM;AACR;QAAA;AAGH,YAAI,KAAK,OAAO,CAAA,MAAO,KAA6B;AACjD,kBAAQ,QAAQ,MAAM,GAAA,KAAQ;QAAA;AAGjC,kBAAU,QAAQ,IAAA;MAAA;AAGrB,aAAO;IAAA;EAAA;AAAA,CAAA;AC7KH,SAAA,WAAoB,YAAgD;AACxE,QAAM,WAAW;IACd;IACA;IACA;IACA;IACA;IACA,GAAG,WAAW,OAAO,CAAC,QAAQ,CAAC,eAAe,SAAS,GAAA,CAAA;EAAA;AAG1D,SAAO;IACJ,QAAQ;IACR;IACA,OAAO,MAAc;AAClB,aAAO,mBAAmB,IAAA;IAAA;EAAA;AAAA;AApBnC,IAIM;AAJN,IAAA,cAAA,MAAA;EAAA,4BAAA;AACA,uBAAA;AAGM,qBAAiB,CAAC,UAAU,IAAA;EAAA;AAAA,CAAA;ACUlC,SAAA,gBACG,QAAQ,GACR,QAAQ,GACR,QAAyB,GACzB,QAAQ,IACR,YAAY,MACE;AACd,SAAO,OAAO,eACX;IACG;IACA;IACA;IACA;IACA;EAAA,GAEH,YACA;IACG,QAAQ;AACL,aAAO,GAAG,KAAK,SAAS,KAAK,SAAS,KAAK;IAAA;IAE9C,cAAc;IACd,YAAY;EAAA,CAAA;AAAA;AAKrB,SAAA,uBAAgC;AAC7B,SAAO,gBAAgB,GAAG,GAAG,GAAG,IAAI,KAAA;AAAA;AAGxB,SAAA,kBAAwC;AACpD,SAAO;IACJ,UAA4B;AACzB,aAAO,KAAK,SAAS;QAClB,UAAU,CAAC,WAAA;QACX,QAAQ;QACR,QAAQ;QACR,QAAQ,QAAQ,OAAO,MAAM,MAAM;AAChC,cAAI,OAAO,aAAa,IAAqB;AAC1C,mBAAO,KAAK,OAAO,KAAK,aAAA,CAAA;UAAA;AAG3B,eAAK,KAAA;QAAA;MAAA,CAAA;IAAA;EAAA;AAAA;AAyBpB,SAAA,cAAuB,QAAgB;AACpC,MAAI,WAAW,eAAe;AAC3B,WAAO,qBAAA;EAAA;AAGV,SAAO,oBAAoB,gBAAgB,GAAG,GAAG,GAAG,MAAA,GAAS,UAAS,MAAA;AAAA;AAtFzE,IAYM;AAZN,IA+DM;AA/DN,IAAA,eAAA,MAAA;EAAA,6BAAA;AAEA,eAAA;AAUM,oBAAgB;AAmDhB,eAAuC;MAC1C,IAAI,WACD,+CACA,CAAC,QAAQ,CAAC,OAAO,OAAO,OAAO,QAAQ,EAAA,MAAQ;AAC5C,eAAO,OACJ,QACA,gBAAgB,SAAS,KAAA,GAAQ,SAAS,KAAA,GAAQ,SAAS,KAAA,GAAQ,KAAA,CAAA;MAAA,CAAA;MAI5E,IAAI,WACD,qCACA,CAAC,QAAQ,CAAC,OAAO,OAAO,OAAO,QAAQ,EAAA,MAAQ;AAC5C,eAAO,OAAO,QAAQ,gBAAgB,SAAS,KAAA,GAAQ,SAAS,KAAA,GAAQ,OAAO,KAAA,CAAA;MAAA,CAAA;IAAA;EAAA;AAAA,CAAA;AC5ExF,IAAA,yBAAA,CAAA;AAAAA,UAAA,wBAAA;EAAA,cAAA,MAAA;AAAA,CAAA;AAAA,IA0BO;AA1BP,IAAA,sBAAA,MAAA;EAAA,8BAAA;AACA,uBAAA;AACA,kCAAA;AACA,kBAAA;AACA,gBAAA;AACA,gBAAA;AACA,sBAAA;AACA,cAAA;AACA,qBAAA;AACA,cAAA;AACA,aAAA;AACA,eAAA;AACA,cAAA;AACA,cAAA;AACA,gBAAA;AACA,cAAA;AACA,iBAAA;AAEA,eAAA;AAQO,mBAAA,MAA4C;MAChD,YAAoB,WAA8B;AAA9B,aAAA,YAAA;MAAA;MAEV,SAAY,MAAwB,MAAiC;AAC5E,cAAM,QAAQ,KAAK,UAAU,MAAA;AAC7B,cAAM,UAAU,MAAM,KAAK,IAAA;AAE3B,YAAI,MAAM;AACP,uBAAa,MAAM,SAAS,IAAA;QAAA;AAG/B,eAAO,OAAO,OAAO,MAAM;UACxB,MAAM,EAAE,OAAO,QAAQ,KAAK,KAAK,OAAA,EAAA;UACjC,OAAO,EAAE,OAAO,QAAQ,MAAM,KAAK,OAAA,EAAA;UACnC,WAAW,EAAE,OAAO,MAAA;QAAA,CAAA;MAAA;MAI1B,IAAI,OAA0B;AAC3B,eAAO,KAAK,SACT,0BAA0B,CAAC,OAAO,GAAG,QAAQ,KAAA,CAAA,CAAA,GAC7C,yBAAyB,SAAA,CAAA;MAAA;MAI/B,IAAI,WAAsD;AACvD,cAAM,OAAO,yBAAyB,SAAA;AAEtC,YAAI,OAAO,cAAc,UAAU;AAChC,iBAAO,KAAK,SAAS,2BAA2B,WAAW,KAAK,SAAA,GAAY,IAAA;QAAA;AAG/E,YAAI,QAAO,aAAA,OAAA,SAAA,UAAW,UAAS,UAAU;AACtC,iBAAO,KAAK,SACT,2BACG,UAAU,MACT,UAAU,QAAQ,KAAK,aAAc,MAAA,GAEzC,IAAA;QAAA;AAIN,eAAO,KAAK,SACT,uBAAuB,wDAAA,GACvB,IAAA;MAAA;MAIN,WAAW,MAAc,OAA0B;AAChD,eAAO,KAAK,SACT,eAAe,MAAM,UAAU,IAAA,GAC/B,yBAAyB,SAAA,CAAA;MAAA;MAI/B,KAAK,MAA0B;AAC5B,eAAO,KAAK,SACT,SAAS,SAAS,MAAM,KAAK,UAAU,KAAK,mBAAmB,SAAA,CAAA,GAC/D,yBAAyB,SAAA,CAAA;MAAA;MAI/B,QAAQ;AACL,eAAO,KAAK,SACT,UAAU,mBAAmB,SAAA,CAAA,GAC7B,yBAAyB,SAAA,CAAA;MAAA;MAI/B,YAAY,QAAgB,QAAgB;AACzC,YAAI,EAAE,aAAa,MAAA,KAAW,aAAa,MAAA,IAAU;AAClD,iBAAO,KAAK,SACT,uBACG,2FAAA,CAAA;QAAA;AAKT,eAAO,KAAK,SACT,UAAU,CAAC,QAAQ,QAAQ,GAAG,mBAAmB,SAAA,CAAA,CAAA,GACjD,yBAAyB,WAAW,KAAA,CAAA;MAAA;MAI1C,cAAc,SAAwB;AACnC,aAAK,UAAU,gBAAgB;AAC/B,eAAO;MAAA;MAGV,OAAO;AACJ,cAAM,OAAO,SACV;UACG,QAAQ,WAAW,UAAU,CAAA,GAAI,YAAA;UACjC,QAAQ,WAAW,UAAU,CAAA,GAAI,YAAA;QAAA,GAEpC,mBAAmB,SAAA,CAAA;AAGtB,eAAO,KAAK,SAAS,MAAM,yBAAyB,SAAA,CAAA;MAAA;MAGvD,QAAQ;AACL,eAAO,KAAK,SACT,0BAA0B,CAAC,SAAS,GAAG,mBAAmB,SAAA,CAAA,CAAA,GAC1D,yBAAyB,SAAA,CAAA;MAAA;MAI/B,SAAS;AACN,eAAO,KAAK,SACT,WAAW,mBAAmB,SAAA,CAAA,GAC9B,yBAAyB,SAAA,CAAA;MAAA;IAAA;AAKlC,WAAO,OACJ,aAAa,WACb,iBAAA,GACA,eAAA,GACA,eAAA,GACA,qBAAA,GACA,aAAA,GACA,YAAA,GACA,aAAA,GACA,gBAAA,CAAA;EAAA;AAAA,CAAA;ACvJH,IAAA,oBAAA,CAAA;AAAAA,UAAA,mBAAA;EAAA,WAAA,MAAA;AAAA,CAAA;AAAA,IASM;AATN,IAuBO;AAvBP,IAAA,iBAAA,MAAA;EAAA,iCAAA;AAAA,eAAA;AAEA,oBAAA;AAOM,2BAA4C,MAAM;AACrD,UAAI,KAAK;AACT,aAAO,MAAM;AACV;AACA,cAAM,EAAE,SAAS,KAAA,QAAS,wCAAA;AAE1B,eAAO;UACJ;UACA;UACA;QAAA;MAAA;IAAA,GAAA;AAKF,gBAAA,MAAgB;MAKpB,YAAoB,cAAc,GAAG;AAAjB,aAAA,cAAA;AAJZ,aAAA,SAAS,aAAa,IAAI,WAAA;AAC1B,aAAA,UAA2B,CAAA;AAC3B,aAAA,UAA2B,CAAA;AAGhC,aAAK,OAAO,+BAA+B,WAAA;MAAA;MAGtC,WAAW;AAChB,YAAI,CAAC,KAAK,QAAQ,UAAU,KAAK,QAAQ,UAAU,KAAK,aAAa;AAClE,eAAK,OACF,kEACA,KAAK,QAAQ,QACb,KAAK,QAAQ,QACb,KAAK,WAAA;AAER;QAAA;AAGH,cAAM,OAAO,OAAO,KAAK,SAAS,KAAK,QAAQ,MAAA,CAAA;AAC/C,aAAK,OAAO,oBAAoB,KAAK,EAAA;AACrC,aAAK,KAAK,MAAM;AACb,eAAK,OAAO,kBAAkB,KAAK,EAAA;AACnC,iBAAO,KAAK,SAAS,IAAA;AACrB,eAAK,SAAA;QAAA,CAAA;MAAA;MAIX,OAA0C;AACvC,cAAM,EAAE,SAAS,GAAA,IAAO,OAAO,KAAK,SAAS,oBAAA,CAAA;AAC7C,aAAK,OAAO,oBAAoB,EAAA;AAEhC,aAAK,SAAA;AAEL,eAAO;MAAA;IAAA;EAAA;AAAA,CAAA;AC1Db,IAAA,sBAAA,CAAA;AAAAA,UAAA,qBAAA;EAAA,gBAAA,MAAA;AAAA,CAAA;AAgCO,SAAA,eAAwB,SAAmB,YAA0C;AACzF,SAAO,0BAA0B,CAAC,SAAS,GAAG,YAAY,GAAG,OAAA,CAAA;AAAA;AAjChE,IAAA,mBAAA,MAAA;EAAA,iCAAA;AAAA,cAAA;EAAA;AAAA,CAAA;ACiBO,SAAA,sBAA+B,QAAgB,MAAyC;AAC5F,SAAO;IACJ;IACA;IACA,SAAS;EAAA;AAAA;AAIR,SAAA,sBAA+B,QAA2C;AAC9E,SAAO;IACJ;IACA,MAAM;IACN,SAAS;EAAA;AAAA;AA7Bf,IAOO;AAPP,IAAA,2BAAA,MAAA;EAAA,6CAAA;AAOO,0BAAA,MAA6D;MAA7D,cAPP;AAQG,aAAA,MAAkC,CAAA;AAClC,aAAA,WAA+D,CAAA;AAC/D,aAAA,SAAqC,CAAA;MAAA;MAAA,IAEjC,UAAmB;AACpB,eAAO,CAAC,KAAK,OAAO;MAAA;IAAA;EAAA;AAAA,CAAA;ACsBnB,SAAA,uBAAgC,MAAc,iBAAqC;AACvF,SAAO,oBAAoB,KAAmB,iBAAiB,KAAK,IAAA;AAAA;AApCvE,IASM;AATN,IAUM;AAVN,IAYM;AAZN,IA4Ba;AA5Bb,IAAA,2BAAA,MAAA;EAAA,2CAAA;AACA,6BAAA;AAMA,eAAA;AAEM,yBAAqB;AACrB,uBAAmB;AAEnB,eAAiD;MACpD,IAAI,WAAW,oBAAoB,CAAC,QAAQ,CAAC,QAAQ,IAAA,MAAU;AAC5D,cAAM,WAAW,sBAAsB,QAAQ,IAAA;AAE/C,eAAO,IAAI,KAAK,QAAA;AAChB,eAAO,SAAS,MAAA,IAAU;MAAA,CAAA;MAE7B,IAAI,WAAW,kBAAkB,CAAC,QAAQ,CAAC,MAAA,MAAY;AACpD,cAAM,WAAW,sBAAsB,MAAA;AAEvC,eAAO,OAAO,KAAK,QAAA;AACnB,eAAO,IAAI,KAAK,QAAA;AAChB,eAAO,SAAS,MAAA,IAAU;MAAA,CAAA;IAAA;AAInB,2BAAoE,CAC9E,QACA,WACE;AACF,aAAO,oBAAoB,IAAI,oBAAA,GAAuB,UAAS,CAAC,QAAQ,MAAA,CAAA;IAAA;EAAA;AAAA,CAAA;AChC3E,IAOO;AAPP,IAAA,qBAAA,MAAA;EAAA,uCAAA;AAOO,0BAAA,MAAmD;MAAnD,cAPP;AAQU,aAAA,MAAgB,CAAA;AAChB,aAAA,WAAiD,CAAA;AACjD,aAAA,UAAkB;AAClB,aAAA,WAAoB;MAAA;MAE3B,KACG,QACA,UACA,MACA,QACA,OACD;AACC,YAAI,WAAW,KAAgC;AAC5C,eAAK,WAAW;AAChB,eAAK,UAAU;QAAA;AAGlB,aAAK,IAAI,KAAK,IAAA;AACd,aAAK,SAAS,IAAA,IAAQ;UACnB,SAAS,WAAW;UACpB,gBAAgB,WAAW;UAC3B;UACA;UACA;QAAA;MAAA;IAAA;EAAA;AAAA,CAAA;ACZT,SAAA,aAAsB,OAAgB;AACnC,SAAO,QAAQ,MAAM,OAAO,CAAA,IAAK;AAAA;AAG7B,SAAA,mBAA4B,QAA+B;AAC/D,SAAO,oBAAoB,IAAI,oBAAA,GAAuB,UAAS,MAAA;AAAA;AAxBlE,IAIM;AAJN,IAAA,oBAAA,MAAA;EAAA,oCAAA;AACA,uBAAA;AACA,eAAA;AAEM,eAA6C;MAChD,IAAI,WACD,2EACA,CAAC,QAAQ,CAAC,SAAS,MAAM,QAAQ,KAAA,MAAW;AACzC,eAAO,KAAK,aAAa,OAAA,GAAU,MAAM,MAAM,QAAQ,KAAA;MAAA,CAAA;MAG7D,IAAI,WACD,0CACA,CAAC,QAAQ,CAAC,SAAS,MAAM,QAAQ,KAAA,MAAW;AACzC,eAAO,KAAK,aAAa,OAAA,GAAU,OAAO,MAAM,QAAQ,KAAA;MAAA,CAAA;IAAA;EAAA;AAAA,CAAA;ACdjE,IAAA,iBAAA,CAAA;AAAAA,UAAA,gBAAA;EAAA,iBAAA,MAAA;EAAA,YAAA,MAAA;EAAA,6BAAA,MAAA;EAAA,kBAAA,MAAA;EAAA,oBAAA,MAAA;AAAA,CAAA;AAOO,SAAA,4BAAqC,UAAoB;AAC7D,QAAM,iBAAiB,CAAC,MAAM,MAAM,UAAA;AACpC,SAAO,SAAS,KAAK,CAAC,YAAY,eAAe,SAAS,OAAA,CAAA;AAAA;AAGtD,SAAA,WACJ,YACqD;AACrD,QAAM,WAAW,4BAA4B,UAAA;AAC7C,QAAM,WAAW,CAAC,UAAU,GAAG,UAAA;AAE/B,MAAI,SAAS,WAAW,GAAG;AACxB,aAAS,KAAK,IAAA;EAAA;AAGjB,MAAI,CAAC,SAAS,SAAS,IAAA,GAAO;AAC3B,aAAS,OAAO,GAAG,GAAG,IAAA;EAAA;AAGzB,SAAO;IACJ,QAAQ;IACR;IACA,OAAO,QAAQ,QAAQ;AACpB,UAAI,UAAU;AACX,eAAO,qBAAqB,QAAQ,MAAA,EAAQ,IAAI,CAAA;MAAA;AAGnD,aAAO,mBAAmB,MAAA;IAAA;EAAA;AAAA;AAK5B,SAAA,kBAAsD;AAC1D,QAAM,UAAS;AAEf,SAAO;IACJ,QAAQ;IACR,UAAU,CAAC,UAAU,IAAA;IACrB,QAAA;EAAA;AAAA;AAIC,SAAA,mBACJ,UACA,cAAc,OACsB;AACpC,SAAO;IACJ,QAAQ;IACR,UAAU,CAAC,UAAU,MAAM,cAAc,OAAO,MAAM,GAAG,QAAA;IACzD,OAAO,QAAQ,QAAQ;AACpB,aAAO,qBAAqB,QAAQ,MAAA;IAAA;IAEvC,QAAQ,EAAE,UAAU,OAAA,GAAU,OAAO,MAAM,MAAM;AAC9C,UAAI,CAAC,uBAAuB,OAAO,KAAA,GAAQ,QAAA,GAAW;AACnD,eAAO,KAAK,KAAA;MAAA;AAGf,WAAK,MAAA;IAAA;EAAA;AAAA;AAKP,SAAA,iBACJ,QACA,cAAc,OACuB;AACrC,QAAM,OAA6C;IAChD,QAAQ;IACR,UAAU,CAAC,UAAU,MAAM,cAAc,OAAO,MAAM,MAAA;IACtD,OAAO,QAAQ,QAAQ;AACpB,aAAO,qBAAqB,QAAQ,MAAA,EAAQ,SAAS,MAAA;IAAA;IAExD,QAAQ,EAAE,UAAU,QAAQ,OAAA,GAAU,OAAO,GAAG,MAAM;AACnD,UAAI,CAAC,uBAAuB,OAAO,KAAA,GAAQ,QAAA,GAAW;AACnD,eAAO,KAAK,KAAA;MAAA;AAGf,YAAM,IAAI,iBACP,KAAK,OAAO,eAAe,MAAA,GAAS,eAAe,MAAA,CAAA,GACnD,OAAO,KAAA,CAAA;IAAA;EAAA;AAKhB,SAAO;AAAA;AA3FV,IAAA,cAAA,MAAA;EAAA,4BAAA;AAEA,4BAAA;AACA,6BAAA;AACA,sBAAA;AACA,eAAA;EAAA;AAAA,CAAA;ACLA,IAGa;AAHb,IAAA,mBAAA,MAAA;EAAA,qCAAA;AAGa,uBAAmB,CAAC,SAA2B;AACzD,aAAO,KACH,MAAM,KAAA,EACN,IAAI,CAAC,SAAS,KAAK,KAAA,CAAA,EACnB,OAAO,CAAC,SAAS,CAAC,CAAC,IAAA;IAAA;EAAA;AAAA,CAAA;ACP1B,IAAA,uBAAA,CAAA;AAAAA,UAAA,sBAAA;EAAA,iBAAA,MAAA;AAAA,CAAA;AAGO,SAAA,gBAAyB,OAAuC;AACpE,SAAO;IACJ,UAAU,CAAC,gBAAgB,GAAG,KAAA;IAC9B,QAAQ;IACR,QAAQ;EAAA;AAAA;AAPd,IAAA,oBAAA,MAAA;EAAA,kCAAA;AACA,qBAAA;EAAA;AAAA,CAAA;ACDA,IAAA,gBAAA,CAAA;AAAAA,UAAA,eAAA;EAAA,iBAAA,MAAA;EAAA,WAAA,MAAA;AAAA,CAAA;AA+BA,SAAA,kBAA2B,SAAiB;AACzC,SAAO,sBAAsB,KAAK,OAAA;AAAA;AAG9B,SAAA,UACJ,MACA,WACA,YAC+B;AAC/B,QAAM,WAAW,CAAC,SAAS,GAAG,UAAA;AAE9B,eAAa,IAAA,KAAS,SAAS,KAAK,IAAA;AACpC,eAAa,SAAA,KAAc,SAAS,KAAK,SAAA;AAEzC,QAAM,SAAS,SAAS,KAAK,iBAAA;AAC7B,MAAI,QAAQ;AACT,WAAO,uBAAuB,gDAAA;EAAA;AAGjC,SAAO,0BAA0B,QAAA;AAAA;AAG7B,SAAA,gBACJ,MACA,WACA,YACD;AACC,SAAO,YAAY,UAAA;AAEnB,SAAO,UAAU,MAAM,WAAW,UAAA;AAAA;AA5DrC,IAAA,aAAA,MAAA;EAAA,2BAAA;AAAA,cAAA;AAEA,eAAA;EAAA;AAAA,CAAA;ACmCO,SAAA,iBAA0B,QAAgB,QAA6B;AAC3E,QAAM,SAAsB;IACzB,KAAK;IACL,QAAQ;IACR,UAAU,CAAA;IACV,MAAM,CAAA;IACN,SAAS,CAAA;IACT,SAAS,CAAA;EAAA;AAEZ,SAAO,oBAAoB,QAAQ,WAAS,CAAC,QAAQ,MAAA,CAAA;AAAA;AA9CxD,IAGM;AAHN,IAAA,mBAAA,MAAA;EAAA,mCAAA;AACA,eAAA;AAEM,gBAAqC;MACxC,IAAI,WAAW,cAAc,CAAC,QAAQ,CAAC,MAAA,MAAY;AAChD,eAAO,SAAS;MAAA,CAAA;MAEnB,IAAI,WAAW,uCAAuC,CAAC,QAAQ,CAAC,MAAM,QAAA,MAAc;AACjF,eAAO,SAAS,KAAK;UAClB;UACA;QAAA,CAAA;MAAA,CAAA;MAGN,IAAI,WAAW,oCAAoC,CAAC,QAAQ,CAAC,MAAM,QAAA,MAAc;AAC9E,eAAO,KAAK,KAAK;UACd;UACA;QAAA,CAAA;MAAA,CAAA;MAGN,IAAI,WAAW,iCAAiC,CAAC,QAAQ,CAAC,QAAA,MAAc;AACrE,eAAO,QAAQ,KAAK;UACjB;QAAA,CAAA;MAAA,CAAA;MAGN,IAAI,WACD,0CACA,CAAC,QAAQ,CAAC,MAAM,IAAI,MAAM,QAAA,MAAc;AACrC,eAAO,QAAQ,KAAK;UACjB;UACA;UACA;UACA;QAAA,CAAA;MAAA,CAAA;IAAA;EAAA;AAAA,CAAA;AC/BZ,IAAA,gBAAA,CAAA;AAAAA,UAAA,eAAA;EAAA,WAAA,MAAA;AAAA,CAAA;AAMA,SAAA,mBAA2B,SAAiB;AACzC,SAAO,sBAAsB,KAAK,OAAA;AAAA;AAG9B,SAAA,UACJ,QACA,QACA,YACoC;AACpC,QAAM,WAAW,CAAC,SAAS,GAAG,UAAA;AAC9B,MAAI,UAAU,QAAQ;AACnB,aAAS,KAAK,QAAQ,MAAA;EAAA;AAGzB,QAAM,SAAS,SAAS,KAAK,kBAAA;AAC7B,MAAI,QAAQ;AACT,WAAO,uBAAuB,gDAAA;EAAA;AAGjC,SAAO;IACJ;IACA,QAAQ;IACR,QAAQ;EAAA;AAAA;AA5Bd,IAAA,aAAA,MAAA;EAAA,2BAAA;AACA,qBAAA;AAGA,cAAA;EAAA;AAAA,CAAA;ACKO,SAAA,gBAAyB,QAA4B;AACzD,SAAO,oBAAoB,EAAE,OAAO,CAAA,EAAA,GAAM,WAAS,MAAA;AAAA;AAVtD,IAGM;AAHN,IAAA,kBAAA,MAAA;EAAA,kCAAA;AACA,eAAA;AAEM,gBAAoC;MACvC,IAAI,WAAW,2BAA2B,CAAC,QAAQ,CAAC,MAAM,EAAA,MAAQ;AAC/D,eAAO,MAAM,KAAK,EAAE,MAAM,GAAA,CAAA;MAAA,CAAA;IAAA;EAAA;AAAA,CAAA;ACLhC,IAAA,eAAA,CAAA;AAAAA,UAAA,cAAA;EAAA,UAAA,MAAA;AAAA,CAAA;AAKO,SAAA,SAAkB,MAAyB,IAAoC;AACnF,SAAO;IACJ,UAAU,CAAC,MAAM,MAAM,GAAG,QAAQ,IAAA,GAAO,EAAA;IACzC,QAAQ;IACR,QAAQ;EAAA;AAAA;AATd,IAAA,YAAA,MAAA;EAAA,0BAAA;AACA,oBAAA;AAEA,eAAA;EAAA;AAAA,CAAA;ACHA,IAAA,eAAA,CAAA;AAAAA,UAAA,cAAA;EAAA,UAAA,MAAA;AAAA,CAAA;AAMO,SAAA,SACJ,QACA,QACA,YACuB;AACvB,QAAM,WAAqB,CAAC,QAAQ,GAAG,UAAA;AACvC,MAAI,UAAU,QAAQ;AACnB,aAAS,OAAO,GAAG,GAAG,QAAQ,MAAA;EAAA;AAGjC,SAAO;IACJ;IACA,QAAQ;IACR,OAAO,QAAQ,QAAoB;AAChC,aAAO,gBAAgB,QAAQ,MAAA;IAAA;IAElC,QAAQ,QAAQ,QAAQ,OAAO,MAAM;AAClC,YAAM,YAAY,qBACf,eAAe,OAAO,MAAA,GACtB,eAAe,OAAO,MAAA,CAAA;AAEzB,UAAI,WAAW;AACZ,eAAO,KAAK,IAAI,iBAAiB,SAAA,CAAA;MAAA;AAGpC,WAAK,MAAA;IAAA;EAAA;AAAA;AA/Bd,IAAA,YAAA,MAAA;EAAA,0BAAA;AACA,4BAAA;AACA,oBAAA;AAEA,eAAA;EAAA;AAAA,CAAA;ACSO,SAAA,gBAAyB,MAAmC;AAChE,QAAM,UAAiD,CAAA;AAEvD,UAAQ,MAAM,CAAC,CAAC,IAAA,MAAW,QAAQ,IAAA,IAAQ,EAAE,KAAA,CAAA;AAE7C,SAAO,OAAO,OAAO,OAAA;AAAA;AAGjB,SAAA,uBAAgC,MAAgC;AACpE,QAAM,UAA8C,CAAA;AAEpD,UAAQ,MAAM,CAAC,CAAC,MAAM,KAAK,OAAA,MAAa;AACrC,QAAI,CAAC,QAAQ,eAAe,IAAA,GAAO;AAChC,cAAQ,IAAA,IAAQ;QACb;QACA,MAAM,EAAE,OAAO,IAAI,MAAM,GAAA;MAAA;IAAA;AAI/B,QAAI,WAAW,KAAK;AACjB,cAAQ,IAAA,EAAM,KAAK,QAAQ,QAAQ,WAAW,EAAA,CAAA,IAAuC;IAAA;EAAA,CAAA;AAI3F,SAAO,OAAO,OAAO,OAAA;AAAA;AAGxB,SAAA,QAAiB,MAAc,SAAmC;AAC/D,yBAAuB,MAAM,CAAC,SAAS,QAAQ,KAAK,MAAM,KAAA,CAAA,CAAA;AAAA;AAzC7D,IAAA,wBAAA,MAAA;EAAA,0CAAA;AAAA,eAAA;EAAA;AAAA,CAAA;ACAA,IAAA,iBAAA,CAAA;AAAAA,UAAA,gBAAA;EAAA,eAAA,MAAA;EAAA,gBAAA,MAAA;EAAA,iBAAA,MAAA;EAAA,YAAA,MAAA;EAAA,kBAAA,MAAA;AAAA,CAAA;AAIO,SAAA,cACJ,YACA,YACA,aAAuB,CAAA,GACJ;AACnB,SAAO,0BAA0B,CAAC,UAAU,OAAO,GAAG,YAAY,YAAY,UAAA,CAAA;AAAA;AAG1E,SAAA,eAAwB,SAAmC;AAC/D,QAAM,WAAW,CAAC,QAAA;AAClB,MAAI,SAAS;AACV,aAAS,KAAK,IAAA;EAAA;AAGjB,SAAO;IACJ;IACA,QAAQ;IACR,QAAQ,UAAU,yBAAyB;EAAA;AAAA;AAI1C,SAAA,gBAAyB,aAAuB,CAAA,GAAwB;AAC5E,QAAM,WAAW,CAAC,GAAG,UAAA;AACrB,MAAI,SAAS,CAAA,MAAO,aAAa;AAC9B,aAAS,QAAQ,WAAA;EAAA;AAGpB,SAAO,0BAA0B,QAAA;AAAA;AAG7B,SAAA,WAAoB,aAAuB,CAAA,GAAwB;AACvE,QAAM,WAAW,CAAC,GAAG,UAAA;AACrB,MAAI,SAAS,CAAA,MAAO,UAAU;AAC3B,aAAS,QAAQ,QAAA;EAAA;AAGpB,SAAO,0BAA0B,QAAA;AAAA;AAG7B,SAAA,iBAA0B,YAAoB;AAClD,SAAO,0BAA0B,CAAC,UAAU,UAAU,UAAA,CAAA;AAAA;AA5CzD,IAAA,cAAA,MAAA;EAAA,4BAAA;AAAA,0BAAA;AAEA,cAAA;EAAA;AAAA,CAAA;ACFA,IAAA,qBAAA,CAAA;AAAAA,UAAA,oBAAA;EAAA,eAAA,MAAA;AAAA,CAAA;AAQO,SAAA,cACJ,MAAkB,CAAA,GAClB,YACkC;AAClC,QAAM,UAAU,gBAAqB,GAAA;AACrC,QAAM,WAAW,CAAC,SAAS,QAAQ,GAAG,QAAQ,UAAU,GAAG,UAAA;AAC3D,QAAM,UAAS,2BACZ,QAAQ,UACR,QAAQ,QACR,qBAAqB,QAAA,CAAA;AAGxB,SACG,wBAAwB,QAAA,KAAa;IAClC;IACA,QAAQ;IACR,QAAA;EAAA;AAAA;AAxBT,IAAA,kBAAA,MAAA;EAAA,gCAAA;AACA,oBAAA;AACA,gCAAA;AAEA,cAAA;AACA,aAAA;EAAA;AAAA,CAAA;ACLA,IAAA,qBAAA,CAAA;AAAAA,UAAA,oBAAA;EAAA,kBAAA,MAAA;EAAA,mBAAA,MAAA;EAAA,eAAA,MAAA;EAAA,qBAAA,MAAA;AAAA,CAAA;AAGO,SAAA,iBAA0B,MAAc,MAAkC;AAC9E,SAAO,cAAc,CAAC,OAAO,MAAM,IAAA,CAAA;AAAA;AAG/B,SAAA,kBAA2B,YAA0C;AACzE,SAAO,cAAc,CAAC,QAAQ,GAAG,UAAA,CAAA;AAAA;AAG7B,SAAA,cAAuB,YAA0C;AACrE,QAAM,WAAW,CAAC,GAAG,UAAA;AACrB,MAAI,SAAS,CAAA,MAAO,aAAa;AAC9B,aAAS,QAAQ,WAAA;EAAA;AAGpB,SAAO,0BAA0B,QAAA;AAAA;AAG7B,SAAA,oBAA6B,YAA0C;AAC3E,SAAO,cAAc,CAAC,UAAU,GAAG,UAAA,CAAA;AAAA;AArBtC,IAAA,kBAAA,MAAA;EAAA,gCAAA;AACA,cAAA;EAAA;AAAA,CAAA;ACqCA,SAAA,aAAsB,GAAW,GAAmB;AACjD,QAAM,SAAS,MAAM,CAAA;AACrB,QAAM,SAAS,MAAM,CAAA;AAErB,MAAI,WAAW,QAAQ;AACpB,WAAO,SAAS,IAAI;EAAA;AAGvB,SAAO,SAAS,OAAO,GAAG,CAAA,IAAK;AAAA;AAGlC,SAAA,OAAgB,GAAW,GAAW;AACnC,SAAO,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI;AAAA;AAGpC,SAAA,QAAiB,OAAe;AAC7B,SAAO,MAAM,KAAA;AAAA;AAGhB,SAAA,SAAkB,OAA2B;AAC1C,MAAI,OAAO,UAAU,UAAU;AAC5B,WAAO,SAAS,MAAM,QAAQ,SAAS,EAAA,GAAK,EAAA,KAAO;EAAA;AAGtD,SAAO;AAAA;AA9DV,IAEO;AAFP,IASa;AATb,IAAA,eAAA,MAAA;EAAA,iCAAA;AAEO,cAAA,MAAmC;MACvC,YACmB,KACA,QACjB;AAFiB,aAAA,MAAA;AACA,aAAA,SAAA;MAAA;IAAA;AAIT,mBAAe,SAAU,MAAc,aAAa,OAAO;AACrE,YAAM,OAAO,KAAK,MAAM,IAAA,EAAM,IAAI,OAAA,EAAS,OAAO,OAAA;AAElD,UAAI,CAAC,YAAY;AACd,aAAK,KAAK,SAAU,MAAM,MAAM;AAC7B,gBAAM,SAAS,KAAK,MAAM,GAAA;AAC1B,gBAAM,SAAS,KAAK,MAAM,GAAA;AAE1B,cAAI,OAAO,WAAW,KAAK,OAAO,WAAW,GAAG;AAC7C,mBAAO,aAAa,SAAS,OAAO,CAAA,CAAA,GAAK,SAAS,OAAO,CAAA,CAAA,CAAA;UAAA;AAG5D,mBAAS,IAAI,GAAG,IAAI,KAAK,IAAI,OAAO,QAAQ,OAAO,MAAA,GAAS,IAAI,GAAG,KAAK;AACrE,kBAAM,OAAO,OAAO,SAAS,OAAO,CAAA,CAAA,GAAK,SAAS,OAAO,CAAA,CAAA,CAAA;AAEzD,gBAAI,MAAM;AACP,qBAAO;YAAA;UAAA;AAIb,iBAAO;QAAA,CAAA;MAAA;AAIb,YAAM,SAAS,aAAa,KAAK,CAAA,IAAK,CAAC,GAAG,IAAA,EAAM,QAAA,EAAU,KAAK,CAAC,QAAQ,IAAI,QAAQ,GAAA,KAAQ,CAAA;AAE5F,aAAO,IAAI,QAAQ,MAAM,MAAA;IAAA;EAAA;AAAA,CAAA;ACnC5B,IAAA,cAAA,CAAA;AAAAA,UAAA,aAAA;EAAA,qBAAA,MAAA;EAAA,YAAA,MAAA;EAAA,aAAA,MAAA;AAAA,CAAA;AAOO,SAAA,YAAqB,aAAuB,CAAA,GAA2B;AAC3E,QAAM,gBAAgB,WAAW,KAAK,CAAC,WAAW,WAAW,KAAK,MAAA,CAAA;AAElE,SAAO;IACJ,QAAQ;IACR,UAAU,CAAC,OAAO,MAAM,GAAG,UAAA;IAC3B,OAAO,MAAc;AAClB,aAAO,aAAa,MAAM,aAAA;IAAA;EAAA;AAAA;AAQ5B,SAAA,WAAoB,MAA4C;AACpE,SAAO;IACJ,QAAQ;IACR,UAAU,CAAC,OAAO,IAAA;IAClB,SAAS;AACN,aAAO,EAAE,KAAA;IAAA;EAAA;AAAA;AAQX,SAAA,oBACJ,MACA,YAC6B;AAC7B,SAAO;IACJ,QAAQ;IACR,UAAU,CAAC,OAAO,MAAM,MAAM,YAAY,IAAA;IAC1C,SAAS;AACN,aAAO,EAAE,KAAA;IAAA;EAAA;AAAA;AA3ClB,IAAA,WAAA,MAAA;EAAA,yBAAA;AACA,iBAAA;EAAA;AAAA,CAAA;ACDA,IAAA,cAAAG,YAAA;EAAA,aAAA,SAAAC,SAAA;AAAA,QAAM,EAAE,aAAA,aAAA,KAAgB,kBAAA,GAAAC,cAAA,oBAAA;AACxB,QAAM,EAAE,cAAA,cAAA,KAAiB,oBAAA,GAAAA,cAAA,sBAAA;AAEzB,QAAM,EAAE,WAAA,WAAA,KAAc,eAAA,GAAAA,cAAA,iBAAA;AACtB,QAAM,EAAE,wBAAA,wBAAA,KAA2B,UAAA,GAAAA,cAAA,YAAA;AACnC,QAAM;MACH,SAAA;MACA,aAAA;MACA,kBAAA;MACA,cAAA;MACA,2BAAA;MACA,YAAA;MACA,oBAAA;MACA,0BAAA;MACA,yBAAA;IAAA,KACC,WAAA,GAAAA,cAAA,aAAA;AACJ,QAAM,EAAE,gBAAA,gBAAA,KAAmB,iBAAA,GAAAA,cAAA,mBAAA;AAC3B,QAAM;MACH,YAAA;MACA,iBAAA;MACA,oBAAA;MACA,kBAAA;IAAA,KACC,YAAA,GAAAA,cAAA,cAAA;AACJ,QAAM,EAAE,iBAAA,iBAAA,KAAoB,kBAAA,GAAAA,cAAA,oBAAA;AAC5B,QAAM,EAAE,iBAAA,iBAAA,KAAoB,mBAAA,GAAAA,cAAA,qBAAA;AAC5B,QAAM,EAAE,WAAA,YAAW,iBAAA,iBAAA,KAAoB,WAAA,GAAAA,cAAA,aAAA;AACvC,QAAM,EAAE,sBAAA,uBAAsB,qBAAA,qBAAA,KAAwB,WAAA,GAAAA,cAAA,aAAA;AACtD,QAAM,EAAE,iBAAA,iBAAA,KAAoB,UAAA,GAAAA,cAAA,YAAA;AAC5B,QAAM,EAAE,WAAA,WAAA,KAAc,WAAA,GAAAA,cAAA,aAAA;AACtB,QAAM,EAAE,UAAA,UAAA,KAAa,UAAA,GAAAA,cAAA,YAAA;AACrB,QAAM,EAAE,UAAA,UAAA,KAAa,UAAA,GAAAA,cAAA,YAAA;AACrB,QAAM,EAAE,cAAA,cAAA,KAAiB,UAAA,GAAAA,cAAA,YAAA;AACzB,QAAM;MACH,eAAA;MACA,gBAAA;MACA,iBAAA;MACA,YAAA;MACA,kBAAA;IAAA,KACC,YAAA,GAAAA,cAAA,cAAA;AACJ,QAAM,EAAE,cAAA,eAAc,WAAA,WAAA,KAAc,WAAA,GAAAA,cAAA,aAAA;AACpC,QAAM,EAAE,eAAA,eAAA,KAAkB,gBAAA,GAAAA,cAAA,kBAAA;AAC1B,QAAM;MACH,kBAAA;MACA,mBAAA;MACA,eAAA;MACA,qBAAA;IAAA,KACC,gBAAA,GAAAA,cAAA,kBAAA;AACJ,QAAM,EAAE,qBAAA,sBAAqB,YAAA,aAAY,aAAA,aAAA,KAAgB,SAAA,GAAAA,cAAA,WAAA;AACzD,QAAM,EAAE,2BAAA,4BAA2B,2BAAA,2BAAA,KAA8B,UAAA,GAAAA,cAAA,YAAA;AAEjE,aAAA,KAAa,SAAS,SAAS;AAC5B,WAAK,YAAY,IAAI,aAClB,QAAQ,QACR,QAAQ,SACR,IAAI,WAAU,QAAQ,sBAAA,GACtB,OAAA;AAGH,WAAK,WAAW,QAAQ;IAAA;AAG1B,KAAA,KAAI,YAAY,OAAO,OAAO,cAAa,SAAA,GAAY,cAAc;AAStE,SAAI,UAAU,eAAe,SAAU,SAAS;AAC7C,WAAK,UAAU,SAAS;AACxB,aAAO;IAAA;AAWV,SAAI,UAAU,MAAM,SAAU,MAAM,OAAO;AACxC,UAAI,UAAU,WAAW,KAAK,OAAO,SAAS,UAAU;AACrD,aAAK,UAAU,MAAM;MAAA,OACjB;AACH,SAAA,KAAK,UAAU,MAAM,KAAK,UAAU,OAAO,CAAA,GAAI,IAAA,IAAQ;MAAA;AAG3D,aAAO;IAAA;AAMV,SAAI,UAAU,YAAY,SAAU,SAAS;AAC1C,aAAO,KAAK,SACT,eACG,yBAAwB,SAAA,KAAc,CAAA,GACrC,aAAY,OAAA,KAAY,WAAY,CAAA,CAAA,GAExC,0BAAyB,SAAA,CAAA;IAAA;AAI/B,aAAA,gBAAyB,KAAK,MAAM,UAAU,WAAW;AACtD,UAAI,OAAO,aAAa,UAAU;AAC/B,eAAO,wBAAuB,OAAO,oCAAA;MAAA;AAGxC,aAAO,KAAK,UAAU,YAAW,WAAW,aAAA,GAAe,oBAAmB,SAAA,CAAA;IAAA;AAMjF,SAAI,UAAU,QAAQ,WAAY;AAC/B,aAAO,KAAK,SACT,gBAAgB,SAAS,YAAW,GAAG,SAAA,GACvC,0BAAyB,SAAA,CAAA;IAAA;AAO/B,SAAI,UAAU,SAAS,WAAY;AAChC,aAAO,KAAK,SACT,gBAAgB,UAAU,kBAAiB,GAAG,SAAA,GAC9C,0BAAyB,SAAA,CAAA;IAAA;AAY/B,SAAI,UAAU,KAAK,SAAU,MAAM,IAAI;AACpC,aAAO,KAAK,SAAS,UAAS,MAAM,EAAA,GAAK,0BAAyB,SAAA,CAAA;IAAA;AAQrE,SAAI,UAAU,oBAAoB,SAAU,MAAM;AAC/C,UAAI,MAAM;AACV,aAAO,KAAK,KAAK,WAAY;AAC1B,YAAI,KAAK,SAAU,KAAK,MAAM;AAC3B,cAAI,SAAS,KAAK,QAAQ,IAAA;QAAA,CAAA;MAAA,CAAA;IAAA;AAQnC,SAAI,UAAU,OAAO,SAAU,QAAQ,QAAQ,SAAS,MAAM;AAC3D,aAAO,KAAK,SACT,UACG,YAAW,QAAQ,aAAA,GACnB,YAAW,QAAQ,aAAA,GACnB,oBAAmB,SAAA,CAAA,GAEtB,0BAAyB,SAAA,CAAA;IAAA;AAc/B,SAAI,UAAU,QAAQ,SAAU,QAAQ,QAAQ;AAC7C,aAAO,KAAK,SACT,WACG,YAAW,QAAQ,aAAA,GACnB,YAAW,QAAQ,aAAA,GACnB,oBAAmB,SAAA,CAAA,GAEtB,0BAAyB,SAAA,CAAA;IAAA;AAW/B,SAAI,UAAU,SAAS,SAAU,SAAS;AACvC,cAAQ,KACL,sKAAA;AAEH,aAAO;IAAA;AAYV,SAAI,UAAU,OAAO,SAAU,SAAS,MAAM;AAC3C,aAAO,KAAK,SACT,aAAY,oBAAmB,SAAA,CAAA,GAC/B,0BAAyB,SAAA,CAAA;IAAA;AAQ/B,SAAI,UAAU,SAAS,WAAY;AAChC,aAAO,KAAK,SACT,2BAA0B,CAAC,UAAU,GAAG,oBAAmB,SAAA,CAAA,CAAA,GAC3D,0BAAyB,SAAA,CAAA;IAAA;AAO/B,SAAI,UAAU,QAAQ,SAAU,MAAM;AACnC,aAAO,KAAK,SACT,WAAU,cAAa,IAAA,GAAO,oBAAmB,SAAA,CAAA,GACjD,0BAAyB,SAAA,CAAA;IAAA;AAO/B,SAAI,UAAU,SAAS,SAAU,QAAQ;AACtC,YAAM,OAAO,0BAAyB,SAAA;AAEtC,UAAI,OAAO,WAAW,UAAU;AAC7B,eAAO,KAAK,SAAS,wBAAuB,yBAAA,GAA4B,IAAA;MAAA;AAG3E,aAAO,KAAK,SACT,2BAA0B,CAAC,UAAU,GAAG,oBAAmB,WAAW,GAAG,IAAA,GAAO,MAAA,CAAA,GAChF,IAAA;IAAA;AAON,SAAI,UAAU,SAAS,SAAU,MAAM;AACpC,YAAM,OACH,OAAO,SAAS,WACX,YAAW,IAAA,IACX,wBAAuB,gCAAA;AAE/B,aAAO,KAAK,SAAS,MAAM,0BAAyB,SAAA,CAAA;IAAA;AAMvD,SAAI,UAAU,kBAAkB,SAAU,SAAS,YAAY;AAC5D,aAAO,KAAK,SACT,qBAAoB,SAAS,UAAA,GAC7B,0BAAyB,SAAA,CAAA;IAAA;AAO/B,SAAI,UAAU,oBAAoB,SAAU,YAAY,aAAa,MAAM;AACxE,aAAO,KAAK,SACT,kBAAiB,YAAY,OAAO,gBAAgB,YAAY,cAAc,KAAA,GAC9E,0BAAyB,SAAA,CAAA;IAAA;AAO/B,SAAI,UAAU,sBAAsB,SAAU,aAAa,aAAa,MAAM;AAC3E,aAAO,KAAK,SACT,oBAAmB,aAAa,OAAO,gBAAgB,YAAY,cAAc,KAAA,GACjF,0BAAyB,SAAA,CAAA;IAAA;AAU/B,SAAI,UAAU,SAAS,SAAU,SAAS,MAAM;AAC7C,aAAO,KAAK,SACT,YAAW,oBAAmB,SAAA,CAAA,GAC9B,0BAAyB,SAAA,CAAA;IAAA;AAS/B,SAAI,UAAU,cAAc,SAAU,MAAM;AACzC,aAAO,KAAK,SAAS,iBAAA,GAAmB,0BAAyB,SAAA,CAAA;IAAA;AAMpE,SAAI,UAAU,MAAM,SAAU,UAAU;AACrC,YAAM,qBAAqB,CAAC,MAAM,QAAQ,QAAA;AAC1C,YAAM,UAAU,CAAA,EAAG,MAAM,KAAK,qBAAqB,YAAY,UAAU,CAAA;AAEzE,eAAS,IAAI,GAAG,IAAI,QAAQ,UAAU,oBAAoB,KAAK;AAC5D,YAAI,CAAC,kBAAiB,QAAQ,CAAA,CAAA,GAAK;AAChC,kBAAQ,OAAO,GAAG,QAAQ,SAAS,CAAA;AACnC;QAAA;MAAA;AAIN,cAAQ,KAAK,GAAG,oBAAmB,WAAW,GAAG,IAAA,CAAA;AAEjD,UAAI,OAAO,0BAAyB,SAAA;AAEpC,UAAI,CAAC,QAAQ,QAAQ;AAClB,eAAO,KAAK,SACT,wBAAuB,iDAAA,GACvB,IAAA;MAAA;AAIN,aAAO,KAAK,SAAS,2BAA0B,SAAS,KAAK,QAAA,GAAW,IAAA;IAAA;AAG3E,SAAI,UAAU,eAAe,SAAU,MAAM,MAAM,MAAM;AACtD,aAAO,KAAK,SAAS,kBAAiB,MAAM,IAAA,GAAO,0BAAyB,SAAA,CAAA;IAAA;AAG/E,SAAI,UAAU,kBAAkB,SAAU,MAAM,MAAM;AACnD,aAAO,KAAK,SACT,qBAAoB,oBAAmB,WAAW,IAAA,CAAA,GAClD,0BAAyB,SAAA,CAAA;IAAA;AAI/B,SAAI,UAAU,gBAAgB,SAAU,MAAM,MAAM;AACjD,aAAO,KAAK,SACT,mBAAkB,oBAAmB,WAAW,IAAA,CAAA,GAChD,0BAAyB,SAAA,CAAA;IAAA;AAI/B,SAAI,UAAU,YAAY,SAAU,SAAS,MAAM;AAChD,aAAO,KAAK,SACT,eAAc,oBAAmB,SAAA,CAAA,GACjC,0BAAyB,SAAA,CAAA;IAAA;AAI/B,SAAI,UAAU,aAAa,WAAY;AACpC,aAAO,KAAK,SACT,iBAAgB,oBAAmB,SAAA,CAAA,GACnC,0BAAyB,SAAA,CAAA;IAAA;AAO/B,SAAI,UAAU,YAAY,SAAU,YAAY,YAAY,MAAM;AAC/D,aAAO,KAAK,SACT,eAAc,YAAY,YAAY,oBAAmB,SAAA,CAAA,GACzD,0BAAyB,SAAA,CAAA;IAAA;AAO/B,SAAI,UAAU,eAAe,SAAU,YAAY,MAAM;AACtD,aAAO,KAAK,SAAS,kBAAiB,UAAA,GAAa,0BAAyB,SAAA,CAAA;IAAA;AAO/E,SAAI,UAAU,aAAa,SAAU,SAAS,MAAM;AACjD,aAAO,KAAK,SAAS,gBAAe,YAAY,IAAA,GAAO,0BAAyB,SAAA,CAAA;IAAA;AASnF,SAAI,UAAU,SAAS,SAAU,SAAS,MAAM;AAC7C,aAAO,KAAK,SACT,YAAW,oBAAmB,SAAA,CAAA,GAC9B,0BAAyB,SAAA,CAAA;IAAA;AAU/B,SAAI,UAAU,MAAM,SAAU,SAAS,MAAM;AAC1C,YAAM,UAAU,oBAAmB,SAAA;AAEnC,UAAI,QAAQ,CAAA,MAAO,OAAO;AACvB,gBAAQ,QAAQ,KAAA;MAAA;AAGnB,aAAO,KAAK,SAAS,2BAA0B,OAAA,GAAU,0BAAyB,SAAA,CAAA;IAAA;AAQrF,SAAI,UAAU,mBAAmB,SAAU,MAAM;AAC9C,aAAO,KAAK,SACT,2BAA0B,CAAC,oBAAA,CAAA,GAC3B,0BAAyB,SAAA,CAAA;IAAA;AAW/B,SAAI,UAAU,WAAW,SAAU,QAAQ,MAAM;AAC9C,YAAM,OAAO,cACV,EAAE,QAAQ,YAAW,QAAQ,aAAA,EAAA,GAC7B,oBAAmB,SAAA,CAAA;AAGtB,aAAO,KAAK,SAAS,MAAM,0BAAyB,SAAA,CAAA;IAAA;AAMvD,SAAI,UAAU,KAAK,SAAU,OAAO;AACjC,aAAO,KAAK,SACT,2BAA0B,CAAC,MAAM,MAAM,GAAG,SAAQ,KAAA,CAAA,CAAA,GAClD,0BAAyB,SAAA,CAAA;IAAA;AAU/B,SAAI,UAAU,cAAc,SAAU,OAAO;AAC1C,aAAO,KAAK,SACT,2BAA0B,CAAC,MAAM,YAAY,GAAG,SAAQ,KAAA,CAAA,CAAA,GACxD,0BAAyB,SAAA,CAAA;IAAA;AAa/B,SAAI,UAAU,UAAU,SAAU,SAAS,MAAM;AAC9C,aAAO,KAAK,SAAS,SAAS,SAAA;IAAA;AAGjC,SAAI,UAAU,gBAAgB,WAAY;AACvC,aAAO,KAAK,SAAS,UAAU,SAAA;IAAA;AAGlC,SAAI,UAAU,WAAW,SAAU,QAAQ,MAAM;AAC9C,UAAI,UAAU,0BAAyB,IAAA;AACvC,UAAI,UAAU,CAAC,UAAA;AACf,UAAI,UAAU,KAAK,CAAA;AAEnB,UAAI,OAAO,YAAY,UAAU;AAC9B,eAAO,KAAK,SACT,wBAAuB,8DAAA,GACvB,OAAA;MAAA;AAIN,UAAI,MAAM,QAAQ,OAAA,GAAU;AACzB,gBAAQ,KAAK,MAAM,SAAS,OAAA;MAAA;AAG/B,YAAM,OACH,WAAW,WAAW,2BAA0B,OAAA,IAAW,2BAA0B,OAAA;AAExF,aAAO,KAAK,SAAS,MAAM,OAAA;IAAA;AAG9B,SAAI,UAAU,OAAO,SAAU,SAAS,MAAM;AAC3C,YAAM,OAAO,cAAa,OAAA,IACrB,wBACG,sGAAA,IAEH,2BAA0B,CAAC,QAAQ,GAAG,oBAAmB,SAAA,CAAA,CAAA;AAE9D,aAAO,KAAK,SAAS,MAAM,0BAAyB,SAAA,CAAA;IAAA;AAGvD,SAAI,UAAU,cAAc,WAAY;AACrC,aAAO,KAAK,SACT,iBAAgB,oBAAmB,WAAW,CAAA,CAAA,GAC9C,0BAAyB,SAAA,CAAA;IAAA;AAI/B,SAAI,UAAU,aAAa,SAAU,SAAS;AAC3C,YAAM,OAAO,CAAC,2BAA0B,OAAA,IACnC,wBACG,0EAAA,IAEH,gBAAe,SAAQ,OAAA,GAAU,oBAAmB,CAAA,EAAG,MAAM,KAAK,WAAW,CAAA,CAAA,CAAA;AAElF,aAAO,KAAK,SAAS,MAAM,0BAAyB,SAAA,CAAA;IAAA;AAGvD,SAAI,UAAU,WAAW,WAAY;AAClC,YAAM,WAAW,CAAC,aAAa,GAAG,oBAAmB,WAAW,IAAA,CAAA;AAChE,aAAO,KAAK,SACT,2BAA0B,UAAU,IAAA,GACpC,0BAAyB,SAAA,CAAA;IAAA;AAM/B,SAAI,UAAU,QAAQ,SAAU,MAAM,SAAS,MAAM;AAClD,YAAM,yBAAyB,qBAAoB,IAAA;AACnD,YAAM,YACF,0BAA0B,KAAK,KAAK,EAAA,KAAQ,YAAW,MAAM,aAAA,KAAiB;AAClF,YAAM,aAAa,oBAAmB,CAAA,EAAG,MAAM,KAAK,WAAW,yBAAyB,IAAI,CAAA,CAAA;AAE5F,aAAO,KAAK,SACT,sBAAqB,WAAW,UAAA,GAChC,0BAAyB,SAAA,CAAA;IAAA;AAI/B,SAAI,UAAU,OAAO,SAAU,MAAM;AAClC,YAAM,OAAO;QACV,UAAU,CAAA;QACV,QAAQ;QACR,SAAS;AACN,cAAI,OAAO,SAAS,YAAY;AAC7B,iBAAA;UAAA;QAAA;MAAA;AAKT,aAAO,KAAK,SAAS,IAAA;IAAA;AAQxB,SAAI,UAAU,aAAa,WAAY;AAGpC,aAAO;IAAA;AASV,SAAI,UAAU,cAAc,SAAU,WAAW,MAAM;AACpD,aAAO,KAAK,SACT,iBAAgB,SAAQ,YAAW,WAAW,4BAA2B,CAAA,CAAA,CAAA,CAAA,GACzE,0BAAyB,SAAA,CAAA;IAAA;AAI/B,SAAI,UAAU,cAAc,SAAU,WAAW,MAAM;AACpD,aAAO,KAAK,SACT,iBAAgB,YAAW,WAAW,aAAA,CAAA,GACtC,0BAAyB,SAAA,CAAA;IAAA;AAI/B,IAAAD,QAAO,UAAU;EAAA;AAAA,CAAA;AChnBjB,cAAA;ACAA,eAAA;AAYO,IAAA,oBAAA,cAAgC,SAAS;EAC7C,YACmB,QAChB,SACD;AACC,UAAM,QAAW,OAAA;AAHD,SAAA,SAAA;EAAA;AAAA;ADZtB,eAAA;AEDA,eAAA;AAEO,IAAA,iBAAA,cAA6B,SAAS;EAC1C,YACU,MACS,QAChB,SACD;AACC,UAAM,MAAM,OAAA;AAJL,SAAA,OAAA;AACS,SAAA,SAAA;AAIhB,WAAO,eAAe,MAAM,WAAW,SAAA;EAAA;AAAA;AFN7C,wBAAA;AACA,8BAAA;AACA,mBAAA;AACA,WAAA;AACA,YAAA;AACA,sBAAA;AACA,UAAA;AACA,WAAA;AGPO,SAAA,YAAqB,QAAmC;AAC5D,MAAI,CAAC,QAAQ;AACV;EAAA;AAGH,QAAM,eAA+C;IAClD,MAAM;IACN,OAAO,OAAO,SAAS;AACpB,eAAA,OAAgB;AACb,gBAAQ,KAAK,IAAI,eAAe,QAAW,SAAS,uBAAA,CAAA;MAAA;AAGvD,aAAO,iBAAiB,SAAS,IAAA;AAEjC,cAAQ,QAAQ,GAAG,SAAS,MAAM,OAAO,oBAAoB,SAAS,IAAA,CAAA;IAAA;EAAA;AAI5E,QAAM,gBAAiD;IACpD,MAAM;IACN,OAAO,OAAO,SAAS;AACpB,UAAI,OAAO,SAAS;AACjB,gBAAQ,KAAK,IAAI,eAAe,QAAW,SAAS,wBAAA,CAAA;MAAA;IAAA;EAAA;AAK7D,SAAO,CAAC,eAAe,YAAA;AAAA;AC1B1B,SAAA,eAAwB,KAAuB;AAC5C,SAAO,OAAO,QAAQ,YAAY,IAAI,KAAA,EAAO,YAAA,MAAkB;AAAA;AAGlE,SAAA,wBAAiC,KAAa,MAAc;AACzD,MAAI,CAAC,eAAe,GAAA,GAAM;AACvB;EAAA;AAGH,MAAI,CAAC,+BAA+B,KAAK,IAAA,GAAO;AAC7C;EAAA;AAGH,QAAM,IAAI,eACP,QACA,UACA,qFAAA;AAAA;AAIN,SAAA,kBAA2B,KAAa,QAAgB;AACrD,MAAI,8BAA8B,KAAK,GAAA,GAAM;AAC1C,UAAM,IAAI,eACP,QACA,UACA,0FAAA;EAAA;AAIN,MAAI,WAAW,WAAW,WAAW,KAAK,GAAA,GAAM;AAC7C,UAAM,IAAI,eACP,QACA,UACA,+EAAA;EAAA;AAIN,MAAI,WAAW,UAAU,eAAe,KAAK,GAAA,GAAM;AAChD,UAAM,IAAI,eACP,QACA,UACA,kFAAA;EAAA;AAAA;AAKF,SAAA,4BAAqC;EACzC,8BAA8B;EAC9B,kBAAkB;AAAA,IACgB,CAAA,GAAmC;AACrE,SAAO;IACJ,MAAM;IACN,OAAO,MAAM,SAAS;AACnB,WAAK,QAAQ,CAAC,SAAS,UAAU;AAC9B,cAAM,OAAO,QAAQ,KAAK,SAAS,KAAK,QAAQ,CAAA,IAAK;AAErD,uCAA+B,wBAAwB,SAAS,IAAA;AAChE,2BAAmB,kBAAkB,SAAS,QAAQ,MAAA;MAAA,CAAA;AAGzD,aAAO;IAAA;EAAA;AAAA;ACjEhB,WAAA;AAGO,SAAA,6BACJ,eAC8B;AAC9B,QAAM,SAAS,cAAc,eAAe,IAAA;AAE5C,SAAO;IACJ,MAAM;IACN,OAAO,MAAM;AACV,aAAO,CAAC,GAAG,QAAQ,GAAG,IAAA;IAAA;EAAA;AAAA;ACT/B,WAAA;AAGA,IAAM,YAAQ,mCAAA,EAAW;AAElB,SAAA,0BAAmC;EACvC,UAAU;EACV,SAAS;AAAA,IAC6B,CAAA,GAAoC;AAC1E,WAAA,eAAwB;AACrB,QAAI,WAAW;AACf,UAAM,SAAS;MACZ,WAAO,mCAAA;MACP,kBAAc,mCAAA;MACd,UAAM,mCAAA;MACN,iBAAa,mCAAA;IAAA;AAGhB,UAAM,SAAS,QAAQ,KAAK;MACzB,YAAY,QAAQ,QAAQ,OAAO,aAAa;MAChD,WAAW,QAAQ,QAAQ,OAAO,YAAY;IAAA,CAAA;AAGjD,qBAAiB,SAAS,OAAO,OAAO,OAAO,YAAA;AAC/C,qBAAiB,QAAQ,OAAO,MAAM,OAAO,WAAA;AAE7C,WAAO;MACJ,MAAM,MAAc;AACjB,mBAAW;AACX,eAAO,MAAM,KAAA;MAAA;MAEhB,KAAK,MAAc;AAChB,mBAAW;AACX,eAAO,KAAK,KAAA;MAAA;MAAA,IAEX,WAAW;AACZ,eAAO;MAAA;MAEV;IAAA;EAAA;AAIN,WAAA,iBACG,MACA,OACA,SACD;AACC,QAAI,SAAS,OAAO;AACjB;IAAA;AAGF,KAAA,SAAS,OAAO,MAAM,UAAU,MAAM,QAAQ,KAAK,MAAM,MAAM,IAAA,CAAA,GAAQ,KAAK,QAAQ,IAAA;EAAA;AAGxF,SAAO;IACJ,MAAM;IACA,OAAO,IAAO,IAAoB;AAAA,aAAA,QAAA,MAAA,WAAA,WAA3B,OAAO,EAAE,SAAS,MAAA,GAAS;AA1D9C,YAAA,KAAA;AA2DS,cAAM,SAAS,aAAA;AAEf,YAAI,aAAa;AACjB,YAAI,aAAa,MAAM,MAAM,aAAa;AAE1C,SAAA,MAAA,QAAQ,WAAR,OAAA,SAAA,IAAgB,GAAG,QAAQ,UAAA;AAC3B,SAAA,KAAA,QAAQ,WAAR,OAAA,SAAA,GAAgB,GAAG,QAAQ,UAAA;AAC3B,gBAAQ,GAAG,SAAS,UAAA;AAEpB,gBAAQ,GAAG,SAAS,CAAC,SAAiB,OAAO,MAAM,IAAA,CAAA;AACnD,gBAAQ,GAAG,QAAQ,CAAC,SAAiB,OAAO,KAAK,IAAA,CAAA;AAEjD,YAAI;AACD,gBAAM,OAAO;AACb,cAAI,YAAY;AACb,kBAAM,MAAM,EAAA;UAAA;AAEf,gBAAM,OAAO,QAAA;QAAA,SACP,KADO;AAEb,gBAAM,OAAO,UAAU,GAAA;QAAA;MAAA,CAAA;IAAA;EAAA;AAAA;AC9EnC,eAAA;AAMA,SAAA,YAAqB,QAAoB;AACtC,SAAO,CAAC,EAAE,OAAO,YAAY,OAAO,OAAO;AAAA;AAG9C,SAAA,gBAAyB,QAAoB;AAC1C,SAAO,OAAO,OAAO,CAAC,GAAG,OAAO,QAAQ,GAAG,OAAO,MAAA,CAAA;AAAA;AAG9C,SAAA,sBACJ,YAAY,OACZ,UAAU,aACV,eAAuD,iBACxD;AACC,SAAO,CAAC,OAAmC,WAAuB;AAC/D,QAAK,CAAC,aAAa,SAAU,CAAC,QAAQ,MAAA,GAAS;AAC5C,aAAO;IAAA;AAGV,WAAO,aAAa,MAAA;EAAA;AAAA;AAInB,SAAA,qBACJ,QAC8B;AAC9B,SAAO;IACJ,MAAM;IACN,OAAO,MAAM,SAAS;AACnB,YAAM,QAAQ,OAAO,KAAK,OAAO;QAC9B,QAAQ,QAAQ;QAChB,QAAQ,QAAQ;QAChB,UAAU,QAAQ;MAAA,CAAA;AAGrB,UAAI,OAAO,SAAS,KAAA,GAAQ;AACzB,eAAO,EAAE,OAAO,IAAI,SAAS,QAAW,MAAM,SAAS,OAAA,CAAA,EAAA;MAAA;AAG1D,aAAO;QACJ;MAAA;IAAA;EAAA;AAAA;AC5CZ,WAAA;AAEO,IAAA,cAAA,MAAkB;EAAlB,cAHP;AAIW,SAAA,UAAqD,oBAAI,IAAA;EAAA;EAE1D,IACJ,QACD;AACC,UAAM,UAAgC,CAAA;AAEtC,YAAQ,MAAA,EAAQ,QAAQ,CAAC,YAAW,WAAU,KAAK,QAAQ,IAAI,OAAO,SAAS,OAAA,CAAA,CAAA;AAE/E,WAAO,MAAM;AACV,cAAQ,QAAQ,CAAC,YAAW,KAAK,QAAQ,OAAO,OAAA,CAAA;IAAA;EAAA;EAI/C,KACJ,MACA,MACA,SACY;AACZ,QAAI,SAAS;AACb,UAAM,aAAa,OAAO,OAAO,OAAO,OAAO,OAAA,CAAA;AAE/C,eAAW,UAAU,KAAK,SAAS;AAChC,UAAI,OAAO,SAAS,MAAM;AACvB,iBAAS,OAAO,OAAO,QAAQ,UAAA;MAAA;IAAA;AAIrC,WAAO;EAAA;AAAA;AC/Bb,WAAA;AAIO,SAAA,sBAA+B,UAAuD;AAC1F,QAAM,kBAAkB;AACxB,QAAM,kBAAkB,CAAC,YAAY,SAAS,SAAS,QAAQ,MAAA;AAE/D,QAAM,aAA6C;IAChD,MAAM;IACN,OAAO,OAAO,SAAS;AAX7B,UAAA;AAYS,UAAI,CAAC,QAAQ,SAAS,SAAS,eAAA,GAAkB;AAC9C;MAAA;AAGH,OAAA,MAAA,QAAQ,QAAQ,WAAhB,OAAA,SAAA,IAAwB,GAAG,QAAQ,CAAC,UAAkB;AACnD,cAAM,UAAU,yCAAyC,KAAK,MAAM,SAAS,MAAA,CAAA;AAC7E,YAAI,CAAC,SAAS;AACX;QAAA;AAGH,iBAAS;UACN,QAAQ,QAAQ;UAChB,OAAO,mBAAmB,QAAQ,CAAA,CAAA;UAClC,UAAU,SAAS,QAAQ,CAAA,CAAA;UAC3B,WAAW,SAAS,QAAQ,CAAA,CAAA;UAC5B,OAAO,SAAS,QAAQ,CAAA,CAAA;QAAA,CAAA;MAAA,CAAA;IAAA;EAAA;AAMpC,QAAM,SAAwC;IAC3C,MAAM;IACN,OAAO,MAAM,SAAS;AACnB,UAAI,CAAC,gBAAgB,SAAS,QAAQ,MAAA,GAAS;AAC5C,eAAO;MAAA;AAGV,aAAO,UAAU,MAAM,eAAA;IAAA;EAAA;AAI7B,SAAO,CAAC,QAAQ,UAAA;AAAA;AAGnB,SAAA,mBAA4B,OAAe;AACxC,SAAO,OAAO,MAAM,YAAA,EAAc,MAAM,KAAK,CAAA,CAAA,KAAO;AAAA;AC/CvD,WAAA;AAGO,SAAA,mBACJ,cACiC;AACjC,QAAM,UAAU,KAAK,cAAc,CAAC,OAAO,KAAA,CAAA;AAE3C,SAAO;IACJ,MAAM;IACN,OAAO,MAAM;AACV,aAAO,eAAA,eAAA,CAAA,GAAK,OAAA,GAAY,IAAA;IAAA;EAAA;AAAA;ACP1B,SAAA,cAAuB;EAC3B;EACA,SAAS;EACT,SAAS;AAAA,GAC+E;AACxF,MAAI,QAAQ,GAAG;AACZ,WAAO;MACJ,MAAM;MACN,OAAO,OAAO,SAAS;AAbhC,YAAA,KAAA;AAcY,YAAI;AAEJ,iBAAA,OAAgB;AACb,qBAAW,aAAa,OAAA;AACxB,oBAAU,WAAW,MAAM,KAAA;QAAA;AAG9B,iBAAA,OAAgB;AArB5B,cAAA,KAAA;AAsBe,WAAA,MAAA,QAAQ,QAAQ,WAAhB,OAAA,SAAA,IAAwB,IAAI,QAAQ,IAAA;AACpC,WAAA,MAAA,QAAQ,QAAQ,WAAhB,OAAA,SAAA,IAAwB,IAAI,QAAQ,IAAA;AACpC,kBAAQ,QAAQ,IAAI,QAAQ,IAAA;AAC5B,kBAAQ,QAAQ,IAAI,SAAS,IAAA;AAC7B,qBAAW,aAAa,OAAA;QAAA;AAG3B,iBAAA,OAAgB;AACb,eAAA;AACA,kBAAQ,KAAK,IAAI,eAAe,QAAW,WAAW,uBAAA,CAAA;QAAA;AAGzD,oBAAU,MAAA,QAAQ,QAAQ,WAAhB,OAAA,SAAA,IAAwB,GAAG,QAAQ,IAAA;AAC7C,oBAAU,KAAA,QAAQ,QAAQ,WAAhB,OAAA,SAAA,GAAwB,GAAG,QAAQ,IAAA;AAC7C,gBAAQ,QAAQ,GAAG,QAAQ,IAAA;AAC3B,gBAAQ,QAAQ,GAAG,SAAS,IAAA;AAE5B,aAAA;MAAA;IAAA;EAAA;AAAA;ACtCZ,cAAA;AAEO,SAAA,oBAA4D;AAChE,SAAO;IACJ,MAAM;IACN,OAAO,MAAM;AACV,YAAM,SAAmB,CAAA;AACzB,UAAI;AACJ,eAAA,QAAgB,MAAgB;AAC5B,SAAA,SAAS,UAAU,CAAA,GAAI,KAAK,GAAG,IAAA;MAAA;AAGnC,eAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACnC,cAAM,QAAQ,KAAK,CAAA;AAEnB,YAAI,WAAW,KAAA,GAAQ;AACpB,kBAAO,QAAQ,KAAA,CAAA;AACf;QAAA;AAGH,YAAI,UAAU,MAAM;AACjB,kBACG,KAAK,MAAM,IAAI,CAAA,EAAG,QAAQ,CAAC,SAAU,WAAW,IAAA,KAAS,QAAQ,IAAA,KAAU,IAAA,CAAA;AAE9E;QAAA;AAGH,eAAO,KAAK,KAAA;MAAA;AAGf,aAAO,CAAC,SAAS,SAAS,CAAC,GAAG,QAAQ,MAAM,GAAG,OAAO,IAAI,MAAA,CAAA;IAAA;EAAA;AAAA;ACfnE,WAAA;AAGA,IAAM,MAAM,YAAA;AAmBL,SAAA,mBACJ,SACA,SACD;AACC,QAAM,UAAU,IAAI,YAAA;AACpB,QAAM,SAAS,qBACX,YAAY,OAAO,YAAY,WAAW,EAAE,QAAA,IAAY,YAAa,CAAA,GACtE,OAAA;AAGH,MAAI,CAAC,aAAa,OAAO,OAAA,GAAU;AAChC,UAAM,IAAQ,kBACX,QACA,0DAAA;EAAA;AAIN,MAAI,MAAM,QAAQ,OAAO,MAAA,GAAS;AAC/B,YAAQ,IAAI,6BAA6B,OAAO,MAAA,CAAA;EAAA;AAGnD,UAAQ,IAAI,4BAA4B,OAAO,MAAA,CAAA;AAC/C,UAAQ,IAAI,kBAAA,CAAA;AACZ,UAAQ,IAAI,0BAA0B,OAAO,UAAA,CAAA;AAC7C,SAAO,SAAS,QAAQ,IAAI,YAAY,OAAO,KAAA,CAAA;AAC/C,SAAO,YAAY,QAAQ,IAAI,sBAAsB,OAAO,QAAA,CAAA;AAC5D,SAAO,WAAW,QAAQ,IAAI,cAAc,OAAO,OAAA,CAAA;AACnD,SAAO,gBAAgB,QAAQ,IAAI,mBAAmB,OAAO,YAAA,CAAA;AAE7D,UAAQ,IAAI,qBAAqB,sBAAsB,IAAA,CAAA,CAAA;AACvD,SAAO,UAAU,QAAQ,IAAI,qBAAqB,OAAO,MAAA,CAAA;AAEzD,SAAO,IAAI,IAAI,QAAQ,OAAA;AAAA;ACpE1B,wBAAA;ACKA,IAAO,cAAQ;;;A9FDf,IAAM,iBAAiB;AAEvB,IAAM,eAAe,UAAM,aAAAE,SAAM,EAAE,OAAO,kBAAkB;AAC5D,IAAM,iBAAiB,CAAC,eACvB,4BAA4B,iBAAiB,aAAa;AAuBpD,IAAM,mBAAN,MAA6C;AAAA,EAGnD,YAAY,UAAyB,UAAwB;AAAxB;AAFrC,wBAAQ;AAGP,mBAAO,MAAM,kCAAkC;AAC/C,SAAK,cAAc,YAAU,QAAQ;AACrC,mBAAO,MAAM,+BAA+B;AAAA,EAC7C;AAAA,EAEA,MAAM,UAAU,UAAU,eAAe,KAAK,SAAS,UAAU,GAAG;AACnE,mBAAO,KAAK,iBAAiB,SAAS;AAEtC,UAAM,KAAK,YAAY,OAAO,OAAO;AAAA,EACtC;AAAA,EAEA,MAAM,oBAAoB;AACzB,UAAM,KAAK,YAAY,KAAK,CAAC,UAAU,CAAC;AAAA,EACzC;AAAA,EAEA,MAAM,QAAQ,SAAS,KAAK,SAAS,YAAY;AAChD,UAAM,KAAK,YAAY,KAAK,gBAAgB,QAAQ,CAAC,UAAU,CAAC;AAAA,EACjE;AAAA,EAEA,MAAM,gBAAgB,SAAS,KAAK,SAAS,YAAY;AACxD,UAAM,KAAK,YAAY,KAAK,gBAAgB,QAAQ;AAAA,MACnD;AAAA,MACA;AAAA,IACD,CAAC;AAED,mBAAO,KAAK,6BAA6B,kBAAkB,SAAS;AAAA,EACrE;AAAA,EAEA,MAAM,QAAQ,YAAY,OAAO,SAAS,KAAK,SAAS,YAAY;AACnE,UAAM,UAAU,YAAY,CAAC,IAAI,IAAI,CAAC;AAEtC,UAAM,KAAK,YAAY,KAAK,gBAAgB,QAAQ,OAAO;AAE3D,mBAAO,KAAK,qBAAqB,kBAAkB,SAAS;AAAA,EAC7D;AAAA,EAEA,MAAM,YAAY,OAAiB;AAClC,UAAM,QAAQ,IAAI,MAAM,IAAI,CAAC,SAAS,KAAK,YAAY,IAAI,IAAI,CAAC,CAAC;AAAA,EAClE;AAAA,EAEA,MAAM,cAAc;AACnB,UAAM,KAAK,YAAY,IAAI,KAAK;AAAA,EACjC;AAAA,EAEA,MAAM,eAAe;AACpB,WAAO,KAAK,YAAY,OAAO,EAAE,KAAK,CAAC,WAAW,OAAO,QAAQ,CAAC;AAAA,EACnE;AAAA,EAEA,MAAM,aAAa;AAClB,WAAO,KAAK,YACV,IAAI,CAAC,QAAQ,CAAC,EACd,KAAK,CAAC,WAAW,OAAO,SAAS,QAAQ,CAAC;AAAA,EAC7C;AAAA,EAEA,MAAM,qBAAqB;AAC1B,QAAI,mBAAmB;AAEvB,QAAI;AACH,YAAM,UAAU,MAAM,KAAK,YAAY,WAAW,CAAC,WAAW,CAAC;AAC/D,yBAAmB,CAAC,CAAC;AAAA,IACtB,SAAQ,GAAN;AACD,yBAAmB;AAAA,IACpB;AAEA,WAAO;AAAA,EACR;AAAA,EAEA,MAAM,SAAS;AACd,WAAO,KAAK,YAAY,YAAY;AAAA,EACrC;AAAA,EAEA,MAAM,sBAAsB;AAC3B,WAAO,KAAK,YAAY,OAAO,EAAE,KAAK,CAAC,WAAW,OAAO,UAAU;AAAA,EACpE;AAAA,EAEA,MAAM,eAAe;AACpB,YAAQ,IAAI,aAAa;AAEzB,UAAM,KAAK,YAAY;AACvB,UAAM,KAAK,YAAY,OAAO,CAAC,YAAY,CAAC;AAC5C,UAAM,KAAK,QAAQ;AAEnB,YAAQ,IAAI,aAAa;AAAA,EAC1B;AAAA,EAEA,MAAM,uBAAuB;AAC5B,WAAO,KAAK,YACV,OAAO,EACP;AAAA,MACA,CAAC,WACA,OAAO,MAAM,SAAS,KAAK,OAAO,UAAU,SAAS;AAAA,IACvD;AAAA,EACF;AACD;;;A+F/HA,kBAAwB;AAExB,IAAM,sBAAsB;AAErB,IAAM,mBAAN,MAAuB;AAAA,EAG7B,YAAY,UAA0B,YAAwB;AAAxB;AAFtC,wBAAQ;AAGP,mBAAO,MAAM,kCAAkC;AAC/C,SAAK,oBAAgB,qBAAQ,UAAU,mBAAmB;AAC1D,mBAAO,MAAM,+BAA+B;AAAA,EAC7C;AAAA,EAEA,MAAc,4BAA4B,SAAiB;AAC1D,UAAM,KAAK,WAAW,SAAS,mBAAmB;AAClD,UAAM,KAAK,WAAW,UAAU,OAAO;AACvC,UAAM,KAAK,WAAW,QAAQ;AAAA,EAC/B;AACD;;;ACnBA,IAAAC,mBAA2B;AAE3B,IAAqB,oBAArB,cAA+C,uBAAM;AAAA,EACpD,YAAY,KAAkB,YAAyB;AACtD,UAAM,GAAG;AADoB;AAAA,EAE9B;AAAA,EAEA,SAAe;AAThB,QAAAC;AAUE,SAAK,UAAU,MAAM;AAErB,SAAK,UAAU,SAAS,MAAM;AAAA,MAC7B,MAAM;AAAA,MACN,KAAK;AAAA,IACN,CAAC;AAED,KAAAA,MAAA,KAAK,eAAL,gBAAAA,IAAiB,sBAAsB,KAAK,CAAC,UAAU;AACtD,WAAK,UAAU,MAAM;AAErB,UAAI,MAAM,SAAS,GAAG;AACrB,aAAK,UAAU,SAAS,MAAM;AAAA,UAC7B,MAAM;AAAA,UACN,KAAK;AAAA,QACN,CAAC;AAED,cAAM,OAAO,KAAK,UAAU,SAAS,IAAI;AAEzC,cAAM;AAAA,UAAQ,CAAC,SACd,KACE,SAAS,IAAI,EACb,SAAS,UAAU;AAAA,YACnB,MAAM;AAAA,YACN,KAAK;AAAA,UACN,CAAC;AAAA,QACH;AAAA,MACD,OAAO;AACN,aAAK,UAAU,SAAS,MAAM;AAAA,UAC7B,MAAM;AAAA,UACN,KAAK;AAAA,QACN,CAAC;AAAA,MACF;AAAA,IACD;AAAA,EACD;AAAA,EAEA,UAAgB;AACf,SAAK,UAAU,MAAM;AAAA,EACtB;AACD;;;AC9CA,IAAAC,mBAA+C;AAE/C,gBAAe;AAGf,IAAM,oBACL;AACD,IAAM,cAAc;AAoBb,IAAM,wBAAsC;AAAA,EAClD,YAAY,UAAAC,QAAG,SAAS;AAAA,EACxB,YAAY;AAAA,EACZ,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,WAAW;AAAA,EACX,YAAY;AAAA,EACZ,UAAU;AAAA,EACV,gBAAgB;AAAA,EAChB,kBAAkB;AAAA,EAClB,wBAAwB;AAAA,EACxB,uBAAuB;AAAA,EACvB,aAAa;AAAA,EACb,wBAAwB;AAAA,EACxB,6BAA6B;AAC9B;AAEA,IAAqB,iBAArB,cAA4C,kCAAiB;AAAA,EAI5D,YAAY,KAAU,QAAsB;AAC3C,UAAM,KAAK,MAAM;AAJlB;AACA,wBAAQ;AAIP,SAAK,SAAS;AACd,SAAK,cAAc,YAAU;AAAA,EAC9B;AAAA,EAEA,UAAU;AACT,UAAM,EAAE,YAAY,IAAI;AAExB,gBAAY,MAAM;AAElB,SAAK,kBAAkB,WAAW;AAClC,SAAK,YAAY,WAAW;AAAA,EAC7B;AAAA,EAEQ,kBAAkB,aAA0B;AACnD,QAAI,yBAAQ,WAAW,EAAE,QAAQ,SAAS,EAAE,WAAW;AACvD,SAAK,qBAAqB,WAAW;AACrC,SAAK,sBAAsB,WAAW;AAAA,EACvC;AAAA,EAEQ,YAAY,aAA0B;AAC7C,QAAI,yBAAQ,WAAW,EAAE,QAAQ,WAAW,EAAE,WAAW;AACzD,SAAK,cAAc,WAAW;AAC9B,SAAK,iBAAiB,WAAW;AAAA,EAClC;AAAA,EAEQ,qBAAqB,IAAiB;AAC7C,QAAI,yBAAQ,EAAE,EACZ,QAAQ,aAAa,EACrB;AAAA,MACA;AAAA,IACD,EACC;AAAA,MAAQ,CAAC,SACT,KACE,eAAe,sBAAsB,UAAU,EAC/C,SAAS,KAAK,OAAO,SAAS,UAAU,EACxC,SAAS,OAAO,eAAe;AAC/B,aAAK,OAAO,SAAS,aAAa;AAClC,cAAM,KAAK,OAAO,aAAa;AAAA,MAChC,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EAEQ,sBAAsB,IAAiB;AAC9C,QAAI,yBAAQ,EAAE,EACZ,QAAQ,iBAAiB,EACzB;AAAA,MACA;AAAA,IACD,EACC;AAAA,MAAU,CAAC,WACX,OACE,cAAc,cAAc,EAC5B,WAAW,2BAA2B,EACtC,OAAO,EACP;AAAA,QAAQ,MACR,KAAK,KAAK,mBAAmB,UAAU,aAAa;AAAA,MACrD;AAAA,IACF;AAAA,EACF;AAAA,EAEQ,iBAAiB,IAAiB;AACzC,QAAI,yBAAQ,EAAE,EACZ,QAAQ,mBAAmB,EAC3B;AAAA,MACA;AAAA,IACD,EACC;AAAA,MAAQ,CAAC,SACT,KACE,eAAe,WAAW,EAC1B,SAAS,KAAK,OAAO,SAAS,UAAU,EACxC,SAAS,OAAO,eAAe;AAC/B,aAAK,OAAO,SAAS,aAAa;AAClC,cAAM,KAAK,OAAO,aAAa;AAAA,MAChC,CAAC;AAAA,IACH;AACD,QAAI,yBAAQ,EAAE,EACZ,QAAQ,0DAA0D,EAClE;AAAA,MAAQ,CAAC,SACT,KACE,eAAe,WAAW,EAC1B,SAAS,KAAK,OAAO,SAAS,QAAQ,EACtC,SAAS,OAAO,aAAa;AAC7B,aAAK,OAAO,SAAS,WAAW;AAChC,cAAM,KAAK,OAAO,aAAa;AAAA,MAChC,CAAC;AAAA,IACH;AAED,QAAI,yBAAQ,EAAE,EAAE;AAAA,MAAU,CAAC,WAC1B,OACE,cAAc,QAAQ,EACtB,WAAW,4BAA4B,EACvC,OAAO,EACP,QAAQ,YAAY;AACpB,YAAI;AACH,gBAAM,aAAa,GAAG,KAAK,OAAO,SAAS;AAC3C,gBAAM,KAAK,YACT;AAAA,YACA;AAAA,YACA,GAAG,KAAK,OAAO,SAAS;AAAA,UACzB,EACC,MAAM;AAAA,QACT,SAAS,OAAP;AACD,kBAAQ,MAAM,KAAK;AAAA,QACpB;AAAA,MACD,CAAC;AAAA,IACH;AAAA,EACD;AAAA,EAEQ,cAAc,IAAiB;AACtC,QAAI,yBAAQ,EAAE,EACZ,QAAQ,eAAe,EACvB,QAAQ,yBAAyB,EACjC;AAAA,MAAQ,CAAC,SACT,KACE,eAAe,MAAM,EACrB,SAAS,KAAK,OAAO,SAAS,UAAU,EACxC,SAAS,OAAO,eAAe;AAC/B,aAAK,OAAO,SAAS,aAAa;AAClC,cAAM,KAAK,OAAO,aAAa;AAAA,MAChC,CAAC;AAAA,IACH;AACD,QAAI,yBAAQ,EAAE,EAAE;AAAA,MAAU,CAAC,WAC1B,OACE,cAAc,QAAQ,EACtB,WAAW,uBAAuB,EAClC,OAAO,EACP,QAAQ,YAAY;AACpB,YAAI,MAAM,YAAU,KAAK,OAAO,SAAS,QAAQ;AACjD,YAAI;AACH,gBAAM,IAAI;AAAA,YACT,GAAG,KAAK,OAAO,SAAS;AAAA,YACxB;AAAA,UACD;AAAA,QACD,SAAS,OAAP;AACD,gBAAM,IAAI;AAAA,YACT,GAAG,KAAK,OAAO,SAAS;AAAA,UACzB;AAAA,QACD;AAAA,MACD,CAAC;AAAA,IACH;AAAA,EACD;AACD;;;AxGnLA,IAAAC,mBAAkD;AAElD,IAAM,cAAc;AAEpB,IAAqB,eAArB,cAA0C,wBAAO;AAAA,EAAjD;AAAA;AACC,wBAAQ;AACR,wBAAQ;AACR,wBAAQ;AAER,oCAAyB;AAAA;AAAA,EAEzB,MAAM,SAAS;AACd,mBAAO,MAAM,wBAAwB;AAErC,QAAI;AACH,YAAM,KAAK,aAAa;AAExB,qBAAO,KAAK,kBAAkB;AAAA,IAC/B,SAAQ,GAAN;AACD,qBAAO,MAAM,0BAA0B;AAAA,IACxC;AAEA,UAAM,UAAU,KAAK,IAAI,MAAM;AAE/B,QAAI,mBAAmB,oCAAmB;AACzC,YAAM,WAAW,QAAQ,YAAY;AAErC,WAAK,aAAa,IAAI,iBAAiB,UAAU,KAAK,QAAQ;AAC9D,WAAK,mBAAmB,IAAI;AAAA,QAC3B;AAAA,QACA,KAAK;AAAA,MACN;AACA,WAAK,iBAAiB,IAAI;AAAA,QACzB,KAAK;AAAA,QACL,KAAK;AAAA,MACN;AAEA,WAAK,WAAW;AAAA,QACf,IAAI;AAAA,QACJ,MAAM;AAAA,QACN,UAAU,MACT,IAAI,kBAAkB,KAAK,KAAK,KAAK,UAAU,EAAE,KAAK;AAAA,MACxD,CAAC;AACD,WAAK,WAAW;AAAA,QACf,IAAI;AAAA,QACJ,MAAM;AAAA,QACN,UAAU,YAAY;AACrB,gBAAM,KAAK,UAAU;AAAA,QACtB;AAAA,MACD,CAAC;AACD,WAAK;AAAA,QACJ;AAAA,QACA;AAAA,QACA,KAAK,UAAU,KAAK,IAAI;AAAA,MACzB;AACA,WAAK,cAAc,IAAI,eAAe,KAAK,KAAK,IAAI,CAAC;AAErD,qBAAO,MAAM,qBAAqB;AAAA,IACnC,OAAO;AACN,6BAAuB,iCAAiC;AAExD,qBAAO,MAAM,wCAAwC;AAAA,IACtD;AAAA,EACD;AAAA,EAEA,MAAM,eAAe;AACpB,SAAK,WAAW,OAAO;AAAA,MACtB,CAAC;AAAA,MACD;AAAA,MACA,MAAM,KAAK,SAAS;AAAA,IACrB;AAEA,QAAI,KAAK,SAAS,eAAe;AAChC,WAAK,SAAS,aAAa,sBAAsB;AAAA,EACnD;AAAA,EAEA,MAAM,aAAa,WAAW,KAAK,UAAU;AAC5C,UAAM,KAAK,SAAS,QAAQ;AAAA,EAC7B;AAAA,EAEA,MAAc,UAAU,MAAmB;AAC1C,QAAI,CAAC,KAAK,cAAc,CAAC,KAAK,kBAAkB;AAC/C,qBAAO,MAAM,gCAAgC;AAAA,IAC9C,WAAW,CAAC,KAAK,gBAAgB;AAChC,qBAAO,MAAM,sCAAsC;AAAA,IACpD,OAAO;AACN,UAAI;AACH,cAAM,KAAK,eAAe,KAAK;AAAA,MAChC,SAAS,GAAP;AACD,YAAI,wBAAO,iDAAiD;AAE5D,uBAAO,MAAM,kBAAkB,CAAC;AAAA,MACjC;AAAA,IACD;AAAA,EACD;AACD;",
  "names": ["module", "t", "e", "n", "r", "i", "s", "u", "a", "M", "m", "f", "l", "$", "y", "v", "g", "D", "o", "d", "c", "h", "module", "module", "debug", "self", "module", "exists", "__export", "deferred", "createConsola", "import_obsidian", "e", "import_promise_deferred", "__export", "debug", "logger", "__commonJS", "module", "__toCommonJS", "dayjs", "import_obsidian", "_a", "import_obsidian", "os", "import_obsidian"]
}
 diff --git a/.obsidian/plugins/cicada-sync/manifest.json b/.obsidian/plugins/cicada-sync/manifest.json new file mode 100644 index 0000000..261bdc0 --- /dev/null +++ b/.obsidian/plugins/cicada-sync/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "cicada-sync", + "name": "Cicada Synchronizer", + "version": "1.0.1", + "minAppVersion": "0.15.0", + "description": "uses Git to synchronize vaults for team collaboration.", + "author": "Adapole, Mahyar Mirrashed", + "authorUrl": "https://github.com/adapole", + "isDesktopOnly": true +} diff --git a/.obsidian/plugins/cicada-sync/styles.css b/.obsidian/plugins/cicada-sync/styles.css new file mode 100644 index 0000000..9a342fb --- /dev/null +++ b/.obsidian/plugins/cicada-sync/styles.css @@ -0,0 +1,15 @@ +/* + +This CSS file will be included with your plugin, and +available in the app when your plugin is enabled. + +If your plugin does not need CSS, delete this file. + +*/ +.sync-title { + margin-top: 0; +} + +.sync-conflicting-files { + margin-top: 0; +} diff --git a/.obsidian/workspace.json b/.obsidian/workspace.json new file mode 100644 index 0000000..8c2d92e --- /dev/null +++ b/.obsidian/workspace.json @@ -0,0 +1,154 @@ +{ + "main": { + "id": "85777452bb659073", + "type": "split", + "children": [ + { + "id": "a69b74c941597ddd", + "type": "tabs", + "children": [ + { + "id": "549e5793024b5758", + "type": "leaf", + "state": { + "type": "markdown", + "state": { + "file": "Readme.md", + "mode": "source", + "source": false + } + } + } + ] + } + ], + "direction": "vertical" + }, + "left": { + "id": "5c1d584e991cc6d9", + "type": "split", + "children": [ + { + "id": "cf24db14deba6bd6", + "type": "tabs", + "children": [ + { + "id": "a221fca3380aa248", + "type": "leaf", + "state": { + "type": "file-explorer", + "state": { + "sortOrder": "alphabetical" + } + } + }, + { + "id": "86c956fd6b2fa048", + "type": "leaf", + "state": { + "type": "search", + "state": { + "query": "", + "matchingCase": false, + "explainSearch": false, + "collapseAll": false, + "extraContext": false, + "sortOrder": "alphabetical" + } + } + }, + { + "id": "0667b9c10004a50f", + "type": "leaf", + "state": { + "type": "bookmarks", + "state": {} + } + } + ] + } + ], + "direction": "horizontal", + "width": 300 + }, + "right": { + "id": "45450d166a5fbc98", + "type": "split", + "children": [ + { + "id": "1da2710d2ef05767", + "type": "tabs", + "children": [ + { + "id": "0e1f907b84f1ee3d", + "type": "leaf", + "state": { + "type": "backlink", + "state": { + "file": "Readme.md", + "collapseAll": false, + "extraContext": false, + "sortOrder": "alphabetical", + "showSearch": false, + "searchQuery": "", + "backlinkCollapsed": false, + "unlinkedCollapsed": true + } + } + }, + { + "id": "c1ee775654e1acda", + "type": "leaf", + "state": { + "type": "outgoing-link", + "state": { + "file": "Readme.md", + "linksCollapsed": false, + "unlinkedCollapsed": true + } + } + }, + { + "id": "bfc488ea95077d03", + "type": "leaf", + "state": { + "type": "tag", + "state": { + "sortOrder": "frequency", + "useHierarchy": true + } + } + }, + { + "id": "5b6b2d6ae86136eb", + "type": "leaf", + "state": { + "type": "outline", + "state": { + "file": "Readme.md" + } + } + } + ] + } + ], + "direction": "horizontal", + "width": 300, + "collapsed": true + }, + "left-ribbon": { + "hiddenItems": { + "switcher:Schnellauswahl öffnen": false, + "graph:Graphen-Ansicht öffnen": false, + "canvas:Neuen Canvas erstellen": false, + "daily-notes:Heutige Notiz öffnen": false, + "templates:Vorlage einfügen": false, + "command-palette:Befehlspalette öffnen": false, + "cicada-sync:CI-SYNC": false + } + }, + "active": "549e5793024b5758", + "lastOpenFiles": [ + "Readme.md" + ] +} \ No newline at end of file diff --git a/Readme.md b/Readme.md new file mode 100644 index 0000000..690531b --- /dev/null +++ b/Readme.md @@ -0,0 +1,9 @@ +# Entwicklung des rpi-virtuell Materialpools + +Schwerpunkte: + +- Konkrete **Arbeitsvorhaben**, die bereits hier aufgelistet sind, können wir in eigene Issues als **Tasks** überführen und an ein Board heften. +- Vorschläge zur Weiterentwicklung des Materialpools können wir in einzelne **Proposals** in jeweils ein eigenes Issue überführen und dort weiterentwickeln. +- Gesprächsprotokolle rund um die **Vernetzungsoptionen und den Datenaustausch** mit dem Materialpool. +- Entwicklung von **Qualitätskriterien** für die redaktionelle und maschinelle Erfassung und Verarbeitung neuer Materialien. +- Allgemeine Überlegungen, die wir zunächst in der Matrix diskutieren können. \ No newline at end of file