diff --git a/.obsidian/config b/.obsidian/config new file mode 100644 index 000000000..05b6d2862 --- /dev/null +++ b/.obsidian/config @@ -0,0 +1 @@ +{"pluginEnabledStatus":{"file-explorer":true,"global-search":true,"switcher":true,"graph":true,"backlink":true,"command-palette":true,"markdown-importer":true,"word-count":true,"open-with-default-app":true,"file-recovery":true,"daily-notes":true,"templates":true,"random-note":true,"outline":true,"audio-recorder":true,"starred":true,"page-preview":true,"tag-pane":false},"vimMode":true,"strictLineBreaks":false,"enabledPlugins":[],"hotkeys":{"daily-notes":[{"modifiers":["Alt"],"key":"D"}],"daily-notes:goto-prev":[{"modifiers":["Alt"],"key":"Y"}],"daily-notes:goto-next":[{"modifiers":["Alt"],"key":"T"}]}} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-git/main.js b/.obsidian/plugins/obsidian-git/main.js new file mode 100644 index 000000000..843fc65f1 --- /dev/null +++ b/.obsidian/plugins/obsidian-git/main.js @@ -0,0 +1,6523 @@ +'use strict'; + +var child_process_1 = require('child_process'); +var obsidian = require('obsidian'); +var fs_1 = require('fs'); +var tty = require('tty'); +var util$1 = require('util'); +var os = require('os'); + +function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } + +var child_process_1__default = /*#__PURE__*/_interopDefaultLegacy(child_process_1); +var fs_1__default = /*#__PURE__*/_interopDefaultLegacy(fs_1); +var tty__default = /*#__PURE__*/_interopDefaultLegacy(tty); +var util__default = /*#__PURE__*/_interopDefaultLegacy(util$1); +var os__default = /*#__PURE__*/_interopDefaultLegacy(os); + +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise */ + +var extendStatics = function(d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); +}; + +function __extends(d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +} + +var __assign = function() { + __assign = Object.assign || function __assign(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +function __generator(thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +} + +function __spreadArray(to, from) { + for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) + to[j] = from[i]; + return to; +} + +var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + +function createCommonjsModule(fn, basedir, module) { + return module = { + path: basedir, + exports: {}, + require: function (path, base) { + return commonjsRequire(path, (base === undefined || base === null) ? module.path : base); + } + }, fn(module, module.exports), module.exports; +} + +function commonjsRequire () { + throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs'); +} + +var gitError = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.GitError = void 0; +/** + * The `GitError` is thrown when the underlying `git` process throws a + * fatal exception (eg an `ENOENT` exception when attempting to use a + * non-writable directory as the root for your repo), and acts as the + * base class for more specific errors thrown by the parsing of the + * git response or errors in the configuration of the task about to + * be run. + * + * When an exception is thrown, pending tasks in the same instance will + * not be executed. The recommended way to run a series of tasks that + * can independently fail without needing to prevent future tasks from + * running is to catch them individually: + * + * ```typescript + import { gitP, SimpleGit, GitError, PullResult } from 'simple-git'; + + function catchTask (e: GitError) { + return e. + } + + const git = gitP(repoWorkingDir); + const pulled: PullResult | GitError = await git.pull().catch(catchTask); + const pushed: string | GitError = await git.pushTags().catch(catchTask); + ``` + */ +class GitError extends Error { + constructor(task, message) { + super(message); + this.task = task; + Object.setPrototypeOf(this, new.target.prototype); + } +} +exports.GitError = GitError; +//# sourceMappingURL=git-error.js.map +}); + +var gitResponseError = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.GitResponseError = void 0; + +/** + * The `GitResponseError` is the wrapper for a parsed response that is treated as + * a fatal error, for example attempting a `merge` can leave the repo in a corrupted + * state when there are conflicts so the task will reject rather than resolve. + * + * For example, catching the merge conflict exception: + * + * ```typescript + import { gitP, SimpleGit, GitResponseError, MergeSummary } from 'simple-git'; + + const git = gitP(repoRoot); + const mergeOptions: string[] = ['--no-ff', 'other-branch']; + const mergeSummary: MergeSummary = await git.merge(mergeOptions) + .catch((e: GitResponseError) => e.git); + + if (mergeSummary.failed) { + // deal with the error + } + ``` + */ +class GitResponseError extends gitError.GitError { + constructor( + /** + * `.git` access the parsed response that is treated as being an error + */ + git, message) { + super(undefined, message || String(git)); + this.git = git; + } +} +exports.GitResponseError = GitResponseError; +//# sourceMappingURL=git-response-error.js.map +}); + +var gitConstructError = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.GitConstructError = void 0; + +/** + * The `GitConstructError` is thrown when an error occurs in the constructor + * of the `simple-git` instance itself. Most commonly as a result of using + * a `baseDir` option that points to a folder that either does not exist, + * or cannot be read by the user the node script is running as. + * + * Check the `.message` property for more detail including the properties + * passed to the constructor. + */ +class GitConstructError extends gitError.GitError { + constructor(config, message) { + super(undefined, message); + this.config = config; + } +} +exports.GitConstructError = GitConstructError; +//# sourceMappingURL=git-construct-error.js.map +}); + +var gitPluginError = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.GitPluginError = void 0; + +class GitPluginError extends gitError.GitError { + constructor(task, plugin, message) { + super(task, message); + this.task = task; + this.plugin = plugin; + Object.setPrototypeOf(this, new.target.prototype); + } +} +exports.GitPluginError = GitPluginError; +//# sourceMappingURL=git-plugin-error.js.map +}); + +var taskConfigurationError = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.TaskConfigurationError = void 0; + +/** + * The `TaskConfigurationError` is thrown when a command was incorrectly + * configured. An error of this kind means that no attempt was made to + * run your command through the underlying `git` binary. + * + * Check the `.message` property for more detail on why your configuration + * resulted in an error. + */ +class TaskConfigurationError extends gitError.GitError { + constructor(message) { + super(undefined, message); + } +} +exports.TaskConfigurationError = TaskConfigurationError; +//# sourceMappingURL=task-configuration-error.js.map +}); + +/** + * Helpers. + */ + +var s = 1000; +var m = s * 60; +var h = m * 60; +var d = h * 24; +var w = d * 7; +var y = d * 365.25; + +/** + * Parse or format the given `val`. + * + * Options: + * + * - `long` verbose formatting [false] + * + * @param {String|Number} val + * @param {Object} [options] + * @throws {Error} throw an error if val is not a non-empty string or a number + * @return {String|Number} + * @api public + */ + +var ms = 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) + ); +}; + +/** + * Parse the given `str` and return milliseconds. + * + * @param {String} str + * @return {Number} + * @api private + */ + +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 undefined; + } +} + +/** + * Short format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +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'; +} + +/** + * Long format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +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'; +} + +/** + * Pluralization helper. + */ + +function plural(ms, msAbs, n, name) { + var isPlural = msAbs >= n * 1.5; + return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : ''); +} + +/** + * This is the common logic for both the Node.js and web browser + * implementations of `debug()`. + */ + +function setup(env) { + createDebug.debug = createDebug; + createDebug.default = createDebug; + createDebug.coerce = coerce; + createDebug.disable = disable; + createDebug.enable = enable; + createDebug.enabled = enabled; + createDebug.humanize = ms; + createDebug.destroy = destroy; + + Object.keys(env).forEach(key => { + createDebug[key] = env[key]; + }); + + /** + * The currently active debug mode names, and names to skip. + */ + + createDebug.names = []; + createDebug.skips = []; + + /** + * Map of special "%n" handling functions, for the debug "format" argument. + * + * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N". + */ + createDebug.formatters = {}; + + /** + * Selects a color for a debug namespace + * @param {String} namespace The namespace string for the for the debug instance to be colored + * @return {Number|String} An ANSI color code for the given namespace + * @api private + */ + function selectColor(namespace) { + let hash = 0; + + for (let i = 0; i < namespace.length; i++) { + hash = ((hash << 5) - hash) + namespace.charCodeAt(i); + hash |= 0; // Convert to 32bit integer + } + + return createDebug.colors[Math.abs(hash) % createDebug.colors.length]; + } + createDebug.selectColor = selectColor; + + /** + * Create a debugger with the given `namespace`. + * + * @param {String} namespace + * @return {Function} + * @api public + */ + function createDebug(namespace) { + let prevTime; + let enableOverride = null; + + function debug(...args) { + // Disabled? + if (!debug.enabled) { + return; + } + + const self = debug; + + // Set `diff` timestamp + const curr = Number(new Date()); + const ms = curr - (prevTime || curr); + self.diff = ms; + self.prev = prevTime; + self.curr = curr; + prevTime = curr; + + args[0] = createDebug.coerce(args[0]); + + if (typeof args[0] !== 'string') { + // Anything else let's inspect with %O + args.unshift('%O'); + } + + // Apply any `formatters` transformations + let index = 0; + args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => { + // If we encounter an escaped % then don't increase the array index + if (match === '%%') { + return '%'; + } + index++; + const formatter = createDebug.formatters[format]; + if (typeof formatter === 'function') { + const val = args[index]; + match = formatter.call(self, val); + + // Now we need to remove `args[index]` since it's inlined in the `format` + args.splice(index, 1); + index--; + } + return match; + }); + + // Apply env-specific formatting (colors, etc.) + createDebug.formatArgs.call(self, args); + + const logFn = self.log || createDebug.log; + logFn.apply(self, args); + } + + debug.namespace = namespace; + debug.useColors = createDebug.useColors(); + debug.color = createDebug.selectColor(namespace); + debug.extend = extend; + debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release. + + Object.defineProperty(debug, 'enabled', { + enumerable: true, + configurable: false, + get: () => enableOverride === null ? createDebug.enabled(namespace) : enableOverride, + set: v => { + enableOverride = v; + } + }); + + // Env-specific initialization logic for debug instances + if (typeof createDebug.init === 'function') { + createDebug.init(debug); + } + + return debug; + } + + function extend(namespace, delimiter) { + const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace); + newDebug.log = this.log; + return newDebug; + } + + /** + * Enables a debug mode by namespaces. This can include modes + * separated by a colon and wildcards. + * + * @param {String} namespaces + * @api public + */ + function enable(namespaces) { + createDebug.save(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]) { + // ignore empty strings + continue; + } + + namespaces = split[i].replace(/\*/g, '.*?'); + + if (namespaces[0] === '-') { + createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$')); + } else { + createDebug.names.push(new RegExp('^' + namespaces + '$')); + } + } + } + + /** + * Disable debug output. + * + * @return {String} namespaces + * @api public + */ + function disable() { + const namespaces = [ + ...createDebug.names.map(toNamespace), + ...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace) + ].join(','); + createDebug.enable(''); + return namespaces; + } + + /** + * Returns true if the given mode name is enabled, false otherwise. + * + * @param {String} name + * @return {Boolean} + * @api public + */ + 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; + } + + /** + * Convert regexp to namespace + * + * @param {RegExp} regxep + * @return {String} namespace + * @api private + */ + function toNamespace(regexp) { + return regexp.toString() + .substring(2, regexp.toString().length - 2) + .replace(/\.\*\?$/, '*'); + } + + /** + * Coerce `val`. + * + * @param {Mixed} val + * @return {Mixed} + * @api private + */ + function coerce(val) { + if (val instanceof Error) { + return val.stack || val.message; + } + return val; + } + + /** + * XXX DO NOT USE. This is a temporary stub function. + * XXX It WILL be removed in the next major release. + */ + 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; +} + +var common = setup; + +var browser = createCommonjsModule(function (module, exports) { +/* eslint-env browser */ + +/** + * This is the web browser implementation of `debug()`. + */ + +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`.'); + } + }; +})(); + +/** + * Colors. + */ + +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' +]; + +/** + * Currently only WebKit-based Web Inspectors, Firefox >= v31, + * and the Firebug extension (any Firefox version) are known + * to support "%c" CSS customizations. + * + * TODO: add a `localStorage` variable to explicitly enable/disable colors + */ + +// eslint-disable-next-line complexity +function useColors() { + // NB: In an Electron preload script, document will be defined but not fully + // initialized. Since we know we're in Chrome, we'll just detect this case + // explicitly + if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) { + return true; + } + + // Internet Explorer and Edge do not support colors. + if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) { + return false; + } + + // Is webkit? http://stackoverflow.com/a/16459606/376773 + // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632 + 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+)/)); +} + +/** + * Colorize log arguments if enabled. + * + * @api public + */ + +function formatArgs(args) { + args[0] = (this.useColors ? '%c' : '') + + this.namespace + + (this.useColors ? ' %c' : ' ') + + args[0] + + (this.useColors ? '%c ' : ' ') + + '+' + module.exports.humanize(this.diff); + + if (!this.useColors) { + return; + } + + const c = 'color: ' + this.color; + args.splice(1, 0, c, 'color: inherit'); + + // The final "%c" is somewhat tricky, because there could be other + // arguments passed either before or after the %c, so we need to + // figure out the correct index to insert the CSS into + let index = 0; + let lastC = 0; + args[0].replace(/%[a-zA-Z%]/g, match => { + if (match === '%%') { + return; + } + index++; + if (match === '%c') { + // We only are interested in the *last* %c + // (the user may have provided their own) + lastC = index; + } + }); + + args.splice(lastC, 0, c); +} + +/** + * Invokes `console.debug()` when available. + * No-op when `console.debug` is not a "function". + * If `console.debug` is not available, falls back + * to `console.log`. + * + * @api public + */ +exports.log = console.debug || console.log || (() => {}); + +/** + * Save `namespaces`. + * + * @param {String} namespaces + * @api private + */ +function save(namespaces) { + try { + if (namespaces) { + exports.storage.setItem('debug', namespaces); + } else { + exports.storage.removeItem('debug'); + } + } catch (error) { + // Swallow + // XXX (@Qix-) should we be logging these? + } +} + +/** + * Load `namespaces`. + * + * @return {String} returns the previously persisted debug modes + * @api private + */ +function load() { + let r; + try { + r = exports.storage.getItem('debug'); + } catch (error) { + // Swallow + // XXX (@Qix-) should we be logging these? + } + + // If debug isn't set in LS, and we're in Electron, try to load $DEBUG + if (!r && typeof process !== 'undefined' && 'env' in process) { + r = process.env.DEBUG; + } + + return r; +} + +/** + * Localstorage attempts to return the localstorage. + * + * This is necessary because safari throws + * when a user disables cookies/localstorage + * and you attempt to access it. + * + * @return {LocalStorage} + * @api private + */ + +function localstorage() { + try { + // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context + // The Browser also has localStorage in the global context. + return localStorage; + } catch (error) { + // Swallow + // XXX (@Qix-) should we be logging these? + } +} + +module.exports = common(exports); + +const {formatters} = module.exports; + +/** + * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default. + */ + +formatters.j = function (v) { + try { + return JSON.stringify(v); + } catch (error) { + return '[UnexpectedJSONParseError]: ' + error.message; + } +}; +}); + +var hasFlag = (flag, argv = process.argv) => { + const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--'); + const position = argv.indexOf(prefix + flag); + const terminatorPosition = argv.indexOf('--'); + return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition); +}; + +const {env} = process; + +let forceColor; +if (hasFlag('no-color') || + hasFlag('no-colors') || + hasFlag('color=false') || + hasFlag('color=never')) { + forceColor = 0; +} else if (hasFlag('color') || + hasFlag('colors') || + hasFlag('color=true') || + hasFlag('color=always')) { + forceColor = 1; +} + +if ('FORCE_COLOR' in env) { + if (env.FORCE_COLOR === 'true') { + forceColor = 1; + } else if (env.FORCE_COLOR === 'false') { + forceColor = 0; + } else { + forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3); + } +} + +function translateLevel(level) { + if (level === 0) { + return false; + } + + return { + level, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3 + }; +} + +function supportsColor(haveStream, streamIsTTY) { + if (forceColor === 0) { + return 0; + } + + if (hasFlag('color=16m') || + hasFlag('color=full') || + hasFlag('color=truecolor')) { + return 3; + } + + if (hasFlag('color=256')) { + return 2; + } + + if (haveStream && !streamIsTTY && forceColor === undefined) { + return 0; + } + + const min = forceColor || 0; + + if (env.TERM === 'dumb') { + return min; + } + + if (process.platform === 'win32') { + // Windows 10 build 10586 is the first Windows release that supports 256 colors. + // Windows 10 build 14931 is the first release that supports 16m/TrueColor. + const osRelease = os__default['default'].release().split('.'); + if ( + Number(osRelease[0]) >= 10 && + Number(osRelease[2]) >= 10586 + ) { + return Number(osRelease[2]) >= 14931 ? 3 : 2; + } + + return 1; + } + + if ('CI' in env) { + if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env) || env.CI_NAME === 'codeship') { + return 1; + } + + return min; + } + + if ('TEAMCITY_VERSION' in env) { + return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0; + } + + if (env.COLORTERM === 'truecolor') { + return 3; + } + + if ('TERM_PROGRAM' in env) { + const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10); + + switch (env.TERM_PROGRAM) { + case 'iTerm.app': + return version >= 3 ? 3 : 2; + case 'Apple_Terminal': + return 2; + // No default + } + } + + if (/-256(color)?$/i.test(env.TERM)) { + return 2; + } + + if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) { + return 1; + } + + if ('COLORTERM' in env) { + return 1; + } + + return min; +} + +function getSupportLevel(stream) { + const level = supportsColor(stream, stream && stream.isTTY); + return translateLevel(level); +} + +var supportsColor_1 = { + supportsColor: getSupportLevel, + stdout: translateLevel(supportsColor(true, tty__default['default'].isatty(1))), + stderr: translateLevel(supportsColor(true, tty__default['default'].isatty(2))) +}; + +var node = createCommonjsModule(function (module, exports) { +/** + * Module dependencies. + */ + + + + +/** + * This is the Node.js implementation of `debug()`. + */ + +exports.init = init; +exports.log = log; +exports.formatArgs = formatArgs; +exports.save = save; +exports.load = load; +exports.useColors = useColors; +exports.destroy = util__default['default'].deprecate( + () => {}, + 'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.' +); + +/** + * Colors. + */ + +exports.colors = [6, 2, 3, 4, 5, 1]; + +try { + // Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json) + // eslint-disable-next-line import/no-extraneous-dependencies + const supportsColor = supportsColor_1; + + if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) { + exports.colors = [ + 20, + 21, + 26, + 27, + 32, + 33, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 56, + 57, + 62, + 63, + 68, + 69, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 92, + 93, + 98, + 99, + 112, + 113, + 128, + 129, + 134, + 135, + 148, + 149, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 178, + 179, + 184, + 185, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 214, + 215, + 220, + 221 + ]; + } +} catch (error) { + // Swallow - we only care if `supports-color` is available; it doesn't have to be. +} + +/** + * Build up the default `inspectOpts` object from the environment variables. + * + * $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js + */ + +exports.inspectOpts = Object.keys(process.env).filter(key => { + return /^debug_/i.test(key); +}).reduce((obj, key) => { + // Camel-case + const prop = key + .substring(6) + .toLowerCase() + .replace(/_([a-z])/g, (_, k) => { + return k.toUpperCase(); + }); + + // Coerce string value into JS value + let val = process.env[key]; + if (/^(yes|on|true|enabled)$/i.test(val)) { + val = true; + } else if (/^(no|off|false|disabled)$/i.test(val)) { + val = false; + } else if (val === 'null') { + val = null; + } else { + val = Number(val); + } + + obj[prop] = val; + return obj; +}, {}); + +/** + * Is stdout a TTY? Colored output is enabled when `true`. + */ + +function useColors() { + return 'colors' in exports.inspectOpts ? + Boolean(exports.inspectOpts.colors) : + tty__default['default'].isatty(process.stderr.fd); +} + +/** + * Adds ANSI color escape codes if enabled. + * + * @api public + */ + +function formatArgs(args) { + const {namespace: name, useColors} = this; + + if (useColors) { + const c = this.color; + const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c); + const prefix = ` ${colorCode};1m${name} \u001B[0m`; + + args[0] = prefix + args[0].split('\n').join('\n' + prefix); + args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m'); + } else { + args[0] = getDate() + name + ' ' + args[0]; + } +} + +function getDate() { + if (exports.inspectOpts.hideDate) { + return ''; + } + return new Date().toISOString() + ' '; +} + +/** + * Invokes `util.format()` with the specified arguments and writes to stderr. + */ + +function log(...args) { + return process.stderr.write(util__default['default'].format(...args) + '\n'); +} + +/** + * Save `namespaces`. + * + * @param {String} namespaces + * @api private + */ +function save(namespaces) { + if (namespaces) { + process.env.DEBUG = namespaces; + } else { + // If you set a process.env field to null or undefined, it gets cast to the + // string 'null' or 'undefined'. Just delete instead. + delete process.env.DEBUG; + } +} + +/** + * Load `namespaces`. + * + * @return {String} returns the previously persisted debug modes + * @api private + */ + +function load() { + return process.env.DEBUG; +} + +/** + * Init logic for `debug` instances. + * + * Create a new `inspectOpts` object in case `useColors` is set + * differently for a particular `debug` instance. + */ + +function init(debug) { + debug.inspectOpts = {}; + + const keys = Object.keys(exports.inspectOpts); + for (let i = 0; i < keys.length; i++) { + debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]]; + } +} + +module.exports = common(exports); + +const {formatters} = module.exports; + +/** + * Map %o to `util.inspect()`, all on a single line. + */ + +formatters.o = function (v) { + this.inspectOpts.colors = this.useColors; + return util__default['default'].inspect(v, this.inspectOpts) + .split('\n') + .map(str => str.trim()) + .join(' '); +}; + +/** + * Map %O to `util.inspect()`, allowing multiple lines if needed. + */ + +formatters.O = function (v) { + this.inspectOpts.colors = this.useColors; + return util__default['default'].inspect(v, this.inspectOpts); +}; +}); + +var src$2 = createCommonjsModule(function (module) { +/** + * Detect Electron renderer / nwjs process, which is node, but we should + * treat as a browser. + */ + +if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) { + module.exports = browser; +} else { + module.exports = node; +} +}); + +var src$1 = createCommonjsModule(function (module, exports) { +var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); + +const debug_1 = __importDefault(src$2); +const log = debug_1.default('@kwsites/file-exists'); +function check(path, isFile, isDirectory) { + log(`checking %s`, path); + try { + const stat = fs_1__default['default'].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; + } +} +/** + * Synchronous validation of a path existing either as a file or as a directory. + * + * @param {string} path The path to check + * @param {number} type One or both of the exported numeric constants + */ +function exists(path, type = exports.READABLE) { + return check(path, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0); +} +exports.exists = exists; +/** + * Constant representing a file + */ +exports.FILE = 1; +/** + * Constant representing a folder + */ +exports.FOLDER = 2; +/** + * Constant representing either a file or a folder + */ +exports.READABLE = exports.FILE + exports.FOLDER; +//# sourceMappingURL=index.js.map +}); + +var dist$1 = createCommonjsModule(function (module, exports) { +function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; +} +Object.defineProperty(exports, "__esModule", { value: true }); +__export(src$1); +//# sourceMappingURL=index.js.map +}); + +var util = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.bufferToString = exports.prefixedArray = exports.asNumber = exports.asStringArray = exports.asArray = exports.objectToString = exports.remove = exports.including = exports.append = exports.folderExists = exports.forEachLineWithContent = exports.toLinesWithContent = exports.last = exports.first = exports.splitOn = exports.isUserFunction = exports.asFunction = exports.NOOP = void 0; + +const NOOP = () => { +}; +exports.NOOP = NOOP; +/** + * Returns either the source argument when it is a `Function`, or the default + * `NOOP` function constant + */ +function asFunction(source) { + return typeof source === 'function' ? source : exports.NOOP; +} +exports.asFunction = asFunction; +/** + * Determines whether the supplied argument is both a function, and is not + * the `NOOP` function. + */ +function isUserFunction(source) { + return (typeof source === 'function' && source !== exports.NOOP); +} +exports.isUserFunction = isUserFunction; +function splitOn(input, char) { + const index = input.indexOf(char); + if (index <= 0) { + return [input, '']; + } + return [ + input.substr(0, index), + input.substr(index + 1), + ]; +} +exports.splitOn = splitOn; +function first(input, offset = 0) { + return isArrayLike(input) && input.length > offset ? input[offset] : undefined; +} +exports.first = first; +function last(input, offset = 0) { + if (isArrayLike(input) && input.length > offset) { + return input[input.length - 1 - offset]; + } +} +exports.last = last; +function isArrayLike(input) { + return !!(input && typeof input.length === 'number'); +} +function toLinesWithContent(input, trimmed = true, separator = '\n') { + return input.split(separator) + .reduce((output, line) => { + const lineContent = trimmed ? line.trim() : line; + if (lineContent) { + output.push(lineContent); + } + return output; + }, []); +} +exports.toLinesWithContent = toLinesWithContent; +function forEachLineWithContent(input, callback) { + return toLinesWithContent(input, true).map(line => callback(line)); +} +exports.forEachLineWithContent = forEachLineWithContent; +function folderExists(path) { + return dist$1.exists(path, dist$1.FOLDER); +} +exports.folderExists = folderExists; +/** + * Adds `item` into the `target` `Array` or `Set` when it is not already present and returns the `item`. + */ +function append(target, item) { + if (Array.isArray(target)) { + if (!target.includes(item)) { + target.push(item); + } + } + else { + target.add(item); + } + return item; +} +exports.append = append; +/** + * Adds `item` into the `target` `Array` when it is not already present and returns the `target`. + */ +function including(target, item) { + if (Array.isArray(target) && !target.includes(item)) { + target.push(item); + } + return target; +} +exports.including = including; +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; +} +exports.remove = remove; +exports.objectToString = Object.prototype.toString.call.bind(Object.prototype.toString); +function asArray(source) { + return Array.isArray(source) ? source : [source]; +} +exports.asArray = asArray; +function asStringArray(source) { + return asArray(source).map(String); +} +exports.asStringArray = asStringArray; +function asNumber(source, onNaN = 0) { + if (source == null) { + return onNaN; + } + const num = parseInt(source, 10); + return isNaN(num) ? onNaN : num; +} +exports.asNumber = asNumber; +function prefixedArray(input, prefix) { + const output = []; + for (let i = 0, max = input.length; i < max; i++) { + output.push(prefix, input[i]); + } + return output; +} +exports.prefixedArray = prefixedArray; +function bufferToString(input) { + return (Array.isArray(input) ? Buffer.concat(input) : input).toString('utf-8'); +} +exports.bufferToString = bufferToString; +//# sourceMappingURL=util.js.map +}); + +var argumentFilters = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.filterHasLength = exports.filterFunction = exports.filterPlainObject = exports.filterStringOrStringArray = exports.filterStringArray = exports.filterString = exports.filterPrimitives = exports.filterArray = exports.filterType = void 0; + +function filterType(input, filter, def) { + if (filter(input)) { + return input; + } + return (arguments.length > 2) ? def : undefined; +} +exports.filterType = filterType; +const filterArray = (input) => { + return Array.isArray(input); +}; +exports.filterArray = filterArray; +function filterPrimitives(input, omit) { + return /number|string|boolean/.test(typeof input) && (!omit || !omit.includes((typeof input))); +} +exports.filterPrimitives = filterPrimitives; +const filterString = (input) => { + return typeof input === 'string'; +}; +exports.filterString = filterString; +const filterStringArray = (input) => { + return Array.isArray(input) && input.every(exports.filterString); +}; +exports.filterStringArray = filterStringArray; +const filterStringOrStringArray = (input) => { + return exports.filterString(input) || (Array.isArray(input) && input.every(exports.filterString)); +}; +exports.filterStringOrStringArray = filterStringOrStringArray; +function filterPlainObject(input) { + return !!input && util.objectToString(input) === '[object Object]'; +} +exports.filterPlainObject = filterPlainObject; +function filterFunction(input) { + return typeof input === 'function'; +} +exports.filterFunction = filterFunction; +const filterHasLength = (input) => { + if (input == null || 'number|boolean|function'.includes(typeof input)) { + return false; + } + return Array.isArray(input) || typeof input === 'string' || typeof input.length === 'number'; +}; +exports.filterHasLength = filterHasLength; +//# sourceMappingURL=argument-filters.js.map +}); + +var exitCodes = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ExitCodes = void 0; +(function (ExitCodes) { + ExitCodes[ExitCodes["SUCCESS"] = 0] = "SUCCESS"; + ExitCodes[ExitCodes["ERROR"] = 1] = "ERROR"; + ExitCodes[ExitCodes["UNCLEAN"] = 128] = "UNCLEAN"; +})(exports.ExitCodes || (exports.ExitCodes = {})); +//# sourceMappingURL=exit-codes.js.map +}); + +var gitOutputStreams = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.GitOutputStreams = void 0; +class GitOutputStreams { + constructor(stdOut, stdErr) { + this.stdOut = stdOut; + this.stdErr = stdErr; + } + asStrings() { + return new GitOutputStreams(this.stdOut.toString('utf8'), this.stdErr.toString('utf8')); + } +} +exports.GitOutputStreams = GitOutputStreams; +//# sourceMappingURL=git-output-streams.js.map +}); + +var lineParser = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.RemoteLineParser = exports.LineParser = void 0; +class LineParser { + 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; + } + } + // @ts-ignore + 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)); + } +} +exports.LineParser = LineParser; +class RemoteLineParser 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); + } + } +} +exports.RemoteLineParser = RemoteLineParser; +//# sourceMappingURL=line-parser.js.map +}); + +var simpleGitOptions = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createInstanceConfig = void 0; +const defaultOptions = { + binary: 'git', + maxConcurrentProcesses: 5, + config: [], +}; +function createInstanceConfig(...options) { + const baseDir = process.cwd(); + const config = Object.assign(Object.assign({ baseDir }, defaultOptions), ...(options.filter(o => typeof o === 'object' && o))); + config.baseDir = config.baseDir || baseDir; + return config; +} +exports.createInstanceConfig = createInstanceConfig; +//# sourceMappingURL=simple-git-options.js.map +}); + +var taskOptions = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.trailingFunctionArgument = exports.trailingOptionsArgument = exports.getTrailingOptions = exports.appendTaskOptions = void 0; + + +function appendTaskOptions(options, commands = []) { + if (!argumentFilters.filterPlainObject(options)) { + return commands; + } + return Object.keys(options).reduce((commands, key) => { + const value = options[key]; + if (argumentFilters.filterPrimitives(value, ['boolean'])) { + commands.push(key + '=' + value); + } + else { + commands.push(key); + } + return commands; + }, commands); +} +exports.appendTaskOptions = appendTaskOptions; +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; +} +exports.getTrailingOptions = getTrailingOptions; +function trailingArrayArgument(args) { + const hasTrailingCallback = typeof util.last(args) === 'function'; + return argumentFilters.filterType(util.last(args, hasTrailingCallback ? 1 : 0), argumentFilters.filterArray, []); +} +/** + * Given any number of arguments, returns the trailing options argument, ignoring a trailing function argument + * if there is one. When not found, the return value is null. + */ +function trailingOptionsArgument(args) { + const hasTrailingCallback = argumentFilters.filterFunction(util.last(args)); + return argumentFilters.filterType(util.last(args, hasTrailingCallback ? 1 : 0), argumentFilters.filterPlainObject); +} +exports.trailingOptionsArgument = trailingOptionsArgument; +/** + * Returns either the source argument when it is a `Function`, or the default + * `NOOP` function constant + */ +function trailingFunctionArgument(args, includeNoop = true) { + const callback = util.asFunction(util.last(args)); + return includeNoop || util.isUserFunction(callback) ? callback : undefined; +} +exports.trailingFunctionArgument = trailingFunctionArgument; +//# sourceMappingURL=task-options.js.map +}); + +var taskParser = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseStringResponse = exports.callTaskParser = void 0; + +function callTaskParser(parser, streams) { + return parser(streams.stdOut, streams.stdErr); +} +exports.callTaskParser = callTaskParser; +function parseStringResponse(result, parsers, ...texts) { + texts.forEach(text => { + for (let lines = util.toLinesWithContent(text), i = 0, max = lines.length; i < max; i++) { + const line = (offset = 0) => { + if ((i + offset) >= max) { + return; + } + return lines[i + offset]; + }; + parsers.some(({ parse }) => parse(line, result)); + } + }); + return result; +} +exports.parseStringResponse = parseStringResponse; +//# sourceMappingURL=task-parser.js.map +}); + +var utils = createCommonjsModule(function (module, exports) { +var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(argumentFilters, exports); +__exportStar(exitCodes, exports); +__exportStar(gitOutputStreams, exports); +__exportStar(lineParser, exports); +__exportStar(simpleGitOptions, exports); +__exportStar(taskOptions, exports); +__exportStar(taskParser, exports); +__exportStar(util, exports); +//# sourceMappingURL=index.js.map +}); + +var checkIsRepo = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.checkIsBareRepoTask = exports.checkIsRepoRootTask = exports.checkIsRepoTask = exports.CheckRepoActions = void 0; + +var CheckRepoActions; +(function (CheckRepoActions) { + CheckRepoActions["BARE"] = "bare"; + CheckRepoActions["IN_TREE"] = "tree"; + CheckRepoActions["IS_REPO_ROOT"] = "root"; +})(CheckRepoActions = exports.CheckRepoActions || (exports.CheckRepoActions = {})); +const onError = ({ exitCode }, error, done, fail) => { + if (exitCode === utils.ExitCodes.UNCLEAN && isNotRepoMessage(error)) { + return done(Buffer.from('false')); + } + fail(error); +}; +const parser = (text) => { + return text.trim() === 'true'; +}; +function checkIsRepoTask(action) { + switch (action) { + case CheckRepoActions.BARE: + return checkIsBareRepoTask(); + case CheckRepoActions.IS_REPO_ROOT: + return checkIsRepoRootTask(); + } + const commands = ['rev-parse', '--is-inside-work-tree']; + return { + commands, + format: 'utf-8', + onError, + parser, + }; +} +exports.checkIsRepoTask = checkIsRepoTask; +function checkIsRepoRootTask() { + const commands = ['rev-parse', '--git-dir']; + return { + commands, + format: 'utf-8', + onError, + parser(path) { + return /^\.(git)?$/.test(path.trim()); + }, + }; +} +exports.checkIsRepoRootTask = checkIsRepoRootTask; +function checkIsBareRepoTask() { + const commands = ['rev-parse', '--is-bare-repository']; + return { + commands, + format: 'utf-8', + onError, + parser, + }; +} +exports.checkIsBareRepoTask = checkIsBareRepoTask; +function isNotRepoMessage(error) { + return /(Not a git repository|Kein Git-Repository)/i.test(String(error)); +} +//# sourceMappingURL=check-is-repo.js.map +}); + +var CleanSummary = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.cleanSummaryParser = exports.CleanResponse = void 0; + +class CleanResponse { + constructor(dryRun) { + this.dryRun = dryRun; + this.paths = []; + this.files = []; + this.folders = []; + } +} +exports.CleanResponse = CleanResponse; +const removalRegexp = /^[a-z]+\s*/i; +const dryRunRemovalRegexp = /^[a-z]+\s+[a-z]+\s*/i; +const isFolderRegexp = /\/$/; +function cleanSummaryParser(dryRun, text) { + const summary = new CleanResponse(dryRun); + const regexp = dryRun ? dryRunRemovalRegexp : removalRegexp; + utils.toLinesWithContent(text).forEach(line => { + const removed = line.replace(regexp, ''); + summary.paths.push(removed); + (isFolderRegexp.test(removed) ? summary.folders : summary.files).push(removed); + }); + return summary; +} +exports.cleanSummaryParser = cleanSummaryParser; +//# sourceMappingURL=CleanSummary.js.map +}); + +var task = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isEmptyTask = exports.isBufferTask = exports.straightThroughBufferTask = exports.straightThroughStringTask = exports.configurationErrorTask = exports.adhocExecTask = exports.EMPTY_COMMANDS = void 0; + +exports.EMPTY_COMMANDS = []; +function adhocExecTask(parser) { + return { + commands: exports.EMPTY_COMMANDS, + format: 'utf-8', + parser, + }; +} +exports.adhocExecTask = adhocExecTask; +function configurationErrorTask(error) { + return { + commands: exports.EMPTY_COMMANDS, + format: 'utf-8', + parser() { + throw typeof error === 'string' ? new taskConfigurationError.TaskConfigurationError(error) : error; + } + }; +} +exports.configurationErrorTask = configurationErrorTask; +function straightThroughStringTask(commands, trimmed = false) { + return { + commands, + format: 'utf-8', + parser(text) { + return trimmed ? String(text).trim() : text; + }, + }; +} +exports.straightThroughStringTask = straightThroughStringTask; +function straightThroughBufferTask(commands) { + return { + commands, + format: 'buffer', + parser(buffer) { + return buffer; + }, + }; +} +exports.straightThroughBufferTask = straightThroughBufferTask; +function isBufferTask(task) { + return task.format === 'buffer'; +} +exports.isBufferTask = isBufferTask; +function isEmptyTask(task) { + return !task.commands.length; +} +exports.isEmptyTask = isEmptyTask; +//# sourceMappingURL=task.js.map +}); + +var clean = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isCleanOptionsArray = exports.cleanTask = exports.cleanWithOptionsTask = exports.CleanOptions = exports.CONFIG_ERROR_UNKNOWN_OPTION = exports.CONFIG_ERROR_MODE_REQUIRED = exports.CONFIG_ERROR_INTERACTIVE_MODE = void 0; + + + +exports.CONFIG_ERROR_INTERACTIVE_MODE = 'Git clean interactive mode is not supported'; +exports.CONFIG_ERROR_MODE_REQUIRED = 'Git clean mode parameter ("n" or "f") is required'; +exports.CONFIG_ERROR_UNKNOWN_OPTION = 'Git clean unknown option found in: '; +/** + * All supported option switches available for use in a `git.clean` operation + */ +var CleanOptions; +(function (CleanOptions) { + CleanOptions["DRY_RUN"] = "n"; + CleanOptions["FORCE"] = "f"; + CleanOptions["IGNORED_INCLUDED"] = "x"; + CleanOptions["IGNORED_ONLY"] = "X"; + CleanOptions["EXCLUDING"] = "e"; + CleanOptions["QUIET"] = "q"; + CleanOptions["RECURSIVE"] = "d"; +})(CleanOptions = exports.CleanOptions || (exports.CleanOptions = {})); +const CleanOptionValues = new Set(['i', ...utils.asStringArray(Object.values(CleanOptions))]); +function cleanWithOptionsTask(mode, customArgs) { + const { cleanMode, options, valid } = getCleanOptions(mode); + if (!cleanMode) { + return task.configurationErrorTask(exports.CONFIG_ERROR_MODE_REQUIRED); + } + if (!valid.options) { + return task.configurationErrorTask(exports.CONFIG_ERROR_UNKNOWN_OPTION + JSON.stringify(mode)); + } + options.push(...customArgs); + if (options.some(isInteractiveMode)) { + return task.configurationErrorTask(exports.CONFIG_ERROR_INTERACTIVE_MODE); + } + return cleanTask(cleanMode, options); +} +exports.cleanWithOptionsTask = cleanWithOptionsTask; +function cleanTask(mode, customArgs) { + const commands = ['clean', `-${mode}`, ...customArgs]; + return { + commands, + format: 'utf-8', + parser(text) { + return CleanSummary.cleanSummaryParser(mode === CleanOptions.DRY_RUN, text); + } + }; +} +exports.cleanTask = cleanTask; +function isCleanOptionsArray(input) { + return Array.isArray(input) && input.every(test => CleanOptionValues.has(test)); +} +exports.isCleanOptionsArray = isCleanOptionsArray; +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 === CleanOptions.FORCE || cleanMode === CleanOptions.DRY_RUN; +} +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'; +} +//# sourceMappingURL=clean.js.map +}); + +var reset = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getResetMode = exports.resetTask = exports.ResetMode = void 0; + +var ResetMode; +(function (ResetMode) { + ResetMode["MIXED"] = "mixed"; + ResetMode["SOFT"] = "soft"; + ResetMode["HARD"] = "hard"; + ResetMode["MERGE"] = "merge"; + ResetMode["KEEP"] = "keep"; +})(ResetMode = exports.ResetMode || (exports.ResetMode = {})); +const ResetModes = Array.from(Object.values(ResetMode)); +function resetTask(mode, customArgs) { + const commands = ['reset']; + if (isValidResetMode(mode)) { + commands.push(`--${mode}`); + } + commands.push(...customArgs); + return task.straightThroughStringTask(commands); +} +exports.resetTask = resetTask; +function getResetMode(mode) { + if (isValidResetMode(mode)) { + return mode; + } + switch (typeof mode) { + case 'string': + case 'undefined': + return ResetMode.SOFT; + } + return; +} +exports.getResetMode = getResetMode; +function isValidResetMode(mode) { + return ResetModes.includes(mode); +} +//# sourceMappingURL=reset.js.map +}); + +var api_1 = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); + + + + + + + + +const api = { + CheckRepoActions: checkIsRepo.CheckRepoActions, + CleanOptions: clean.CleanOptions, + GitConstructError: gitConstructError.GitConstructError, + GitError: gitError.GitError, + GitPluginError: gitPluginError.GitPluginError, + GitResponseError: gitResponseError.GitResponseError, + ResetMode: reset.ResetMode, + TaskConfigurationError: taskConfigurationError.TaskConfigurationError, +}; +exports.default = api; +//# sourceMappingURL=api.js.map +}); + +var commandConfigPrefixingPlugin_1 = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.commandConfigPrefixingPlugin = void 0; + +function commandConfigPrefixingPlugin(configuration) { + const prefix = utils.prefixedArray(configuration, '-c'); + return { + type: 'spawn.args', + action(data) { + return [...prefix, ...data]; + }, + }; +} +exports.commandConfigPrefixingPlugin = commandConfigPrefixingPlugin; +//# sourceMappingURL=command-config-prefixing-plugin.js.map +}); + +var errorDetection_plugin = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.errorDetectionPlugin = exports.errorDetectionHandler = void 0; + +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); + }; +} +exports.errorDetectionHandler = errorDetectionHandler; +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.GitError(undefined, error.toString('utf-8')) }; + } + return { + error + }; + }, + }; +} +exports.errorDetectionPlugin = errorDetectionPlugin; +//# sourceMappingURL=error-detection.plugin.js.map +}); + +var pluginStore = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PluginStore = void 0; + +class PluginStore { + constructor() { + this.plugins = new Set(); + } + add(plugin) { + const plugins = []; + utils.asArray(plugin).forEach(plugin => plugin && this.plugins.add(utils.append(plugins, plugin))); + return () => { + plugins.forEach(plugin => this.plugins.delete(plugin)); + }; + } + 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; + } +} +exports.PluginStore = PluginStore; +//# sourceMappingURL=plugin-store.js.map +}); + +var progressMonitorPlugin_1 = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.progressMonitorPlugin = void 0; + +function progressMonitorPlugin(progress) { + const progressCommand = '--progress'; + const progressMethods = ['checkout', 'clone', 'fetch', 'pull', 'push']; + const onProgress = { + type: 'spawn.after', + action(_data, context) { + var _a; + if (!context.commands.includes(progressCommand)) { + return; + } + (_a = context.spawned.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (chunk) => { + const message = /^([a-zA-Z ]+):\s*(\d+)% \((\d+)\/(\d+)\)/.exec(chunk.toString('utf8')); + if (!message) { + return; + } + progress({ + method: context.method, + stage: progressEventStage(message[1]), + progress: utils.asNumber(message[2]), + processed: utils.asNumber(message[3]), + total: utils.asNumber(message[4]), + }); + }); + } + }; + const onArgs = { + type: 'spawn.args', + action(args, context) { + if (!progressMethods.includes(context.method)) { + return args; + } + return utils.including(args, progressCommand); + } + }; + return [onArgs, onProgress]; +} +exports.progressMonitorPlugin = progressMonitorPlugin; +function progressEventStage(input) { + return String(input.toLowerCase().split(' ', 1)) || 'unknown'; +} +//# sourceMappingURL=progress-monitor-plugin.js.map +}); + +var simpleGitPlugin = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=simple-git-plugin.js.map +}); + +var timoutPlugin = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.timeoutPlugin = void 0; + +function timeoutPlugin({ block }) { + if (block > 0) { + return { + type: 'spawn.after', + action(_data, context) { + var _a, _b; + let timeout; + function wait() { + timeout && clearTimeout(timeout); + timeout = setTimeout(kill, block); + } + function stop() { + var _a, _b; + (_a = context.spawned.stdout) === null || _a === void 0 ? void 0 : _a.off('data', wait); + (_b = context.spawned.stderr) === null || _b === void 0 ? void 0 : _b.off('data', wait); + context.spawned.off('exit', stop); + context.spawned.off('close', stop); + } + function kill() { + stop(); + context.kill(new gitPluginError.GitPluginError(undefined, 'timeout', `block timeout reached`)); + } + (_a = context.spawned.stdout) === null || _a === void 0 ? void 0 : _a.on('data', wait); + (_b = context.spawned.stderr) === null || _b === void 0 ? void 0 : _b.on('data', wait); + context.spawned.on('exit', stop); + context.spawned.on('close', stop); + wait(); + } + }; + } +} +exports.timeoutPlugin = timeoutPlugin; +//# sourceMappingURL=timout-plugin.js.map +}); + +var plugins = createCommonjsModule(function (module, exports) { +var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(commandConfigPrefixingPlugin_1, exports); +__exportStar(errorDetection_plugin, exports); +__exportStar(pluginStore, exports); +__exportStar(progressMonitorPlugin_1, exports); +__exportStar(simpleGitPlugin, exports); +__exportStar(timoutPlugin, exports); +//# sourceMappingURL=index.js.map +}); + +var gitLogger = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.GitLogger = exports.createLogger = void 0; + + +src$2.default.formatters.L = (value) => String(utils.filterHasLength(value) ? value.length : '-'); +src$2.default.formatters.B = (value) => { + if (Buffer.isBuffer(value)) { + return value.toString('utf8'); + } + return utils.objectToString(value); +}; +function createLog() { + return src$2.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(utils.filterType(verbose, utils.filterString), debugDebugger, infoDebugger); + return step(initialStep); + function sibling(name, initial) { + return utils.append(spawned, createLogger(label, key.replace(/^[^:]+/, name), initial, infoDebugger)); + } + function step(phase) { + const stepPrefix = phase && `[${phase}]` || ''; + const debug = debugDebugger && prefixedLogger(debugDebugger, stepPrefix) || utils.NOOP; + const info = prefixedLogger(infoDebugger, `${labelPrefix} ${stepPrefix}`, debug); + return Object.assign(debugDebugger ? debug : info, { + label, + sibling, + info, + step, + }); + } +} +exports.createLogger = createLogger; +/** + * The `GitLogger` is used by the main `SimpleGit` runner to handle logging + * any warnings or errors. + */ +class GitLogger { + constructor(_out = createLog()) { + this._out = _out; + this.error = prefixedLogger(_out, '[ERROR]'); + this.warn = prefixedLogger(_out, '[WARN]'); + } + silent(silence = false) { + if (silence !== this._out.enabled) { + return; + } + const { namespace } = this._out; + const env = (process.env.DEBUG || '').split(',').filter(s => !!s); + const hasOn = env.includes(namespace); + const hasOff = env.includes(`-${namespace}`); + // enabling the log + if (!silence) { + if (hasOff) { + utils.remove(env, `-${namespace}`); + } + else { + env.push(namespace); + } + } + else { + if (hasOn) { + utils.remove(env, namespace); + } + else { + env.push(`-${namespace}`); + } + } + src$2.default.enable(env.join(',')); + } +} +exports.GitLogger = GitLogger; +//# sourceMappingURL=git-logger.js.map +}); + +var tasksPendingQueue = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.TasksPendingQueue = void 0; + + +class TasksPendingQueue { + constructor(logLabel = 'GitExecutor') { + this.logLabel = logLabel; + this._queue = new Map(); + } + withProgress(task) { + return this._queue.get(task); + } + createProgress(task) { + const name = TasksPendingQueue.getName(task.commands[0]); + const logger = gitLogger.createLogger(this.logLabel, name); + return { + task, + logger, + 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 }] of Array.from(this._queue.entries())) { + if (task === err.task) { + logger.info(`Failed %o`, err); + logger(`Fatal exception, any as-yet un-started tasks run through this executor will not be attempted`); + } + else { + logger.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.GitError(undefined, 'TasksPendingQueue: attempt called for an unknown task'); + } + progress.logger('Starting task'); + return progress; + } + static getName(name = 'empty') { + return `task:${name}:${++TasksPendingQueue.counter}`; + } +} +exports.TasksPendingQueue = TasksPendingQueue; +TasksPendingQueue.counter = 0; +//# sourceMappingURL=tasks-pending-queue.js.map +}); + +var gitExecutorChain = createCommonjsModule(function (module, exports) { +var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.GitExecutorChain = void 0; + + + + + +class GitExecutorChain { + constructor(_executor, _scheduler, _plugins) { + this._executor = _executor; + this._scheduler = _scheduler; + this._plugins = _plugins; + this._chain = Promise.resolve(); + this._queue = new tasksPendingQueue.TasksPendingQueue(); + } + get binary() { + return this._executor.binary; + } + get cwd() { + return this._executor.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$1) { + return __awaiter(this, void 0, void 0, function* () { + const onScheduleComplete = yield this._scheduler.next(); + const onQueueComplete = () => this._queue.complete(task$1); + try { + const { logger } = this._queue.attempt(task$1); + return yield (task.isEmptyTask(task$1) + ? this.attemptEmptyTask(task$1, logger) + : this.attemptRemoteTask(task$1, logger)); + } + catch (e) { + throw this.onFatalException(task$1, e); + } + finally { + onQueueComplete(); + onScheduleComplete(); + } + }); + } + onFatalException(task, e) { + const gitError$1 = (e instanceof gitError.GitError) ? Object.assign(e, { task }) : new gitError.GitError(task, e && String(e)); + this._chain = Promise.resolve(); + this._queue.fatal(gitError$1); + return gitError$1; + } + attemptRemoteTask(task$1, logger) { + return __awaiter(this, void 0, void 0, function* () { + const args = this._plugins.exec('spawn.args', [...task$1.commands], pluginContext(task$1, task$1.commands)); + const raw = yield this.gitResponse(task$1, this.binary, args, this.outputHandler, logger.step('SPAWN')); + const outputStreams = yield this.handleTaskData(task$1, args, raw, logger.step('HANDLE')); + logger(`passing response to task's parser as a %s`, task$1.format); + if (task.isBufferTask(task$1)) { + return utils.callTaskParser(task$1.parser, outputStreams); + } + return utils.callTaskParser(task$1.parser, outputStreams.asStrings()); + }); + } + attemptEmptyTask(task, logger) { + return __awaiter(this, void 0, void 0, function* () { + logger(`empty task bypassing child process to call to task's parser`); + return task.parser(); + }); + } + handleTaskData(task, args, result, logger) { + const { exitCode, rejection, stdOut, stdErr } = result; + return new Promise((done, fail) => { + logger(`Preparing to handle process response exitCode=%d stdOut=`, exitCode); + const { error } = this._plugins.exec('task.error', { error: rejection }, Object.assign(Object.assign({}, pluginContext(task, args)), result)); + if (error && task.onError) { + logger.info(`exitCode=%s handling with custom error handler`); + return task.onError(result, error, (newStdOut) => { + logger.info(`custom error handler treated as success`); + logger(`custom error returned a %s`, utils.objectToString(newStdOut)); + done(new utils.GitOutputStreams(Array.isArray(newStdOut) ? Buffer.concat(newStdOut) : newStdOut, Buffer.concat(stdErr))); + }, fail); + } + if (error) { + logger.info(`handling as error: exitCode=%s stdErr=%s rejection=%o`, exitCode, stdErr.length, rejection); + return fail(error); + } + logger.info(`retrieving task output complete`); + done(new utils.GitOutputStreams(Buffer.concat(stdOut), Buffer.concat(stdErr))); + }); + } + gitResponse(task, command, args, outputHandler, logger) { + return __awaiter(this, void 0, void 0, function* () { + const outputLogger = logger.sibling('output'); + const spawnOptions = { + cwd: this.cwd, + env: this.env, + windowsHide: true, + }; + return new Promise((done) => { + const stdOut = []; + const stdErr = []; + let attempted = false; + let rejection; + function attemptClose(exitCode, event = 'retry') { + // closing when there is content, terminate immediately + if (attempted || stdErr.length || stdOut.length) { + logger.info(`exitCode=%s event=%s rejection=%o`, exitCode, event, rejection); + done({ + stdOut, + stdErr, + exitCode, + rejection, + }); + attempted = true; + } + // first attempt at closing but no content yet, wait briefly for the close/exit that may follow + if (!attempted) { + attempted = true; + setTimeout(() => attemptClose(exitCode, 'deferred'), 50); + logger('received %s event before content on stdOut/stdErr', event); + } + } + logger.info(`%s %o`, command, args); + logger('%O', spawnOptions); + const spawned = child_process_1__default['default'].spawn(command, args, spawnOptions); + spawned.stdout.on('data', onDataReceived(stdOut, 'stdOut', logger, outputLogger.step('stdOut'))); + spawned.stderr.on('data', onDataReceived(stdErr, 'stdErr', logger, outputLogger.step('stdErr'))); + spawned.on('error', onErrorReceived(stdErr, logger)); + spawned.on('close', (code) => attemptClose(code, 'close')); + spawned.on('exit', (code) => attemptClose(code, 'exit')); + if (outputHandler) { + logger(`Passing child process stdOut/stdErr to custom outputHandler`); + outputHandler(command, spawned.stdout, spawned.stderr, [...args]); + } + this._plugins.exec('spawn.after', undefined, Object.assign(Object.assign({}, pluginContext(task, args)), { spawned, kill(reason) { + if (spawned.killed) { + return; + } + rejection = reason; + spawned.kill('SIGINT'); + } })); + }); + }); + } +} +exports.GitExecutorChain = GitExecutorChain; +function pluginContext(task, commands) { + return { + method: utils.first(task.commands) || '', + commands, + }; +} +function onErrorReceived(target, logger) { + return (err) => { + logger(`[ERROR] child process exception %o`, err); + target.push(Buffer.from(String(err.stack), 'ascii')); + }; +} +function onDataReceived(target, name, logger, output) { + return (buffer) => { + logger(`%s received %L bytes`, name, buffer); + output(`%B`, buffer); + target.push(buffer); + }; +} +//# sourceMappingURL=git-executor-chain.js.map +}); + +var gitExecutor = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.GitExecutor = void 0; + +class GitExecutor { + constructor(binary = 'git', cwd, _scheduler, _plugins) { + this.binary = binary; + this.cwd = cwd; + this._scheduler = _scheduler; + this._plugins = _plugins; + this._chain = new gitExecutorChain.GitExecutorChain(this, this._scheduler, this._plugins); + } + chain() { + return new gitExecutorChain.GitExecutorChain(this, this._scheduler, this._plugins); + } + push(task) { + return this._chain.push(task); + } +} +exports.GitExecutor = GitExecutor; +//# sourceMappingURL=git-executor.js.map +}); + +var taskCallback_1 = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.taskCallback = void 0; + + +function taskCallback(task, response, callback = utils.NOOP) { + const onSuccess = (data) => { + callback(null, data); + }; + const onError = (err) => { + if ((err === null || err === void 0 ? void 0 : err.task) === task) { + if (err instanceof gitResponseError.GitResponseError) { + return callback(addDeprecationNoticeToError(err)); + } + callback(err); + } + }; + response.then(onSuccess, onError); +} +exports.taskCallback = taskCallback; +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 = utils.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; + } +} +//# sourceMappingURL=task-callback.js.map +}); + +var parseRemoteObjects = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.remoteMessagesObjectParsers = void 0; + +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: utils.asNumber(count && count[1] || '0'), + delta: utils.asNumber(delta && delta[1] || '0'), + }; +} +exports.remoteMessagesObjectParsers = [ + new utils.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]: utils.asNumber(count) }); + }), + new utils.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]: utils.asNumber(count) }); + }), + new utils.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 = utils.asNumber(packReused); + }), +]; +//# sourceMappingURL=parse-remote-objects.js.map +}); + +var parseRemoteMessages_1 = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.RemoteMessageSummary = exports.parseRemoteMessages = void 0; + + +const parsers = [ + new utils.RemoteLineParser(/^remote:\s*(.+)$/, (result, [text]) => { + result.remoteMessages.all.push(text.trim()); + return false; + }), + ...parseRemoteObjects.remoteMessagesObjectParsers, + new utils.RemoteLineParser([/create a (?:pull|merge) request/i, /\s(https?:\/\/\S+)$/], (result, [pullRequestUrl]) => { + result.remoteMessages.pullRequestUrl = pullRequestUrl; + }), + new utils.RemoteLineParser([/found (\d+) vulnerabilities.+\(([^)]+)\)/i, /\s(https?:\/\/\S+)$/], (result, [count, summary, url]) => { + result.remoteMessages.vulnerabilities = { + count: utils.asNumber(count), + summary, + url, + }; + }), +]; +function parseRemoteMessages(_stdOut, stdErr) { + return utils.parseStringResponse({ remoteMessages: new RemoteMessageSummary() }, parsers, stdErr); +} +exports.parseRemoteMessages = parseRemoteMessages; +class RemoteMessageSummary { + constructor() { + this.all = []; + } +} +exports.RemoteMessageSummary = RemoteMessageSummary; +//# sourceMappingURL=parse-remote-messages.js.map +}); + +var parsePush = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parsePushDetail = exports.parsePushResult = void 0; + + +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, + }; +} +const parsers = [ + new utils.LineParser(/^Pushing to (.+)$/, (result, [repo]) => { + result.repo = repo; + }), + new utils.LineParser(/^updating local tracking ref '(.+)'/, (result, [local]) => { + result.ref = Object.assign(Object.assign({}, (result.ref || {})), { local }); + }), + new utils.LineParser(/^[*-=]\s+([^:]+):(\S+)\s+\[(.+)]$/, (result, [local, remote, type]) => { + result.pushed.push(pushResultPushedItem(local, remote, type)); + }), + new utils.LineParser(/^Branch '([^']+)' set up to track remote branch '([^']+)' from '([^']+)'/, (result, [local, remote, remoteName]) => { + result.branch = Object.assign(Object.assign({}, (result.branch || {})), { local, + remote, + remoteName }); + }), + new utils.LineParser(/^([^:]+):(\S+)\s+([a-z0-9]+)\.\.([a-z0-9]+)$/, (result, [local, remote, from, to]) => { + result.update = { + head: { + local, + remote, + }, + hash: { + from, + to, + }, + }; + }), +]; +const parsePushResult = (stdOut, stdErr) => { + const pushDetail = exports.parsePushDetail(stdOut, stdErr); + const responseDetail = parseRemoteMessages_1.parseRemoteMessages(stdOut, stdErr); + return Object.assign(Object.assign({}, pushDetail), responseDetail); +}; +exports.parsePushResult = parsePushResult; +const parsePushDetail = (stdOut, stdErr) => { + return utils.parseStringResponse({ pushed: [] }, parsers, stdOut, stdErr); +}; +exports.parsePushDetail = parsePushDetail; +//# sourceMappingURL=parse-push.js.map +}); + +var push = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.pushTask = exports.pushTagsTask = void 0; + + +function pushTagsTask(ref = {}, customArgs) { + utils.append(customArgs, '--tags'); + return pushTask(ref, customArgs); +} +exports.pushTagsTask = pushTagsTask; +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); + } + utils.remove(commands, '-v'); + utils.append(commands, '--verbose'); + utils.append(commands, '--porcelain'); + return { + commands, + format: 'utf-8', + parser: parsePush.parsePushResult, + }; +} +exports.pushTask = pushTask; +//# sourceMappingURL=push.js.map +}); + +var simpleGitApi = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SimpleGitApi = void 0; + + + + +class SimpleGitApi { + constructor(_executor) { + this._executor = _executor; + } + _runTask(task, then) { + const chain = this._executor.chain(); + const promise = chain.push(task); + if (then) { + taskCallback_1.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(task.straightThroughStringTask(['add', ...utils.asArray(files)]), utils.trailingFunctionArgument(arguments)); + } + push() { + const task = push.pushTask({ + remote: utils.filterType(arguments[0], utils.filterString), + branch: utils.filterType(arguments[1], utils.filterString), + }, utils.getTrailingOptions(arguments)); + return this._runTask(task, utils.trailingFunctionArgument(arguments)); + } +} +exports.SimpleGitApi = SimpleGitApi; +//# sourceMappingURL=simple-git-api.js.map +}); + +var dist = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createDeferred = exports.deferred = void 0; +/** + * Creates a new `DeferredPromise` + * + * ```typescript + import {deferred} from '@kwsites/promise-deferred`; + ``` + */ +function deferred() { + 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 = deferred; +/** + * Alias of the exported `deferred` function, to help consumers wanting to use `deferred` as the + * local variable name rather than the factory import name, without needing to rename on import. + * + * ```typescript + import {createDeferred} from '@kwsites/promise-deferred`; + ``` + */ +exports.createDeferred = deferred; +/** + * Default export allows use as: + * + * ```typescript + import deferred from '@kwsites/promise-deferred`; + ``` + */ +exports.default = deferred; +//# sourceMappingURL=index.js.map +}); + +var scheduler = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Scheduler = void 0; + + + +const createScheduledTask = (() => { + let id = 0; + return () => { + id++; + const { promise, done } = dist.createDeferred(); + return { + promise, + done, + id, + }; + }; +})(); +class Scheduler { + constructor(concurrency = 2) { + this.concurrency = concurrency; + this.logger = gitLogger.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 = utils.append(this.running, this.pending.shift()); + this.logger(`Attempting id=%s`, task.id); + task.done(() => { + this.logger(`Completing id=`, task.id); + utils.remove(this.running, task); + this.schedule(); + }); + } + next() { + const { promise, id } = utils.append(this.pending, createScheduledTask()); + this.logger(`Scheduling id=%s`, id); + this.schedule(); + return promise; + } +} +exports.Scheduler = Scheduler; +//# sourceMappingURL=scheduler.js.map +}); + +var applyPatch = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.applyPatchTask = void 0; + +function applyPatchTask(patches, customArgs) { + return task.straightThroughStringTask(['apply', ...customArgs, ...patches]); +} +exports.applyPatchTask = applyPatchTask; +//# sourceMappingURL=apply-patch.js.map +}); + +var BranchDeleteSummary = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isSingleBranchDeleteFailure = exports.branchDeletionFailure = exports.branchDeletionSuccess = exports.BranchDeletionBatch = void 0; +class BranchDeletionBatch { + constructor() { + this.all = []; + this.branches = {}; + this.errors = []; + } + get success() { + return !this.errors.length; + } +} +exports.BranchDeletionBatch = BranchDeletionBatch; +function branchDeletionSuccess(branch, hash) { + return { + branch, hash, success: true, + }; +} +exports.branchDeletionSuccess = branchDeletionSuccess; +function branchDeletionFailure(branch) { + return { + branch, hash: null, success: false, + }; +} +exports.branchDeletionFailure = branchDeletionFailure; +function isSingleBranchDeleteFailure(test) { + return test.success; +} +exports.isSingleBranchDeleteFailure = isSingleBranchDeleteFailure; +//# sourceMappingURL=BranchDeleteSummary.js.map +}); + +var parseBranchDelete = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.hasBranchDeletionError = exports.parseBranchDeletions = void 0; + + +const deleteSuccessRegex = /(\S+)\s+\(\S+\s([^)]+)\)/; +const deleteErrorRegex = /^error[^']+'([^']+)'/m; +const parsers = [ + new utils.LineParser(deleteSuccessRegex, (result, [branch, hash]) => { + const deletion = BranchDeleteSummary.branchDeletionSuccess(branch, hash); + result.all.push(deletion); + result.branches[branch] = deletion; + }), + new utils.LineParser(deleteErrorRegex, (result, [branch]) => { + const deletion = BranchDeleteSummary.branchDeletionFailure(branch); + result.errors.push(deletion); + result.all.push(deletion); + result.branches[branch] = deletion; + }), +]; +const parseBranchDeletions = (stdOut, stdErr) => { + return utils.parseStringResponse(new BranchDeleteSummary.BranchDeletionBatch(), parsers, stdOut, stdErr); +}; +exports.parseBranchDeletions = parseBranchDeletions; +function hasBranchDeletionError(data, processExitCode) { + return processExitCode === utils.ExitCodes.ERROR && deleteErrorRegex.test(data); +} +exports.hasBranchDeletionError = hasBranchDeletionError; +//# sourceMappingURL=parse-branch-delete.js.map +}); + +var BranchSummary = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.BranchSummaryResult = void 0; +class BranchSummaryResult { + constructor() { + this.all = []; + this.branches = {}; + this.current = ''; + this.detached = false; + } + push(current, detached, name, commit, label) { + if (current) { + this.detached = detached; + this.current = name; + } + this.all.push(name); + this.branches[name] = { + current: current, + name: name, + commit: commit, + label: label + }; + } +} +exports.BranchSummaryResult = BranchSummaryResult; +//# sourceMappingURL=BranchSummary.js.map +}); + +var parseBranch = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseBranchSummary = void 0; + + +const parsers = [ + new utils.LineParser(/^(\*\s)?\((?:HEAD )?detached (?:from|at) (\S+)\)\s+([a-z0-9]+)\s(.*)$/, (result, [current, name, commit, label]) => { + result.push(!!current, true, name, commit, label); + }), + new utils.LineParser(/^(\*\s)?(\S+)\s+([a-z0-9]+)\s(.*)$/s, (result, [current, name, commit, label]) => { + result.push(!!current, false, name, commit, label); + }) +]; +function parseBranchSummary(stdOut) { + return utils.parseStringResponse(new BranchSummary.BranchSummaryResult(), parsers, stdOut); +} +exports.parseBranchSummary = parseBranchSummary; +//# sourceMappingURL=parse-branch.js.map +}); + +var branch = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.deleteBranchTask = exports.deleteBranchesTask = exports.branchLocalTask = exports.branchTask = exports.containsDeleteBranchCommand = void 0; + + + + +function containsDeleteBranchCommand(commands) { + const deleteCommands = ['-d', '-D', '--delete']; + return commands.some(command => deleteCommands.includes(command)); +} +exports.containsDeleteBranchCommand = containsDeleteBranchCommand; +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 parseBranchDelete.parseBranchDeletions(stdOut, stdErr).all[0]; + } + return parseBranch.parseBranchSummary(stdOut); + }, + }; +} +exports.branchTask = branchTask; +function branchLocalTask() { + const parser = parseBranch.parseBranchSummary; + return { + format: 'utf-8', + commands: ['branch', '-v'], + parser, + }; +} +exports.branchLocalTask = branchLocalTask; +function deleteBranchesTask(branches, forceDelete = false) { + return { + format: 'utf-8', + commands: ['branch', '-v', forceDelete ? '-D' : '-d', ...branches], + parser(stdOut, stdErr) { + return parseBranchDelete.parseBranchDeletions(stdOut, stdErr); + }, + onError({ exitCode, stdOut }, error, done, fail) { + if (!parseBranchDelete.hasBranchDeletionError(String(error), exitCode)) { + return fail(error); + } + done(stdOut); + }, + }; +} +exports.deleteBranchesTask = deleteBranchesTask; +function deleteBranchTask(branch, forceDelete = false) { + const task = { + format: 'utf-8', + commands: ['branch', '-v', forceDelete ? '-D' : '-d', branch], + parser(stdOut, stdErr) { + return parseBranchDelete.parseBranchDeletions(stdOut, stdErr).branches[branch]; + }, + onError({ exitCode, stdErr, stdOut }, error, _, fail) { + if (!parseBranchDelete.hasBranchDeletionError(String(error), exitCode)) { + return fail(error); + } + throw new gitResponseError.GitResponseError(task.parser(utils.bufferToString(stdOut), utils.bufferToString(stdErr)), String(error)); + }, + }; + return task; +} +exports.deleteBranchTask = deleteBranchTask; +//# sourceMappingURL=branch.js.map +}); + +var CheckIgnore = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseCheckIgnore = void 0; +/** + * Parser for the `check-ignore` command - returns each file as a string array + */ +const parseCheckIgnore = (text) => { + return text.split(/\n/g) + .map(line => line.trim()) + .filter(file => !!file); +}; +exports.parseCheckIgnore = parseCheckIgnore; +//# sourceMappingURL=CheckIgnore.js.map +}); + +var checkIgnore = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.checkIgnoreTask = void 0; + +function checkIgnoreTask(paths) { + return { + commands: ['check-ignore', ...paths], + format: 'utf-8', + parser: CheckIgnore.parseCheckIgnore, + }; +} +exports.checkIgnoreTask = checkIgnoreTask; +//# sourceMappingURL=check-ignore.js.map +}); + +var clone = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.cloneMirrorTask = exports.cloneTask = void 0; + + +function cloneTask(repo, directory, customArgs) { + const commands = ['clone', ...customArgs]; + if (typeof repo === 'string') { + commands.push(repo); + } + if (typeof directory === 'string') { + commands.push(directory); + } + return task.straightThroughStringTask(commands); +} +exports.cloneTask = cloneTask; +function cloneMirrorTask(repo, directory, customArgs) { + utils.append(customArgs, '--mirror'); + return cloneTask(repo, directory, customArgs); +} +exports.cloneMirrorTask = cloneMirrorTask; +//# sourceMappingURL=clone.js.map +}); + +var ConfigList_1 = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.configListParser = exports.ConfigList = void 0; + +class ConfigList { + constructor() { + this.files = []; + this.values = 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 = utils.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 = undefined; + } +} +exports.ConfigList = ConfigList; +function configListParser(text) { + const config = new ConfigList(); + const lines = text.split('\0'); + for (let i = 0, max = lines.length - 1; i < max;) { + const file = configFilePath(lines[i++]); + const [key, value] = utils.splitOn(lines[i++], '\n'); + config.addValue(file, key, value); + } + return config; +} +exports.configListParser = configListParser; +function configFilePath(filePath) { + return filePath.replace(/^(file):/, ''); +} +//# sourceMappingURL=ConfigList.js.map +}); + +var config = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.listConfigTask = exports.addConfigTask = void 0; + +function addConfigTask(key, value, append = false) { + const commands = ['config', '--local']; + if (append) { + commands.push('--add'); + } + commands.push(key, value); + return { + commands, + format: 'utf-8', + parser(text) { + return text; + } + }; +} +exports.addConfigTask = addConfigTask; +function listConfigTask() { + return { + commands: ['config', '--list', '--show-origin', '--null'], + format: 'utf-8', + parser(text) { + return ConfigList_1.configListParser(text); + }, + }; +} +exports.listConfigTask = listConfigTask; +//# sourceMappingURL=config.js.map +}); + +var parseCommit = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseCommitResult = void 0; + +const parsers = [ + new utils.LineParser(/\[([^\s]+)( \([^)]+\))? ([^\]]+)/, (result, [branch, root, commit]) => { + result.branch = branch; + result.commit = commit; + result.root = !!root; + }), + new utils.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 utils.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 utils.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 parseCommitResult(stdOut) { + const result = { + author: null, + branch: '', + commit: '', + root: false, + summary: { + changes: 0, + insertions: 0, + deletions: 0, + }, + }; + return utils.parseStringResponse(result, parsers, stdOut); +} +exports.parseCommitResult = parseCommitResult; +//# sourceMappingURL=parse-commit.js.map +}); + +var commit = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.commitTask = void 0; + +function commitTask(message, files, customArgs) { + const commands = ['commit']; + message.forEach((m) => commands.push('-m', m)); + commands.push(...files, ...customArgs); + return { + commands, + format: 'utf-8', + parser: parseCommit.parseCommitResult, + }; +} +exports.commitTask = commitTask; +//# sourceMappingURL=commit.js.map +}); + +var DiffSummary_1 = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DiffSummary = void 0; +/*** + * The DiffSummary is returned as a response to getting `git().status()` + */ +class DiffSummary { + constructor() { + this.changed = 0; + this.deletions = 0; + this.insertions = 0; + this.files = []; + } +} +exports.DiffSummary = DiffSummary; +//# sourceMappingURL=DiffSummary.js.map +}); + +var parseDiffSummary = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseDiffResult = void 0; + +function parseDiffResult(stdOut) { + const lines = stdOut.trim().split('\n'); + const status = new DiffSummary_1.DiffSummary(); + readSummaryLine(status, lines.pop()); + for (let i = 0, max = lines.length; i < max; i++) { + const line = lines[i]; + textFileChange(line, status) || binaryFileChange(line, status); + } + return status; +} +exports.parseDiffResult = parseDiffResult; +function readSummaryLine(status, summary) { + (summary || '') + .trim() + .split(', ') + .forEach(function (text) { + const summary = /(\d+)\s([a-z]+)/.exec(text); + if (!summary) { + return; + } + summaryType(status, summary[2], parseInt(summary[1], 10)); + }); +} +function summaryType(status, key, value) { + const match = (/([a-z]+?)s?\b/.exec(key)); + if (!match || !statusUpdate[match[1]]) { + return; + } + statusUpdate[match[1]](status, value); +} +const statusUpdate = { + file(status, value) { + status.changed = value; + }, + deletion(status, value) { + status.deletions = value; + }, + insertion(status, value) { + status.insertions = value; + } +}; +function textFileChange(input, { files }) { + const line = input.trim().match(/^(.+)\s+\|\s+(\d+)(\s+[+\-]+)?$/); + if (line) { + var alterations = (line[3] || '').trim(); + files.push({ + file: line[1].trim(), + changes: parseInt(line[2], 10), + insertions: alterations.replace(/-/g, '').length, + deletions: alterations.replace(/\+/g, '').length, + binary: false + }); + return true; + } + return false; +} +function binaryFileChange(input, { files }) { + const line = input.match(/^(.+) \|\s+Bin ([0-9.]+) -> ([0-9.]+) ([a-z]+)$/); + if (line) { + files.push({ + file: line[1].trim(), + before: +line[2], + after: +line[3], + binary: true + }); + return true; + } + return false; +} +//# sourceMappingURL=parse-diff-summary.js.map +}); + +var diff = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.diffSummaryTask = void 0; + +function diffSummaryTask(customArgs) { + return { + commands: ['diff', '--stat=4096', ...customArgs], + format: 'utf-8', + parser(stdOut) { + return parseDiffSummary.parseDiffResult(stdOut); + } + }; +} +exports.diffSummaryTask = diffSummaryTask; +//# sourceMappingURL=diff.js.map +}); + +var parseFetch = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseFetchResult = void 0; + +const parsers = [ + new utils.LineParser(/From (.+)$/, (result, [remote]) => { + result.remote = remote; + }), + new utils.LineParser(/\* \[new branch]\s+(\S+)\s*-> (.+)$/, (result, [name, tracking]) => { + result.branches.push({ + name, + tracking, + }); + }), + new utils.LineParser(/\* \[new tag]\s+(\S+)\s*-> (.+)$/, (result, [name, tracking]) => { + result.tags.push({ + name, + tracking, + }); + }) +]; +function parseFetchResult(stdOut, stdErr) { + const result = { + raw: stdOut, + remote: null, + branches: [], + tags: [], + }; + return utils.parseStringResponse(result, parsers, stdOut, stdErr); +} +exports.parseFetchResult = parseFetchResult; +//# sourceMappingURL=parse-fetch.js.map +}); + +var fetch = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.fetchTask = void 0; + +function fetchTask(remote, branch, customArgs) { + const commands = ['fetch', ...customArgs]; + if (remote && branch) { + commands.push(remote, branch); + } + return { + commands, + format: 'utf-8', + parser: parseFetch.parseFetchResult, + }; +} +exports.fetchTask = fetchTask; +//# sourceMappingURL=fetch.js.map +}); + +var hashObject = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.hashObjectTask = void 0; + +/** + * Task used by `git.hashObject` + */ +function hashObjectTask(filePath, write) { + const commands = ['hash-object', filePath]; + if (write) { + commands.push('-w'); + } + return task.straightThroughStringTask(commands, true); +} +exports.hashObjectTask = hashObjectTask; +//# sourceMappingURL=hash-object.js.map +}); + +var InitSummary_1 = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseInit = exports.InitSummary = void 0; +class InitSummary { + constructor(bare, path, existing, gitDir) { + this.bare = bare; + this.path = path; + this.existing = existing; + this.gitDir = gitDir; + } +} +exports.InitSummary = InitSummary; +const initResponseRegex = /^Init.+ repository in (.+)$/; +const reInitResponseRegex = /^Rein.+ in (.+)$/; +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); +} +exports.parseInit = parseInit; +//# sourceMappingURL=InitSummary.js.map +}); + +var init = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.initTask = void 0; + +const bareCommand = '--bare'; +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 InitSummary_1.parseInit(commands.includes('--bare'), path, text); + } + }; +} +exports.initTask = initTask; +//# sourceMappingURL=init.js.map +}); + +var parseListLogSummary = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createListLogSummaryParser = exports.SPLITTER = exports.COMMIT_BOUNDARY = exports.START_BOUNDARY = void 0; + + +exports.START_BOUNDARY = 'òòòòòò '; +exports.COMMIT_BOUNDARY = ' òò'; +exports.SPLITTER = ' ò '; +const defaultFieldNames = ['hash', 'date', 'message', 'refs', 'author_name', 'author_email']; +function lineBuilder(tokens, fields) { + return fields.reduce((line, field, index) => { + line[field] = tokens[index] || ''; + return line; + }, Object.create({ diff: null })); +} +function createListLogSummaryParser(splitter = exports.SPLITTER, fields = defaultFieldNames) { + return function (stdOut) { + const all = utils.toLinesWithContent(stdOut, true, exports.START_BOUNDARY) + .map(function (item) { + const lineDetail = item.trim().split(exports.COMMIT_BOUNDARY); + const listLogLine = lineBuilder(lineDetail[0].trim().split(splitter), fields); + if (lineDetail.length > 1 && !!lineDetail[1].trim()) { + listLogLine.diff = parseDiffSummary.parseDiffResult(lineDetail[1]); + } + return listLogLine; + }); + return { + all, + latest: all.length && all[0] || null, + total: all.length, + }; + }; +} +exports.createListLogSummaryParser = createListLogSummaryParser; +//# sourceMappingURL=parse-list-log-summary.js.map +}); + +var log = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.logTask = exports.parseLogOptions = void 0; + + +var excludeOptions; +(function (excludeOptions) { + excludeOptions[excludeOptions["--pretty"] = 0] = "--pretty"; + excludeOptions[excludeOptions["max-count"] = 1] = "max-count"; + excludeOptions[excludeOptions["maxCount"] = 2] = "maxCount"; + excludeOptions[excludeOptions["n"] = 3] = "n"; + excludeOptions[excludeOptions["file"] = 4] = "file"; + excludeOptions[excludeOptions["format"] = 5] = "format"; + excludeOptions[excludeOptions["from"] = 6] = "from"; + excludeOptions[excludeOptions["to"] = 7] = "to"; + excludeOptions[excludeOptions["splitter"] = 8] = "splitter"; + excludeOptions[excludeOptions["symmetric"] = 9] = "symmetric"; + excludeOptions[excludeOptions["multiLine"] = 10] = "multiLine"; + excludeOptions[excludeOptions["strictDate"] = 11] = "strictDate"; +})(excludeOptions || (excludeOptions = {})); +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) { + const output = Object.assign({}, input); + Object.keys(input).forEach(key => { + if (key in excludeOptions) { + delete output[key]; + } + }); + return output; +} +function parseLogOptions(opt = {}, customArgs = []) { + const splitter = opt.splitter || parseListLogSummary.SPLITTER; + const format = opt.format || { + hash: '%H', + date: opt.strictDate === false ? '%ai' : '%aI', + message: '%s', + refs: '%D', + body: opt.multiLine ? '%B' : '%b', + author_name: '%aN', + author_email: '%ae' + }; + const [fields, formatStr] = prettyFormat(format, splitter); + const suffix = []; + const command = [ + `--pretty=format:${parseListLogSummary.START_BOUNDARY}${formatStr}${parseListLogSummary.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 (opt.file) { + suffix.push('--follow', opt.file); + } + utils.appendTaskOptions(userOptions(opt), command); + return { + fields, + splitter, + commands: [ + ...command, + ...suffix, + ], + }; +} +exports.parseLogOptions = parseLogOptions; +function logTask(splitter, fields, customArgs) { + return { + commands: ['log', ...customArgs], + format: 'utf-8', + parser: parseListLogSummary.createListLogSummaryParser(splitter, fields), + }; +} +exports.logTask = logTask; +//# sourceMappingURL=log.js.map +}); + +var MergeSummary = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.MergeSummaryDetail = exports.MergeSummaryConflict = void 0; +class MergeSummaryConflict { + constructor(reason, file = null, meta) { + this.reason = reason; + this.file = file; + this.meta = meta; + } + toString() { + return `${this.file}:${this.reason}`; + } +} +exports.MergeSummaryConflict = MergeSummaryConflict; +class MergeSummaryDetail { + 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'; + } +} +exports.MergeSummaryDetail = MergeSummaryDetail; +//# sourceMappingURL=MergeSummary.js.map +}); + +var PullSummary_1 = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PullSummary = void 0; +class PullSummary { + constructor() { + this.remoteMessages = { + all: [], + }; + this.created = []; + this.deleted = []; + this.files = []; + this.deletions = {}; + this.insertions = {}; + this.summary = { + changes: 0, + deletions: 0, + insertions: 0, + }; + } +} +exports.PullSummary = PullSummary; +//# sourceMappingURL=PullSummary.js.map +}); + +var parsePull = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parsePullResult = exports.parsePullDetail = void 0; + + + +const FILE_UPDATE_REGEX = /^\s*(.+?)\s+\|\s+\d+\s*(\+*)(-*)/; +const SUMMARY_REGEX = /(\d+)\D+((\d+)\D+\(\+\))?(\D+(\d+)\D+\(-\))?/; +const ACTION_REGEX = /^(create|delete) mode \d+ (.+)/; +const parsers = [ + new utils.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 utils.LineParser(SUMMARY_REGEX, (result, [changes, , insertions, , deletions]) => { + if (insertions !== undefined || deletions !== undefined) { + result.summary.changes = +changes || 0; + result.summary.insertions = +insertions || 0; + result.summary.deletions = +deletions || 0; + return true; + } + return false; + }), + new utils.LineParser(ACTION_REGEX, (result, [action, file]) => { + utils.append(result.files, file); + utils.append((action === 'create') ? result.created : result.deleted, file); + }), +]; +const parsePullDetail = (stdOut, stdErr) => { + return utils.parseStringResponse(new PullSummary_1.PullSummary(), parsers, stdOut, stdErr); +}; +exports.parsePullDetail = parsePullDetail; +const parsePullResult = (stdOut, stdErr) => { + return Object.assign(new PullSummary_1.PullSummary(), exports.parsePullDetail(stdOut, stdErr), parseRemoteMessages_1.parseRemoteMessages(stdOut, stdErr)); +}; +exports.parsePullResult = parsePullResult; +//# sourceMappingURL=parse-pull.js.map +}); + +var parseMerge = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseMergeDetail = exports.parseMergeResult = void 0; + + + +const parsers = [ + new utils.LineParser(/^Auto-merging\s+(.+)$/, (summary, [autoMerge]) => { + summary.merges.push(autoMerge); + }), + new utils.LineParser(/^CONFLICT\s+\((.+)\): Merge conflict in (.+)$/, (summary, [reason, file]) => { + summary.conflicts.push(new MergeSummary.MergeSummaryConflict(reason, file)); + }), + new utils.LineParser(/^CONFLICT\s+\((.+\/delete)\): (.+) deleted in (.+) and/, (summary, [reason, file, deleteRef]) => { + summary.conflicts.push(new MergeSummary.MergeSummaryConflict(reason, file, { deleteRef })); + }), + new utils.LineParser(/^CONFLICT\s+\((.+)\):/, (summary, [reason]) => { + summary.conflicts.push(new MergeSummary.MergeSummaryConflict(reason, null)); + }), + new utils.LineParser(/^Automatic merge failed;\s+(.+)$/, (summary, [result]) => { + summary.result = result; + }), +]; +/** + * Parse the complete response from `git.merge` + */ +const parseMergeResult = (stdOut, stdErr) => { + return Object.assign(exports.parseMergeDetail(stdOut, stdErr), parsePull.parsePullResult(stdOut, stdErr)); +}; +exports.parseMergeResult = parseMergeResult; +/** + * Parse the merge specific detail (ie: not the content also available in the pull detail) from `git.mnerge` + * @param stdOut + */ +const parseMergeDetail = (stdOut) => { + return utils.parseStringResponse(new MergeSummary.MergeSummaryDetail(), parsers, stdOut); +}; +exports.parseMergeDetail = parseMergeDetail; +//# sourceMappingURL=parse-merge.js.map +}); + +var merge = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.mergeTask = void 0; + + + +function mergeTask(customArgs) { + if (!customArgs.length) { + return task.configurationErrorTask('Git.merge requires at least one option'); + } + return { + commands: ['merge', ...customArgs], + format: 'utf-8', + parser(stdOut, stdErr) { + const merge = parseMerge.parseMergeResult(stdOut, stdErr); + if (merge.failed) { + throw new gitResponseError.GitResponseError(merge); + } + return merge; + } + }; +} +exports.mergeTask = mergeTask; +//# sourceMappingURL=merge.js.map +}); + +var parseMove = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseMoveResult = void 0; + +const parsers = [ + new utils.LineParser(/^Renaming (.+) to (.+)$/, (result, [from, to]) => { + result.moves.push({ from, to }); + }), +]; +function parseMoveResult(stdOut) { + return utils.parseStringResponse({ moves: [] }, parsers, stdOut); +} +exports.parseMoveResult = parseMoveResult; +//# sourceMappingURL=parse-move.js.map +}); + +var move = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.moveTask = void 0; + + +function moveTask(from, to) { + return { + commands: ['mv', '-v', ...utils.asArray(from), to], + format: 'utf-8', + parser: parseMove.parseMoveResult, + }; +} +exports.moveTask = moveTask; +//# sourceMappingURL=move.js.map +}); + +var pull = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.pullTask = void 0; + +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 parsePull.parsePullResult(stdOut, stdErr); + } + }; +} +exports.pullTask = pullTask; +//# sourceMappingURL=pull.js.map +}); + +var GetRemoteSummary = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseGetRemotesVerbose = exports.parseGetRemotes = void 0; + +function parseGetRemotes(text) { + const remotes = {}; + forEach(text, ([name]) => remotes[name] = { name }); + return Object.values(remotes); +} +exports.parseGetRemotes = parseGetRemotes; +function parseGetRemotesVerbose(text) { + const remotes = {}; + forEach(text, ([name, url, purpose]) => { + if (!remotes.hasOwnProperty(name)) { + remotes[name] = { + name: name, + refs: { fetch: '', push: '' }, + }; + } + if (purpose && url) { + remotes[name].refs[purpose.replace(/[^a-z]/g, '')] = url; + } + }); + return Object.values(remotes); +} +exports.parseGetRemotesVerbose = parseGetRemotesVerbose; +function forEach(text, handler) { + utils.forEachLineWithContent(text, (line) => handler(line.split(/\s+/))); +} +//# sourceMappingURL=GetRemoteSummary.js.map +}); + +var remote = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.removeRemoteTask = exports.remoteTask = exports.listRemotesTask = exports.getRemotesTask = exports.addRemoteTask = void 0; + + +function addRemoteTask(remoteName, remoteRepo, customArgs = []) { + return task.straightThroughStringTask(['remote', 'add', ...customArgs, remoteName, remoteRepo]); +} +exports.addRemoteTask = addRemoteTask; +function getRemotesTask(verbose) { + const commands = ['remote']; + if (verbose) { + commands.push('-v'); + } + return { + commands, + format: 'utf-8', + parser: verbose ? GetRemoteSummary.parseGetRemotesVerbose : GetRemoteSummary.parseGetRemotes, + }; +} +exports.getRemotesTask = getRemotesTask; +function listRemotesTask(customArgs = []) { + const commands = [...customArgs]; + if (commands[0] !== 'ls-remote') { + commands.unshift('ls-remote'); + } + return task.straightThroughStringTask(commands); +} +exports.listRemotesTask = listRemotesTask; +function remoteTask(customArgs = []) { + const commands = [...customArgs]; + if (commands[0] !== 'remote') { + commands.unshift('remote'); + } + return task.straightThroughStringTask(commands); +} +exports.remoteTask = remoteTask; +function removeRemoteTask(remoteName) { + return task.straightThroughStringTask(['remote', 'remove', remoteName]); +} +exports.removeRemoteTask = removeRemoteTask; +//# sourceMappingURL=remote.js.map +}); + +var stashList = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.stashListTask = void 0; + + +function stashListTask(opt = {}, customArgs) { + const options = log.parseLogOptions(opt); + const parser = parseListLogSummary.createListLogSummaryParser(options.splitter, options.fields); + return { + commands: ['stash', 'list', ...options.commands, ...customArgs], + format: 'utf-8', + parser, + }; +} +exports.stashListTask = stashListTask; +//# sourceMappingURL=stash-list.js.map +}); + +var FileStatusSummary_1 = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.FileStatusSummary = exports.fromPathRegex = void 0; +exports.fromPathRegex = /^(.+) -> (.+)$/; +class FileStatusSummary { + constructor(path, index, working_dir) { + this.path = path; + this.index = index; + this.working_dir = working_dir; + if ('R' === (index + working_dir)) { + const detail = exports.fromPathRegex.exec(path) || [null, path, path]; + this.from = detail[1] || ''; + this.path = detail[2] || ''; + } + } +} +exports.FileStatusSummary = FileStatusSummary; +//# sourceMappingURL=FileStatusSummary.js.map +}); + +var StatusSummary_1 = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseStatusSummary = exports.StatusSummary = void 0; + + +/** + * The StatusSummary is returned as a response to getting `git().status()` + */ +class StatusSummary { + constructor() { + this.not_added = []; + this.conflicted = []; + this.created = []; + this.deleted = []; + this.modified = []; + this.renamed = []; + /** + * All files represented as an array of objects containing the `path` and status in `index` and + * in the `working_dir`. + */ + this.files = []; + this.staged = []; + /** + * Number of commits ahead of the tracked branch + */ + this.ahead = 0; + /** + *Number of commits behind the tracked branch + */ + this.behind = 0; + /** + * Name of the current branch + */ + this.current = null; + /** + * Name of the branch being tracked + */ + this.tracking = null; + } + /** + * Gets whether this StatusSummary represents a clean working branch. + */ + isClean() { + return !this.files.length; + } +} +exports.StatusSummary = StatusSummary; +var PorcelainFileStatus; +(function (PorcelainFileStatus) { + PorcelainFileStatus["ADDED"] = "A"; + PorcelainFileStatus["DELETED"] = "D"; + PorcelainFileStatus["MODIFIED"] = "M"; + PorcelainFileStatus["RENAMED"] = "R"; + PorcelainFileStatus["COPIED"] = "C"; + PorcelainFileStatus["UNMERGED"] = "U"; + PorcelainFileStatus["UNTRACKED"] = "?"; + PorcelainFileStatus["IGNORED"] = "!"; + PorcelainFileStatus["NONE"] = " "; +})(PorcelainFileStatus || (PorcelainFileStatus = {})); +function renamedFile(line) { + const detail = /^(.+) -> (.+)$/.exec(line); + if (!detail) { + return { + from: line, to: line + }; + } + return { + from: String(detail[1]), + to: String(detail[2]), + }; +} +function parser(indexX, indexY, handler) { + return [`${indexX}${indexY}`, handler]; +} +function conflicts(indexX, ...indexY) { + return indexY.map(y => parser(indexX, y, (result, file) => utils.append(result.conflicted, file))); +} +const parsers = new Map([ + parser(PorcelainFileStatus.NONE, PorcelainFileStatus.ADDED, (result, file) => utils.append(result.created, file)), + parser(PorcelainFileStatus.NONE, PorcelainFileStatus.DELETED, (result, file) => utils.append(result.deleted, file)), + parser(PorcelainFileStatus.NONE, PorcelainFileStatus.MODIFIED, (result, file) => utils.append(result.modified, file)), + parser(PorcelainFileStatus.ADDED, PorcelainFileStatus.NONE, (result, file) => utils.append(result.created, file) && utils.append(result.staged, file)), + parser(PorcelainFileStatus.ADDED, PorcelainFileStatus.MODIFIED, (result, file) => utils.append(result.created, file) && utils.append(result.staged, file) && utils.append(result.modified, file)), + parser(PorcelainFileStatus.DELETED, PorcelainFileStatus.NONE, (result, file) => utils.append(result.deleted, file) && utils.append(result.staged, file)), + parser(PorcelainFileStatus.MODIFIED, PorcelainFileStatus.NONE, (result, file) => utils.append(result.modified, file) && utils.append(result.staged, file)), + parser(PorcelainFileStatus.MODIFIED, PorcelainFileStatus.MODIFIED, (result, file) => utils.append(result.modified, file) && utils.append(result.staged, file)), + parser(PorcelainFileStatus.RENAMED, PorcelainFileStatus.NONE, (result, file) => { + utils.append(result.renamed, renamedFile(file)); + }), + parser(PorcelainFileStatus.RENAMED, PorcelainFileStatus.MODIFIED, (result, file) => { + const renamed = renamedFile(file); + utils.append(result.renamed, renamed); + utils.append(result.modified, renamed.to); + }), + parser(PorcelainFileStatus.UNTRACKED, PorcelainFileStatus.UNTRACKED, (result, file) => utils.append(result.not_added, file)), + ...conflicts(PorcelainFileStatus.ADDED, PorcelainFileStatus.ADDED, PorcelainFileStatus.UNMERGED), + ...conflicts(PorcelainFileStatus.DELETED, PorcelainFileStatus.DELETED, PorcelainFileStatus.UNMERGED), + ...conflicts(PorcelainFileStatus.UNMERGED, PorcelainFileStatus.ADDED, PorcelainFileStatus.DELETED, PorcelainFileStatus.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; + }] +]); +const parseStatusSummary = function (text) { + const lines = text.trim().split('\n'); + const status = new StatusSummary(); + for (let i = 0, l = lines.length; i < l; i++) { + splitLine(status, lines[i]); + } + return status; +}; +exports.parseStatusSummary = parseStatusSummary; +function splitLine(result, lineStr) { + const trimmed = lineStr.trim(); + switch (' ') { + case trimmed.charAt(2): + return data(trimmed.charAt(0), trimmed.charAt(1), trimmed.substr(3)); + case trimmed.charAt(1): + return data(PorcelainFileStatus.NONE, trimmed.charAt(0), trimmed.substr(2)); + default: + return; + } + function data(index, workingDir, path) { + const raw = `${index}${workingDir}`; + const handler = parsers.get(raw); + if (handler) { + handler(result, path); + } + if (raw !== '##') { + result.files.push(new FileStatusSummary_1.FileStatusSummary(path, index, workingDir)); + } + } +} +//# sourceMappingURL=StatusSummary.js.map +}); + +var status = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.statusTask = void 0; + +function statusTask(customArgs) { + return { + format: 'utf-8', + commands: ['status', '--porcelain', '-b', '-u', ...customArgs], + parser(text) { + return StatusSummary_1.parseStatusSummary(text); + } + }; +} +exports.statusTask = statusTask; +//# sourceMappingURL=status.js.map +}); + +var subModule = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.updateSubModuleTask = exports.subModuleTask = exports.initSubModuleTask = exports.addSubModuleTask = void 0; + +function addSubModuleTask(repo, path) { + return subModuleTask(['add', repo, path]); +} +exports.addSubModuleTask = addSubModuleTask; +function initSubModuleTask(customArgs) { + return subModuleTask(['init', ...customArgs]); +} +exports.initSubModuleTask = initSubModuleTask; +function subModuleTask(customArgs) { + const commands = [...customArgs]; + if (commands[0] !== 'submodule') { + commands.unshift('submodule'); + } + return task.straightThroughStringTask(commands); +} +exports.subModuleTask = subModuleTask; +function updateSubModuleTask(customArgs) { + return subModuleTask(['update', ...customArgs]); +} +exports.updateSubModuleTask = updateSubModuleTask; +//# sourceMappingURL=sub-module.js.map +}); + +var TagList_1 = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseTagList = exports.TagList = void 0; +class TagList { + constructor(all, latest) { + this.all = all; + this.latest = latest; + } +} +exports.TagList = TagList; +const 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); +}; +exports.parseTagList = parseTagList; +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; +} +//# sourceMappingURL=TagList.js.map +}); + +var tag = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.addAnnotatedTagTask = exports.addTagTask = exports.tagListTask = void 0; + +/** + * Task used by `git.tags` + */ +function tagListTask(customArgs = []) { + const hasCustomSort = customArgs.some((option) => /^--sort=/.test(option)); + return { + format: 'utf-8', + commands: ['tag', '-l', ...customArgs], + parser(text) { + return TagList_1.parseTagList(text, hasCustomSort); + }, + }; +} +exports.tagListTask = tagListTask; +/** + * Task used by `git.addTag` + */ +function addTagTask(name) { + return { + format: 'utf-8', + commands: ['tag', name], + parser() { + return { name }; + } + }; +} +exports.addTagTask = addTagTask; +/** + * Task used by `git.addTag` + */ +function addAnnotatedTagTask(name, tagMessage) { + return { + format: 'utf-8', + commands: ['tag', '-a', '-m', tagMessage, name], + parser() { + return { name }; + } + }; +} +exports.addAnnotatedTagTask = addAnnotatedTagTask; +//# sourceMappingURL=tag.js.map +}); + +const {GitExecutor} = gitExecutor; +const {SimpleGitApi} = simpleGitApi; + +const {Scheduler} = scheduler; +const {GitLogger} = gitLogger; +const {adhocExecTask, configurationErrorTask} = task; +const { + NOOP, + asArray, + filterArray, + filterPrimitives, + filterString, + filterStringOrStringArray, + filterType, + folderExists, + getTrailingOptions, + trailingFunctionArgument, + trailingOptionsArgument +} = utils; +const {applyPatchTask} = applyPatch; +const {branchTask, branchLocalTask, deleteBranchesTask, deleteBranchTask} = branch; +const {checkIgnoreTask} = checkIgnore; +const {checkIsRepoTask} = checkIsRepo; +const {cloneTask, cloneMirrorTask} = clone; +const {addConfigTask, listConfigTask} = config; +const {cleanWithOptionsTask, isCleanOptionsArray} = clean; +const {commitTask} = commit; +const {diffSummaryTask} = diff; +const {fetchTask} = fetch; +const {hashObjectTask} = hashObject; +const {initTask} = init; +const {logTask, parseLogOptions} = log; +const {mergeTask} = merge; +const {moveTask} = move; +const {pullTask} = pull; +const {pushTagsTask} = push; +const {addRemoteTask, getRemotesTask, listRemotesTask, remoteTask, removeRemoteTask} = remote; +const {getResetMode, resetTask} = reset; +const {stashListTask} = stashList; +const {statusTask} = status; +const {addSubModuleTask, initSubModuleTask, subModuleTask, updateSubModuleTask} = subModule; +const {addAnnotatedTagTask, addTagTask, tagListTask} = tag; +const {straightThroughBufferTask, straightThroughStringTask} = task; + +function Git (options, plugins) { + this._executor = new GitExecutor( + options.binary, options.baseDir, + new Scheduler(options.maxConcurrentProcesses), plugins, + ); + this._logger = new GitLogger(); +} + +(Git.prototype = Object.create(SimpleGitApi.prototype)).constructor = Git; + +/** + * Logging utility for printing out info or error messages to the user + * @type {GitLogger} + * @private + */ +Git.prototype._logger = null; + +/** + * Sets the path to a custom git binary, should either be `git` when there is an installation of git available on + * the system path, or a fully qualified path to the executable. + * + * @param {string} command + * @returns {Git} + */ +Git.prototype.customBinary = function (command) { + this._executor.binary = command; + return this; +}; + +/** + * Sets an environment variable for the spawned child process, either supply both a name and value as strings or + * a single object to entirely replace the current environment variables. + * + * @param {string|Object} name + * @param {string} [value] + * @returns {Git} + */ +Git.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; +}; + +/** + * Sets the working directory of the subsequent commands. + */ +Git.prototype.cwd = function (workingDirectory) { + const task = (typeof workingDirectory !== 'string') + ? configurationErrorTask('Git.cwd: workingDirectory must be supplied as a string') + : adhocExecTask(() => { + if (!folderExists(workingDirectory)) { + throw new Error(`Git.cwd: cannot change to non-directory "${ workingDirectory }"`); + } + + return (this._executor.cwd = workingDirectory); + }); + + return this._runTask(task, trailingFunctionArgument(arguments) || NOOP); +}; + +/** + * Sets a handler function to be called whenever a new child process is created, the handler function will be called + * with the name of the command being run and the stdout & stderr streams used by the ChildProcess. + * + * @example + * require('simple-git') + * .outputHandler(function (command, stdout, stderr) { + * stdout.pipe(process.stdout); + * }) + * .checkout('https://github.com/user/repo.git'); + * + * @see https://nodejs.org/api/child_process.html#child_process_class_childprocess + * @see https://nodejs.org/api/stream.html#stream_class_stream_readable + * @param {Function} outputHandler + * @returns {Git} + */ +Git.prototype.outputHandler = function (outputHandler) { + this._executor.outputHandler = outputHandler; + return this; +}; + +/** + * Initialize a git repo + * + * @param {Boolean} [bare=false] + * @param {Function} [then] + */ +Git.prototype.init = function (bare, then) { + return this._runTask( + initTask(bare === true, this._executor.cwd, getTrailingOptions(arguments)), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Check the status of the local repo + */ +Git.prototype.status = function () { + return this._runTask( + statusTask(getTrailingOptions(arguments)), + trailingFunctionArgument(arguments), + ); +}; + +/** + * List the stash(s) of the local repo + */ +Git.prototype.stashList = function (options) { + return this._runTask( + stashListTask( + trailingOptionsArgument(arguments) || {}, + filterArray(options) && options || [] + ), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Stash the local repo + * + * @param {Object|Array} [options] + * @param {Function} [then] + */ +Git.prototype.stash = function (options, then) { + return this._runTask( + straightThroughStringTask(['stash', ...getTrailingOptions(arguments)]), + trailingFunctionArgument(arguments), + ); +}; + +function createCloneTask (api, task, repoPath, localPath) { + if (typeof repoPath !== 'string') { + return configurationErrorTask(`git.${ api }() requires a string 'repoPath'`); + } + + return task(repoPath, filterType(localPath, filterString), getTrailingOptions(arguments)); +} + + +/** + * Clone a git repo + */ +Git.prototype.clone = function () { + return this._runTask( + createCloneTask('clone', cloneTask, ...arguments), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Mirror a git repo + */ +Git.prototype.mirror = function () { + return this._runTask( + createCloneTask('mirror', cloneMirrorTask, ...arguments), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Moves one or more files to a new destination. + * + * @see https://git-scm.com/docs/git-mv + * + * @param {string|string[]} from + * @param {string} to + */ +Git.prototype.mv = function (from, to) { + return this._runTask(moveTask(from, to), trailingFunctionArgument(arguments)); +}; + +/** + * Internally uses pull and tags to get the list of tags then checks out the latest tag. + * + * @param {Function} [then] + */ +Git.prototype.checkoutLatestTag = function (then) { + var git = this; + return this.pull(function () { + git.tags(function (err, tags) { + git.checkout(tags.latest, then); + }); + }); +}; + +/** + * Commits changes in the current working directory - when specific file paths are supplied, only changes on those + * files will be committed. + * + * @param {string|string[]} message + * @param {string|string[]} [files] + * @param {Object} [options] + * @param {Function} [then] + */ +Git.prototype.commit = function (message, files, options, then) { + const next = trailingFunctionArgument(arguments); + const messages = []; + + if (filterStringOrStringArray(message)) { + messages.push(...asArray(message)); + } else { + console.warn('simple-git deprecation notice: git.commit: requires the commit message to be supplied as a string/string[], this will be an error in version 3'); + } + + return this._runTask( + commitTask( + messages, + asArray(filterType(files, filterStringOrStringArray, [])), + [...filterType(options, filterArray, []), ...getTrailingOptions(arguments, 0, true)] + ), + next + ); +}; + +/** + * Pull the updated contents of the current repo + */ +Git.prototype.pull = function (remote, branch, options, then) { + return this._runTask( + pullTask(filterType(remote, filterString), filterType(branch, filterString), getTrailingOptions(arguments)), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Fetch the updated contents of the current repo. + * + * @example + * .fetch('upstream', 'master') // fetches from master on remote named upstream + * .fetch(function () {}) // runs fetch against default remote and branch and calls function + * + * @param {string} [remote] + * @param {string} [branch] + */ +Git.prototype.fetch = function (remote, branch) { + return this._runTask( + fetchTask(filterType(remote, filterString), filterType(branch, filterString), getTrailingOptions(arguments)), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Disables/enables the use of the console for printing warnings and errors, by default messages are not shown in + * a production environment. + * + * @param {boolean} silence + * @returns {Git} + */ +Git.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'); + this._logger.silent(!!silence); + return this; +}; + +/** + * List all tags. When using git 2.7.0 or above, include an options object with `"--sort": "property-name"` to + * sort the tags by that property instead of using the default semantic versioning sort. + * + * Note, supplying this option when it is not supported by your Git version will cause the operation to fail. + * + * @param {Object} [options] + * @param {Function} [then] + */ +Git.prototype.tags = function (options, then) { + return this._runTask( + tagListTask(getTrailingOptions(arguments)), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Rebases the current working copy. Options can be supplied either as an array of string parameters + * to be sent to the `git rebase` command, or a standard options object. + */ +Git.prototype.rebase = function () { + return this._runTask( + straightThroughStringTask(['rebase', ...getTrailingOptions(arguments)]), + trailingFunctionArgument(arguments) + ); +}; + +/** + * Reset a repo + */ +Git.prototype.reset = function (mode) { + return this._runTask( + resetTask(getResetMode(mode), getTrailingOptions(arguments)), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Revert one or more commits in the local working copy + */ +Git.prototype.revert = function (commit) { + const next = trailingFunctionArgument(arguments); + + if (typeof commit !== 'string') { + return this._runTask( + configurationErrorTask('Commit must be a string'), + next, + ); + } + + return this._runTask( + straightThroughStringTask(['revert', ...getTrailingOptions(arguments, 0, true), commit]), + next + ); +}; + +/** + * Add a lightweight tag to the head of the current branch + */ +Git.prototype.addTag = function (name) { + const task = (typeof name === 'string') + ? addTagTask(name) + : configurationErrorTask('Git.addTag requires a tag name'); + + return this._runTask(task, trailingFunctionArgument(arguments)); +}; + +/** + * Add an annotated tag to the head of the current branch + */ +Git.prototype.addAnnotatedTag = function (tagName, tagMessage) { + return this._runTask( + addAnnotatedTagTask(tagName, tagMessage), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Check out a tag or revision, any number of additional arguments can be passed to the `git checkout` command + * by supplying either a string or array of strings as the first argument. + */ +Git.prototype.checkout = function () { + const commands = ['checkout', ...getTrailingOptions(arguments, true)]; + return this._runTask( + straightThroughStringTask(commands), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Check out a remote branch + * + * @param {string} branchName name of branch + * @param {string} startPoint (e.g origin/development) + * @param {Function} [then] + */ +Git.prototype.checkoutBranch = function (branchName, startPoint, then) { + return this.checkout(['-b', branchName, startPoint], trailingFunctionArgument(arguments)); +}; + +/** + * Check out a local branch + */ +Git.prototype.checkoutLocalBranch = function (branchName, then) { + return this.checkout(['-b', branchName], trailingFunctionArgument(arguments)); +}; + +/** + * Delete a local branch + */ +Git.prototype.deleteLocalBranch = function (branchName, forceDelete, then) { + return this._runTask( + deleteBranchTask(branchName, typeof forceDelete === "boolean" ? forceDelete : false), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Delete one or more local branches + */ +Git.prototype.deleteLocalBranches = function (branchNames, forceDelete, then) { + return this._runTask( + deleteBranchesTask(branchNames, typeof forceDelete === "boolean" ? forceDelete : false), + trailingFunctionArgument(arguments), + ); +}; + +/** + * List all branches + * + * @param {Object | string[]} [options] + * @param {Function} [then] + */ +Git.prototype.branch = function (options, then) { + return this._runTask( + branchTask(getTrailingOptions(arguments)), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Return list of local branches + * + * @param {Function} [then] + */ +Git.prototype.branchLocal = function (then) { + return this._runTask( + branchLocalTask(), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Add config to local git instance + * + * @param {string} key configuration key (e.g user.name) + * @param {string} value for the given key (e.g your name) + * @param {boolean} [append=false] optionally append the key/value pair (equivalent of passing `--add` option). + * @param {Function} [then] + */ +Git.prototype.addConfig = function (key, value, append, then) { + return this._runTask( + addConfigTask(key, value, typeof append === "boolean" ? append : false), + trailingFunctionArgument(arguments), + ); +}; + +Git.prototype.listConfig = function () { + return this._runTask(listConfigTask(), trailingFunctionArgument(arguments)); +}; + +/** + * Executes any command against the git binary. + */ +Git.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 (!filterPrimitives(command[i])) { + command.splice(i, command.length - i); + break; + } + } + + command.push( + ...getTrailingOptions(arguments, 0, true), + ); + + var next = trailingFunctionArgument(arguments); + + if (!command.length) { + return this._runTask( + configurationErrorTask('Raw: must supply one or more command to execute'), + next, + ); + } + + return this._runTask(straightThroughStringTask(command), next); +}; + +Git.prototype.submoduleAdd = function (repo, path, then) { + return this._runTask( + addSubModuleTask(repo, path), + trailingFunctionArgument(arguments), + ); +}; + +Git.prototype.submoduleUpdate = function (args, then) { + return this._runTask( + updateSubModuleTask(getTrailingOptions(arguments, true)), + trailingFunctionArgument(arguments), + ); +}; + +Git.prototype.submoduleInit = function (args, then) { + return this._runTask( + initSubModuleTask(getTrailingOptions(arguments, true)), + trailingFunctionArgument(arguments), + ); +}; + +Git.prototype.subModule = function (options, then) { + return this._runTask( + subModuleTask(getTrailingOptions(arguments)), + trailingFunctionArgument(arguments), + ); +}; + +Git.prototype.listRemote = function () { + return this._runTask( + listRemotesTask(getTrailingOptions(arguments)), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Adds a remote to the list of remotes. + */ +Git.prototype.addRemote = function (remoteName, remoteRepo, then) { + return this._runTask( + addRemoteTask(remoteName, remoteRepo, getTrailingOptions(arguments)), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Removes an entry by name from the list of remotes. + */ +Git.prototype.removeRemote = function (remoteName, then) { + return this._runTask( + removeRemoteTask(remoteName), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Gets the currently available remotes, setting the optional verbose argument to true includes additional + * detail on the remotes themselves. + */ +Git.prototype.getRemotes = function (verbose, then) { + return this._runTask( + getRemotesTask(verbose === true), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Compute object ID from a file + */ +Git.prototype.hashObject = function (path, write) { + return this._runTask( + hashObjectTask(path, write === true), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Call any `git remote` function with arguments passed as an array of strings. + * + * @param {string[]} options + * @param {Function} [then] + */ +Git.prototype.remote = function (options, then) { + return this._runTask( + remoteTask(getTrailingOptions(arguments)), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Merges from one branch to another, equivalent to running `git merge ${from} $[to}`, the `options` argument can + * either be an array of additional parameters to pass to the command or null / omitted to be ignored. + * + * @param {string} from + * @param {string} to + */ +Git.prototype.mergeFromTo = function (from, to) { + if (!(filterString(from) && filterString(to))) { + return this._runTask(configurationErrorTask( + `Git.mergeFromTo requires that the 'from' and 'to' arguments are supplied as strings` + )); + } + + return this._runTask( + mergeTask([from, to, ...getTrailingOptions(arguments)]), + trailingFunctionArgument(arguments, false), + ); +}; + +/** + * Runs a merge, `options` can be either an array of arguments + * supported by the [`git merge`](https://git-scm.com/docs/git-merge) + * or an options object. + * + * Conflicts during the merge result in an error response, + * the response type whether it was an error or success will be a MergeSummary instance. + * When successful, the MergeSummary has all detail from a the PullSummary + * + * @param {Object | string[]} [options] + * @param {Function} [then] + * @returns {*} + * + * @see ./responses/MergeSummary.js + * @see ./responses/PullSummary.js + */ +Git.prototype.merge = function () { + return this._runTask( + mergeTask(getTrailingOptions(arguments)), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Call any `git tag` function with arguments passed as an array of strings. + * + * @param {string[]} options + * @param {Function} [then] + */ +Git.prototype.tag = function (options, then) { + const command = getTrailingOptions(arguments); + + if (command[0] !== 'tag') { + command.unshift('tag'); + } + + return this._runTask( + straightThroughStringTask(command), + trailingFunctionArgument(arguments) + ); +}; + +/** + * Updates repository server info + * + * @param {Function} [then] + */ +Git.prototype.updateServerInfo = function (then) { + return this._runTask( + straightThroughStringTask(['update-server-info']), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Pushes the current tag changes to a remote which can be either a URL or named remote. When not specified uses the + * default configured remote spec. + * + * @param {string} [remote] + * @param {Function} [then] + */ +Git.prototype.pushTags = function (remote, then) { + const task = pushTagsTask({remote: filterType(remote, filterString)}, getTrailingOptions(arguments)); + + return this._runTask(task, trailingFunctionArgument(arguments)); +}; + +/** + * Removes the named files from source control. + */ +Git.prototype.rm = function (files) { + return this._runTask( + straightThroughStringTask(['rm', '-f', ...asArray(files)]), + trailingFunctionArgument(arguments) + ); +}; + +/** + * Removes the named files from source control but keeps them on disk rather than deleting them entirely. To + * completely remove the files, use `rm`. + * + * @param {string|string[]} files + */ +Git.prototype.rmKeepLocal = function (files) { + return this._runTask( + straightThroughStringTask(['rm', '--cached', ...asArray(files)]), + trailingFunctionArgument(arguments) + ); +}; + +/** + * Returns a list of objects in a tree based on commit hash. Passing in an object hash returns the object's content, + * size, and type. + * + * Passing "-p" will instruct cat-file to determine the object type, and display its formatted contents. + * + * @param {string[]} [options] + * @param {Function} [then] + */ +Git.prototype.catFile = function (options, then) { + return this._catFile('utf-8', arguments); +}; + +Git.prototype.binaryCatFile = function () { + return this._catFile('buffer', arguments); +}; + +Git.prototype._catFile = function (format, args) { + var handler = trailingFunctionArgument(args); + var command = ['cat-file']; + var options = args[0]; + + if (typeof options === 'string') { + return this._runTask( + configurationErrorTask('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' + ? straightThroughBufferTask(command) + : straightThroughStringTask(command); + + return this._runTask(task, handler); +}; + +Git.prototype.diff = function (options, then) { + const command = ['diff', ...getTrailingOptions(arguments)]; + + if (typeof options === 'string') { + command.splice(1, 0, options); + this._logger.warn('Git#diff: supplying options as a single string is now deprecated, switch to an array of strings'); + } + + return this._runTask( + straightThroughStringTask(command), + trailingFunctionArgument(arguments), + ); +}; + +Git.prototype.diffSummary = function () { + return this._runTask( + diffSummaryTask(getTrailingOptions(arguments, 1)), + trailingFunctionArgument(arguments), + ); +}; + +Git.prototype.applyPatch = function (patches) { + const task = !filterStringOrStringArray(patches) + ? configurationErrorTask(`git.applyPatch requires one or more string patches as the first argument`) + : applyPatchTask(asArray(patches), getTrailingOptions([].slice.call(arguments, 1))); + + return this._runTask( + task, + trailingFunctionArgument(arguments), + ); +}; + +Git.prototype.revparse = function () { + const commands = ['rev-parse', ...getTrailingOptions(arguments, true)]; + return this._runTask( + straightThroughStringTask(commands, true), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Show various types of objects, for example the file at a certain commit + * + * @param {string[]} [options] + * @param {Function} [then] + */ +Git.prototype.show = function (options, then) { + return this._runTask( + straightThroughStringTask(['show', ...getTrailingOptions(arguments, 1)]), + trailingFunctionArgument(arguments) + ); +}; + +/** + */ +Git.prototype.clean = function (mode, options, then) { + const usingCleanOptionsArray = isCleanOptionsArray(mode); + const cleanMode = usingCleanOptionsArray && mode.join('') || filterType(mode, filterString) || ''; + const customArgs = getTrailingOptions([].slice.call(arguments, usingCleanOptionsArray ? 1 : 0)); + + return this._runTask( + cleanWithOptionsTask(cleanMode, customArgs), + trailingFunctionArgument(arguments), + ); +}; + +/** + * Call a simple function at the next step in the chain. + * @param {Function} [then] + */ +Git.prototype.exec = function (then) { + const task = { + commands: [], + format: 'utf-8', + parser () { + if (typeof then === 'function') { + then(); + } + } + }; + + return this._runTask(task); +}; + +/** + * Show commit logs from `HEAD` to the first commit. + * If provided between `options.from` and `options.to` tags or branch. + * + * Additionally you can provide options.file, which is the path to a file in your repository. Then only this file will be considered. + * + * To use a custom splitter in the log format, set `options.splitter` to be the string the log should be split on. + * + * Options can also be supplied as a standard options object for adding custom properties supported by the git log command. + * For any other set of options, supply options as an array of strings to be appended to the git log command. + */ +Git.prototype.log = function (options) { + const next = trailingFunctionArgument(arguments); + + if (filterString(arguments[0]) && filterString(arguments[1])) { + return this._runTask( + configurationErrorTask(`git.log(string, string) should be replaced with git.log({ from: string, to: string })`), + next + ); + } + + const parsedOptions = parseLogOptions( + trailingOptionsArgument(arguments) || {}, + filterArray(options) && options || [] + ); + + return this._runTask( + logTask(parsedOptions.splitter, parsedOptions.fields, parsedOptions.commands), + next, + ) +}; + +/** + * Clears the queue of pending commands and returns the wrapper instance for chaining. + * + * @returns {Git} + */ +Git.prototype.clearQueue = function () { + // TODO: + // this._executor.clear(); + return this; +}; + +/** + * Check if a pathname or pathnames are excluded by .gitignore + * + * @param {string|string[]} pathnames + * @param {Function} [then] + */ +Git.prototype.checkIgnore = function (pathnames, then) { + return this._runTask( + checkIgnoreTask(asArray((filterType(pathnames, filterStringOrStringArray, [])))), + trailingFunctionArgument(arguments), + ); +}; + +Git.prototype.checkIsRepo = function (checkType, then) { + return this._runTask( + checkIsRepoTask(filterType(checkType, filterString)), + trailingFunctionArgument(arguments), + ); +}; + +var git = Git; + +var gitFactory = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.gitInstanceFactory = exports.gitExportFactory = exports.esModuleFactory = void 0; + + + + +/** + * Adds the necessary properties to the supplied object to enable it for use as + * the default export of a module. + * + * Eg: `module.exports = esModuleFactory({ something () {} })` + */ +function esModuleFactory(defaultExport) { + return Object.defineProperties(defaultExport, { + __esModule: { value: true }, + default: { value: defaultExport }, + }); +} +exports.esModuleFactory = esModuleFactory; +function gitExportFactory(factory, extra) { + return Object.assign(function (...args) { + return factory.apply(null, args); + }, api_1.default, extra || {}); +} +exports.gitExportFactory = gitExportFactory; +function gitInstanceFactory(baseDir, options) { + const plugins$1 = new plugins.PluginStore(); + const config = utils.createInstanceConfig(baseDir && (typeof baseDir === 'string' ? { baseDir } : baseDir) || {}, options); + if (!utils.folderExists(config.baseDir)) { + throw new api_1.default.GitConstructError(config, `Cannot use simple-git on a directory that does not exist`); + } + if (Array.isArray(config.config)) { + plugins$1.add(plugins.commandConfigPrefixingPlugin(config.config)); + } + config.progress && plugins$1.add(plugins.progressMonitorPlugin(config.progress)); + config.timeout && plugins$1.add(plugins.timeoutPlugin(config.timeout)); + plugins$1.add(plugins.errorDetectionPlugin(plugins.errorDetectionHandler(true))); + config.errors && plugins$1.add(plugins.errorDetectionPlugin(config.errors)); + return new git(config, plugins$1); +} +exports.gitInstanceFactory = gitInstanceFactory; +//# sourceMappingURL=git-factory.js.map +}); + +var promiseWrapped = createCommonjsModule(function (module, exports) { +Object.defineProperty(exports, "__esModule", { value: true }); +exports.gitP = void 0; + + +const functionNamesBuilderApi = [ + 'customBinary', 'env', 'outputHandler', 'silent', +]; +const functionNamesPromiseApi = [ + 'add', + 'addAnnotatedTag', + 'addConfig', + 'addRemote', + 'addTag', + 'applyPatch', + 'binaryCatFile', + 'branch', + 'branchLocal', + 'catFile', + 'checkIgnore', + 'checkIsRepo', + 'checkout', + 'checkoutBranch', + 'checkoutLatestTag', + 'checkoutLocalBranch', + 'clean', + 'clone', + 'commit', + 'cwd', + 'deleteLocalBranch', + 'deleteLocalBranches', + 'diff', + 'diffSummary', + 'exec', + 'fetch', + 'getRemotes', + 'init', + 'listConfig', + 'listRemote', + 'log', + 'merge', + 'mergeFromTo', + 'mirror', + 'mv', + 'pull', + 'push', + 'pushTags', + 'raw', + 'rebase', + 'remote', + 'removeRemote', + 'reset', + 'revert', + 'revparse', + 'rm', + 'rmKeepLocal', + 'show', + 'stash', + 'stashList', + 'status', + 'subModule', + 'submoduleAdd', + 'submoduleInit', + 'submoduleUpdate', + 'tag', + 'tags', + 'updateServerInfo' +]; +function gitP(...args) { + let git; + let chain = Promise.resolve(); + try { + git = gitFactory.gitInstanceFactory(...args); + } + catch (e) { + chain = Promise.reject(e); + } + function builderReturn() { + return promiseApi; + } + function chainReturn() { + return chain; + } + const promiseApi = [...functionNamesBuilderApi, ...functionNamesPromiseApi].reduce((api, name) => { + const isAsync = functionNamesPromiseApi.includes(name); + const valid = isAsync ? asyncWrapper(name, git) : syncWrapper(name, git, api); + const alternative = isAsync ? chainReturn : builderReturn; + Object.defineProperty(api, name, { + enumerable: false, + configurable: false, + value: git ? valid : alternative, + }); + return api; + }, {}); + return promiseApi; + function asyncWrapper(fn, git) { + return function (...args) { + if (typeof args[args.length] === 'function') { + throw new TypeError('Promise interface requires that handlers are not supplied inline, ' + + 'trailing function not allowed in call to ' + fn); + } + return chain.then(function () { + return new Promise(function (resolve, reject) { + const callback = (err, result) => { + if (err) { + return reject(toError(err)); + } + resolve(result); + }; + args.push(callback); + git[fn].apply(git, args); + }); + }); + }; + } + function syncWrapper(fn, git, api) { + return (...args) => { + git[fn](...args); + return api; + }; + } +} +exports.gitP = gitP; +function toError(error) { + if (error instanceof Error) { + return error; + } + if (typeof error === 'string') { + return new Error(error); + } + return new gitResponseError.GitResponseError(error); +} +//# sourceMappingURL=promise-wrapped.js.map +}); + +const {gitP} = promiseWrapped; +const {esModuleFactory, gitInstanceFactory, gitExportFactory} = gitFactory; + +var src = esModuleFactory( + gitExportFactory(gitInstanceFactory, {gitP}) +); + +var PluginState; +(function (PluginState) { + PluginState[PluginState["idle"] = 0] = "idle"; + PluginState[PluginState["status"] = 1] = "status"; + PluginState[PluginState["pull"] = 2] = "pull"; + PluginState[PluginState["add"] = 3] = "add"; + PluginState[PluginState["commit"] = 4] = "commit"; + PluginState[PluginState["push"] = 5] = "push"; + PluginState[PluginState["conflicted"] = 6] = "conflicted"; +})(PluginState || (PluginState = {})); +var DEFAULT_SETTINGS = { + commitMessage: "vault backup: {{date}}", + commitDateFormat: "YYYY-MM-DD HH:mm:ss", + autoSaveInterval: 0, + autoPullInterval: 0, + autoPullOnBoot: false, + disablePush: false, + pullBeforePush: true, + disablePopups: false, + listChangedFilesInMessageBody: false, + showStatusBar: true, + lastAutoBackUp: "", + lastAutoPull: "" +}; +var ObsidianGit = /** @class */ (function (_super) { + __extends(ObsidianGit, _super); + function ObsidianGit() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this.gitReady = false; + _this.promiseQueue = new PromiseQueue(); + _this.conflictOutputFile = "conflict-files-obsidian-git.md"; + return _this; + // endregion: displaying / formatting stuff + } + ObsidianGit.prototype.setState = function (state) { + var _a; + this.state = state; + (_a = this.statusBar) === null || _a === void 0 ? void 0 : _a.display(); + }; + ObsidianGit.prototype.onload = function () { + return __awaiter(this, void 0, void 0, function () { + var statusBarEl; + var _this = this; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + console.log('loading ' + this.manifest.name + " plugin"); + return [4 /*yield*/, this.loadSettings()]; + case 1: + _a.sent(); + this.addSettingTab(new ObsidianGitSettingsTab(this.app, this)); + this.addCommand({ + id: "pull", + name: "Pull from remote repository", + callback: function () { return _this.promiseQueue.addTask(function () { return _this.pullChangesFromRemote(); }); }, + }); + this.addCommand({ + id: "push", + name: "Commit *all* changes and push to remote repository", + callback: function () { return _this.promiseQueue.addTask(function () { return _this.createBackup(false); }); } + }); + this.addCommand({ + id: "commit-push-specified-message", + name: "Commit and push all changes with specified message", + callback: function () { return new CustomMessageModal(_this).open(); } + }); + this.addCommand({ + id: "list-changed-files", + name: "List changed files", + callback: function () { return __awaiter(_this, void 0, void 0, function () { + var status; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, this.git.status()]; + case 1: + status = _a.sent(); + new ChangedFilesModal(this, status.files).open(); + return [2 /*return*/]; + } + }); + }); } + }); + if (this.settings.showStatusBar) { + statusBarEl = this.addStatusBarItem(); + this.statusBar = new StatusBar(statusBarEl, this); + this.registerInterval(window.setInterval(function () { return _this.statusBar.display(); }, 1000)); + } + this.init(); + return [2 /*return*/]; + } + }); + }); + }; + ObsidianGit.prototype.onunload = function () { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + window.clearTimeout(this.timeoutIDBackup); + window.clearTimeout(this.timeoutIDPull); + console.log('unloading ' + this.manifest.name + " plugin"); + return [2 /*return*/]; + }); + }); + }; + ObsidianGit.prototype.loadSettings = function () { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c, _d; + return __generator(this, function (_e) { + switch (_e.label) { + case 0: + _a = this; + _c = (_b = Object).assign; + _d = [{}, DEFAULT_SETTINGS]; + return [4 /*yield*/, this.loadData()]; + case 1: + _a.settings = _c.apply(_b, _d.concat([_e.sent()])); + return [2 /*return*/]; + } + }); + }); + }; + ObsidianGit.prototype.saveSettings = function () { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, this.saveData(this.settings)]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); + }; + ObsidianGit.prototype.init = function () { + return __awaiter(this, void 0, void 0, function () { + var adapter, path, isValidRepo, now, last, diff, now, last, diff, error_1; + var _this = this; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + if (!this.isGitInstalled()) { + this.displayError("Cannot run git command"); + return [2 /*return*/]; + } + _a.label = 1; + case 1: + _a.trys.push([1, 3, , 4]); + adapter = this.app.vault.adapter; + path = adapter.getBasePath(); + this.git = src(path); + return [4 /*yield*/, this.git.checkIsRepo()]; + case 2: + isValidRepo = _a.sent(); + if (!isValidRepo) { + this.displayError("Valid git repository not found."); + } + else { + this.gitReady = true; + this.setState(PluginState.idle); + if (this.settings.autoPullOnBoot) { + this.promiseQueue.addTask(function () { return _this.pullChangesFromRemote(); }); + } + if (this.settings.autoSaveInterval > 0) { + now = new Date(); + last = new Date(this.settings.lastAutoBackUp); + diff = this.settings.autoSaveInterval - (Math.round(((now.getTime() - last.getTime()) / 1000) / 60)); + this.startAutoBackup(diff <= 0 ? 0 : diff); + } + if (this.settings.autoPullInterval > 0) { + now = new Date(); + last = new Date(this.settings.lastAutoPull); + diff = this.settings.autoPullInterval - (Math.round(((now.getTime() - last.getTime()) / 1000) / 60)); + this.startAutoPull(diff <= 0 ? 0 : diff); + } + } + return [3 /*break*/, 4]; + case 3: + error_1 = _a.sent(); + this.displayError(error_1); + console.error(error_1); + return [3 /*break*/, 4]; + case 4: return [2 /*return*/]; + } + }); + }); + }; + ObsidianGit.prototype.pullChangesFromRemote = function () { + return __awaiter(this, void 0, void 0, function () { + var filesUpdated, status; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + if (!!this.gitReady) return [3 /*break*/, 2]; + return [4 /*yield*/, this.init()]; + case 1: + _a.sent(); + _a.label = 2; + case 2: + if (!this.gitReady) + return [2 /*return*/]; + return [4 /*yield*/, this.pull()]; + case 3: + filesUpdated = _a.sent(); + if (filesUpdated > 0) { + this.displayMessage("Pulled new changes. " + filesUpdated + " files updated"); + } + else { + this.displayMessage("Everything is up-to-date"); + } + return [4 /*yield*/, this.git.status()]; + case 4: + status = _a.sent(); + if (status.conflicted.length > 0) { + this.displayError("You have " + status.conflicted.length + " conflict files"); + } + this.lastUpdate = Date.now(); + this.setState(PluginState.idle); + return [2 /*return*/]; + } + }); + }); + }; + ObsidianGit.prototype.createBackup = function (fromAutoBackup, commitMessage) { + return __awaiter(this, void 0, void 0, function () { + var status, file, changedFiles, trackingBranch, currentBranch, remoteChangedFiles, pulledFilesLength, remoteChangedFiles_1; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + if (!!this.gitReady) return [3 /*break*/, 2]; + return [4 /*yield*/, this.init()]; + case 1: + _a.sent(); + _a.label = 2; + case 2: + if (!this.gitReady) + return [2 /*return*/]; + this.setState(PluginState.status); + return [4 /*yield*/, this.git.status()]; + case 3: + status = _a.sent(); + if (!!fromAutoBackup) return [3 /*break*/, 5]; + file = this.app.vault.getAbstractFileByPath(this.conflictOutputFile); + return [4 /*yield*/, this.app.vault.delete(file)]; + case 4: + _a.sent(); + _a.label = 5; + case 5: + // check for conflict files on auto backup + if (fromAutoBackup && status.conflicted.length > 0) { + this.setState(PluginState.idle); + this.displayError("Did not commit, because you have " + status.conflicted.length + " conflict files. Please resolve them and commit per command."); + this.handleConflict(status.conflicted); + return [2 /*return*/]; + } + return [4 /*yield*/, this.git.status()]; + case 6: + changedFiles = (_a.sent()).files; + if (!(changedFiles.length !== 0)) return [3 /*break*/, 10]; + return [4 /*yield*/, this.add()]; + case 7: + _a.sent(); + return [4 /*yield*/, this.git.status()]; + case 8: + status = _a.sent(); + return [4 /*yield*/, this.commit(commitMessage)]; + case 9: + _a.sent(); + this.lastUpdate = Date.now(); + this.displayMessage("Committed " + status.staged.length + " files"); + return [3 /*break*/, 11]; + case 10: + this.displayMessage("No changes to commit"); + _a.label = 11; + case 11: + if (!!this.settings.disablePush) return [3 /*break*/, 21]; + trackingBranch = status.tracking; + currentBranch = status.current; + if (!trackingBranch) { + this.displayError("Did not push. No upstream branch is set! See README for instructions", 10000); + this.setState(PluginState.idle); + return [2 /*return*/]; + } + return [4 /*yield*/, this.git.diffSummary([currentBranch, trackingBranch])]; + case 12: + remoteChangedFiles = (_a.sent()).changed; + if (!(remoteChangedFiles > 0)) return [3 /*break*/, 20]; + if (!this.settings.pullBeforePush) return [3 /*break*/, 14]; + return [4 /*yield*/, this.pull()]; + case 13: + pulledFilesLength = _a.sent(); + if (pulledFilesLength > 0) { + this.displayMessage("Pulled " + pulledFilesLength + " files from remote"); + } + _a.label = 14; + case 14: return [4 /*yield*/, this.git.status()]; + case 15: + // Refresh because of pull + status = _a.sent(); + if (!(status.conflicted.length > 0)) return [3 /*break*/, 16]; + this.displayError("Cannot push. You have " + status.conflicted.length + " conflict files"); + this.handleConflict(status.conflicted); + return [2 /*return*/]; + case 16: return [4 /*yield*/, this.git.diffSummary([currentBranch, trackingBranch])]; + case 17: + remoteChangedFiles_1 = (_a.sent()).changed; + return [4 /*yield*/, this.push()]; + case 18: + _a.sent(); + this.displayMessage("Pushed " + remoteChangedFiles_1 + " files to remote"); + _a.label = 19; + case 19: return [3 /*break*/, 21]; + case 20: + this.displayMessage("No changes to push"); + _a.label = 21; + case 21: + this.setState(PluginState.idle); + return [2 /*return*/]; + } + }); + }); + }; + // region: main methods + ObsidianGit.prototype.isGitInstalled = function () { + // https://github.com/steveukx/git-js/issues/402 + var command = child_process_1.spawnSync('git', ['--version'], { + stdio: 'ignore' + }); + if (command.error) { + console.error(command.error); + return false; + } + return true; + }; + ObsidianGit.prototype.add = function () { + return __awaiter(this, void 0, void 0, function () { + var _this = this; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + this.setState(PluginState.add); + return [4 /*yield*/, this.git.add("./*", function (err) { + return err && _this.displayError("Cannot add files: " + err.message); + })]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); + }; + ObsidianGit.prototype.commit = function (message) { + return __awaiter(this, void 0, void 0, function () { + var commitMessage, _a, _b; + return __generator(this, function (_c) { + switch (_c.label) { + case 0: + this.setState(PluginState.commit); + if (!(message !== null && message !== void 0)) return [3 /*break*/, 1]; + _a = message; + return [3 /*break*/, 3]; + case 1: return [4 /*yield*/, this.formatCommitMessage(this.settings.commitMessage)]; + case 2: + _a = _c.sent(); + _c.label = 3; + case 3: + commitMessage = _a; + if (!this.settings.listChangedFilesInMessageBody) return [3 /*break*/, 5]; + _b = [commitMessage, "Affected files:"]; + return [4 /*yield*/, this.git.status()]; + case 4: + commitMessage = _b.concat([(_c.sent()).staged.join("\n")]); + _c.label = 5; + case 5: return [4 /*yield*/, this.git.commit(commitMessage)]; + case 6: + _c.sent(); + return [2 /*return*/]; + } + }); + }); + }; + ObsidianGit.prototype.push = function () { + return __awaiter(this, void 0, void 0, function () { + var _this = this; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + this.setState(PluginState.push); + return [4 /*yield*/, this.git.env(__assign(__assign({}, process.env), { "OBSIDIAN_GIT": 1 })).push(function (err) { + err && _this.displayError("Push failed " + err.message); + })]; + case 1: + _a.sent(); + this.lastUpdate = Date.now(); + return [2 /*return*/]; + } + }); + }); + }; + ObsidianGit.prototype.pull = function () { + return __awaiter(this, void 0, void 0, function () { + var pullResult; + var _this = this; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + this.setState(PluginState.pull); + return [4 /*yield*/, this.git.pull(["--no-rebase"], function (err) { return __awaiter(_this, void 0, void 0, function () { + var status_1; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + if (!err) return [3 /*break*/, 2]; + this.displayError("Pull failed " + err.message); + return [4 /*yield*/, this.git.status()]; + case 1: + status_1 = _a.sent(); + if (status_1.conflicted.length > 0) { + this.handleConflict(status_1.conflicted); + } + _a.label = 2; + case 2: return [2 /*return*/]; + } + }); + }); })]; + case 1: + pullResult = _a.sent(); + this.lastUpdate = Date.now(); + return [2 /*return*/, pullResult.files.length]; + } + }); + }); + }; + // endregion: main methods + ObsidianGit.prototype.startAutoBackup = function (minutes) { + var _this = this; + this.timeoutIDBackup = window.setTimeout(function () { + _this.promiseQueue.addTask(function () { return _this.createBackup(true); }); + _this.settings.lastAutoBackUp = new Date().toString(); + _this.saveSettings(); + _this.startAutoBackup(); + }, (minutes !== null && minutes !== void 0 ? minutes : this.settings.autoSaveInterval) * 60000); + }; + ObsidianGit.prototype.startAutoPull = function (minutes) { + var _this = this; + this.timeoutIDPull = window.setTimeout(function () { + _this.promiseQueue.addTask(function () { return _this.pullChangesFromRemote(); }); + _this.settings.lastAutoPull = new Date().toString(); + _this.saveSettings(); + _this.startAutoPull(); + }, (minutes !== null && minutes !== void 0 ? minutes : this.settings.autoPullInterval) * 60000); + }; + ObsidianGit.prototype.clearAutoBackup = function () { + if (this.timeoutIDBackup) { + window.clearTimeout(this.timeoutIDBackup); + return true; + } + return false; + }; + ObsidianGit.prototype.clearAutoPull = function () { + if (this.timeoutIDPull) { + window.clearTimeout(this.timeoutIDPull); + return true; + } + return false; + }; + ObsidianGit.prototype.handleConflict = function (conflicted) { + return __awaiter(this, void 0, void 0, function () { + var lines; + var _this = this; + return __generator(this, function (_a) { + this.setState(PluginState.conflicted); + lines = __spreadArray([ + "# Conflict files", + "Please resolve them and commit per command (This file will be deleted before the commit)." + ], conflicted.map(function (e) { + var file = _this.app.vault.getAbstractFileByPath(e); + if (file instanceof obsidian.TFile) { + var link = _this.app.metadataCache.fileToLinktext(file, "/"); + return "- [[" + link + "]]"; + } + else { + return "- Not a file: " + e; + } + })); + this.writeAndOpenFile(lines.join("\n")); + return [2 /*return*/]; + }); + }); + }; + ObsidianGit.prototype.writeAndOpenFile = function (text) { + return __awaiter(this, void 0, void 0, function () { + var fileIsAlreadyOpened; + var _this = this; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, this.app.vault.adapter.write(this.conflictOutputFile, text)]; + case 1: + _a.sent(); + fileIsAlreadyOpened = false; + this.app.workspace.iterateAllLeaves(function (leaf) { + if (leaf.getDisplayText() != "" && _this.conflictOutputFile.startsWith(leaf.getDisplayText())) { + fileIsAlreadyOpened = true; + } + }); + if (!fileIsAlreadyOpened) { + this.app.workspace.openLinkText(this.conflictOutputFile, "/", true); + } + return [2 /*return*/]; + } + }); + }); + }; + // region: displaying / formatting messages + ObsidianGit.prototype.displayMessage = function (message, timeout) { + var _a; + if (timeout === void 0) { timeout = 4 * 1000; } + (_a = this.statusBar) === null || _a === void 0 ? void 0 : _a.displayMessage(message.toLowerCase(), timeout); + if (!this.settings.disablePopups) { + new obsidian.Notice(message); + } + console.log("git obsidian message: " + message); + }; + ObsidianGit.prototype.displayError = function (message, timeout) { + var _a; + if (timeout === void 0) { timeout = 0; } + new obsidian.Notice(message); + console.log("git obsidian error: " + message); + (_a = this.statusBar) === null || _a === void 0 ? void 0 : _a.displayMessage(message.toLowerCase(), timeout); + }; + ObsidianGit.prototype.formatCommitMessage = function (template) { + return __awaiter(this, void 0, void 0, function () { + var status_2, numFiles, status_3, changeset_1, chunks, _i, _a, _b, action, files_1, files, moment; + return __generator(this, function (_c) { + switch (_c.label) { + case 0: + if (!template.includes("{{numFiles}}")) return [3 /*break*/, 2]; + return [4 /*yield*/, this.git.status()]; + case 1: + status_2 = _c.sent(); + numFiles = status_2.files.length; + template = template.replace("{{numFiles}}", String(numFiles)); + _c.label = 2; + case 2: + if (!template.includes("{{files}}")) return [3 /*break*/, 4]; + return [4 /*yield*/, this.git.status()]; + case 3: + status_3 = _c.sent(); + changeset_1 = {}; + status_3.files.forEach(function (value) { + if (value.index in changeset_1) { + changeset_1[value.index].push(value.path); + } + else { + changeset_1[value.index] = [value.path]; + } + }); + chunks = []; + for (_i = 0, _a = Object.entries(changeset_1); _i < _a.length; _i++) { + _b = _a[_i], action = _b[0], files_1 = _b[1]; + chunks.push(action + " " + files_1.join(" ")); + } + files = chunks.join(", "); + template = template.replace("{{files}}", files); + _c.label = 4; + case 4: + moment = window.moment; + return [2 /*return*/, template.replace("{{date}}", moment().format(this.settings.commitDateFormat))]; + } + }); + }); + }; + return ObsidianGit; +}(obsidian.Plugin)); +var ObsidianGitSettingsTab = /** @class */ (function (_super) { + __extends(ObsidianGitSettingsTab, _super); + function ObsidianGitSettingsTab() { + return _super !== null && _super.apply(this, arguments) || this; + } + ObsidianGitSettingsTab.prototype.display = function () { + var _this = this; + var containerEl = this.containerEl; + var plugin = this.plugin; + containerEl.empty(); + containerEl.createEl("h2", { text: "Git Backup settings" }); + new obsidian.Setting(containerEl) + .setName("Vault backup interval (minutes)") + .setDesc("Commit and push changes every X minutes. To disable automatic backup, specify negative value or zero (default)") + .addText(function (text) { + return text + .setValue(String(plugin.settings.autoSaveInterval)) + .onChange(function (value) { + if (!isNaN(Number(value))) { + plugin.settings.autoSaveInterval = Number(value); + plugin.saveSettings(); + if (plugin.settings.autoSaveInterval > 0) { + plugin.clearAutoBackup(); + plugin.startAutoBackup(plugin.settings.autoSaveInterval); + new obsidian.Notice("Automatic backup enabled! Every " + plugin.settings.autoSaveInterval + " minutes."); + } + else if (plugin.settings.autoSaveInterval <= 0 && + plugin.timeoutIDBackup) { + plugin.clearAutoBackup() && + new obsidian.Notice("Automatic backup disabled!"); + } + } + else { + new obsidian.Notice("Please specify a valid number."); + } + }); + }); + new obsidian.Setting(containerEl) + .setName("Auto pull interval (minutes)") + .setDesc("Pull changes every X minutes. To disable automatic pull, specify negative value or zero (default)") + .addText(function (text) { + return text + .setValue(String(plugin.settings.autoPullInterval)) + .onChange(function (value) { + if (!isNaN(Number(value))) { + plugin.settings.autoPullInterval = Number(value); + plugin.saveSettings(); + if (plugin.settings.autoPullInterval > 0) { + plugin.clearAutoPull(); + plugin.startAutoPull(plugin.settings.autoSaveInterval); + new obsidian.Notice("Automatic pull enabled! Every " + plugin.settings.autoPullInterval + " minutes."); + } + else if (plugin.settings.autoPullInterval <= 0 && + plugin.timeoutIDPull) { + plugin.clearAutoPull() && + new obsidian.Notice("Automatic pull disabled!"); + } + } + else { + new obsidian.Notice("Please specify a valid number."); + } + }); + }); + new obsidian.Setting(containerEl) + .setName("Commit message") + .setDesc("Specify custom commit message. Available placeholders: {{date}}" + + " (see below) and {{numFiles}} (number of changed files in the commit)") + .addText(function (text) { + return text + .setPlaceholder("vault backup") + .setValue(plugin.settings.commitMessage + ? plugin.settings.commitMessage + : "") + .onChange(function (value) { + plugin.settings.commitMessage = value; + plugin.saveSettings(); + }); + }); + new obsidian.Setting(containerEl) + .setName("{{date}} placeholder format") + .setDesc('Specify custom date format. E.g. "YYYY-MM-DD HH:mm:ss"') + .addText(function (text) { + return text + .setPlaceholder(plugin.settings.commitDateFormat) + .setValue(plugin.settings.commitDateFormat) + .onChange(function (value) { return __awaiter(_this, void 0, void 0, function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + plugin.settings.commitDateFormat = value; + return [4 /*yield*/, plugin.saveSettings()]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); }); + }); + new obsidian.Setting(containerEl) + .setName("Preview commit message") + .addButton(function (button) { + return button.setButtonText("Preview").onClick(function () { return __awaiter(_this, void 0, void 0, function () { + var commitMessagePreview; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, plugin.formatCommitMessage(plugin.settings.commitMessage)]; + case 1: + commitMessagePreview = _a.sent(); + new obsidian.Notice("" + commitMessagePreview); + return [2 /*return*/]; + } + }); + }); }); + }); + new obsidian.Setting(containerEl) + .setName("List filenames affected by commit in the commit body") + .addToggle(function (toggle) { + return toggle + .setValue(plugin.settings.listChangedFilesInMessageBody) + .onChange(function (value) { + plugin.settings.listChangedFilesInMessageBody = value; + plugin.saveSettings(); + }); + }); + new obsidian.Setting(containerEl) + .setName("Current branch") + .setDesc("Switch to a different branch") + .addDropdown(function (dropdown) { return __awaiter(_this, void 0, void 0, function () { + var branchInfo, _i, _a, branch; + var _this = this; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: return [4 /*yield*/, plugin.git.branchLocal()]; + case 1: + branchInfo = _b.sent(); + for (_i = 0, _a = branchInfo.all; _i < _a.length; _i++) { + branch = _a[_i]; + dropdown.addOption(branch, branch); + } + dropdown.setValue(branchInfo.current); + dropdown.onChange(function (option) { return __awaiter(_this, void 0, void 0, function () { + var _this = this; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, plugin.git.checkout(option, [], function (err) { return __awaiter(_this, void 0, void 0, function () { + return __generator(this, function (_a) { + if (err) { + new obsidian.Notice(err.message); + dropdown.setValue(branchInfo.current); + } + else { + new obsidian.Notice("Checked out to " + option); + } + return [2 /*return*/]; + }); + }); })]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); }); + return [2 /*return*/]; + } + }); + }); }); + new obsidian.Setting(containerEl) + .setName("Pull updates on startup") + .setDesc("Automatically pull updates when Obsidian starts") + .addToggle(function (toggle) { + return toggle + .setValue(plugin.settings.autoPullOnBoot) + .onChange(function (value) { + plugin.settings.autoPullOnBoot = value; + plugin.saveSettings(); + }); + }); + new obsidian.Setting(containerEl) + .setName("Disable push") + .setDesc("Do not push changes to the remote repository") + .addToggle(function (toggle) { + return toggle + .setValue(plugin.settings.disablePush) + .onChange(function (value) { + plugin.settings.disablePush = value; + plugin.saveSettings(); + }); + }); + new obsidian.Setting(containerEl) + .setName("Pull changes before push") + .setDesc("Commit -> pull -> push (Only if pushing is enabled)") + .addToggle(function (toggle) { + return toggle + .setValue(plugin.settings.pullBeforePush) + .onChange(function (value) { + plugin.settings.pullBeforePush = value; + plugin.saveSettings(); + }); + }); + new obsidian.Setting(containerEl) + .setName("Disable notifications") + .setDesc("Disable notifications for git operations to minimize distraction (refer to status bar for updates)") + .addToggle(function (toggle) { + return toggle + .setValue(plugin.settings.disablePopups) + .onChange(function (value) { + plugin.settings.disablePopups = value; + plugin.saveSettings(); + }); + }); + new obsidian.Setting(containerEl) + .setName("Show status bar") + .setDesc("Obsidian must be restarted for the changes to take affect") + .addToggle(function (toggle) { + return toggle + .setValue(plugin.settings.showStatusBar) + .onChange(function (value) { + plugin.settings.showStatusBar = value; + plugin.saveSettings(); + }); + }); + }; + return ObsidianGitSettingsTab; +}(obsidian.PluginSettingTab)); +var StatusBar = /** @class */ (function () { + function StatusBar(statusBarEl, plugin) { + this.messages = []; + this.statusBarEl = statusBarEl; + this.plugin = plugin; + } + StatusBar.prototype.displayMessage = function (message, timeout) { + this.messages.push({ + message: "git: " + message.slice(0, 100), + timeout: timeout, + }); + this.display(); + }; + StatusBar.prototype.display = function () { + if (this.messages.length > 0 && !this.currentMessage) { + this.currentMessage = this.messages.shift(); + this.statusBarEl.setText(this.currentMessage.message); + this.lastMessageTimestamp = Date.now(); + } + else if (this.currentMessage) { + var messageAge = Date.now() - this.lastMessageTimestamp; + if (messageAge >= this.currentMessage.timeout) { + this.currentMessage = null; + this.lastMessageTimestamp = null; + } + } + else { + this.displayState(); + } + }; + StatusBar.prototype.displayState = function () { + switch (this.plugin.state) { + case PluginState.idle: + this.displayFromNow(this.plugin.lastUpdate); + break; + case PluginState.status: + this.statusBarEl.setText("git: checking repo status.."); + break; + case PluginState.add: + this.statusBarEl.setText("git: adding files to repo.."); + break; + case PluginState.commit: + this.statusBarEl.setText("git: committing changes.."); + break; + case PluginState.push: + this.statusBarEl.setText("git: pushing changes.."); + break; + case PluginState.pull: + this.statusBarEl.setText("git: pulling changes.."); + break; + case PluginState.conflicted: + this.statusBarEl.setText("git: you have conflict files.."); + break; + default: + this.statusBarEl.setText("git: failed on initialization!"); + break; + } + }; + StatusBar.prototype.displayFromNow = function (timestamp) { + if (timestamp) { + var moment_1 = window.moment; + var fromNow = moment_1(timestamp).fromNow(); + this.statusBarEl.setText("git: last update " + fromNow + ".."); + } + else { + this.statusBarEl.setText("git: ready"); + } + }; + return StatusBar; +}()); +var CustomMessageModal = /** @class */ (function (_super) { + __extends(CustomMessageModal, _super); + function CustomMessageModal(plugin) { + var _this = _super.call(this, plugin.app) || this; + _this.plugin = plugin; + _this.setPlaceholder("Type your message and select optional the version with the added date."); + return _this; + } + CustomMessageModal.prototype.getSuggestions = function (query) { + var date = window.moment().format(this.plugin.settings.commitDateFormat); + if (query == "") + query = "..."; + return [query, date + ": " + query, query + ": " + date]; + }; + CustomMessageModal.prototype.renderSuggestion = function (value, el) { + el.innerText = value; + }; + CustomMessageModal.prototype.onChooseSuggestion = function (item, _) { + var _this = this; + this.plugin.promiseQueue.addTask(function () { return _this.plugin.createBackup(false, item); }); + }; + return CustomMessageModal; +}(obsidian.SuggestModal)); +var ChangedFilesModal = /** @class */ (function (_super) { + __extends(ChangedFilesModal, _super); + function ChangedFilesModal(plugin, changedFiles) { + var _this = _super.call(this, plugin.app) || this; + _this.plugin = plugin; + _this.changedFiles = changedFiles; + _this.setPlaceholder("Not supported files will be opened by default app!"); + return _this; + } + ChangedFilesModal.prototype.getItems = function () { + return this.changedFiles; + }; + ChangedFilesModal.prototype.getItemText = function (item) { + if (item.index == "?" && item.working_dir == "?") { + return "Untracked | " + item.path; + } + var working_dir = ""; + var index = ""; + if (item.working_dir != " ") + working_dir = "Working dir: " + item.working_dir + " "; + if (item.index != " ") + index = "Index: " + item.index; + return "" + working_dir + index + " | " + item.path; + }; + ChangedFilesModal.prototype.onChooseItem = function (item, _) { + if (this.plugin.app.metadataCache.getFirstLinkpathDest(item.path, "") == null) { + this.app.openWithDefaultApp(item.path); + } + else { + this.plugin.app.workspace.openLinkText(item.path, "/"); + } + }; + return ChangedFilesModal; +}(obsidian.FuzzySuggestModal)); +var PromiseQueue = /** @class */ (function () { + function PromiseQueue() { + this.tasks = []; + } + PromiseQueue.prototype.addTask = function (task) { + this.tasks.push(task); + if (this.tasks.length === 1) { + this.handleTask(); + } + }; + PromiseQueue.prototype.handleTask = function () { + return __awaiter(this, void 0, void 0, function () { + var _this = this; + return __generator(this, function (_a) { + if (this.tasks.length > 0) { + this.tasks[0]().finally(function () { + _this.tasks.shift(); + _this.handleTask(); + }); + } + return [2 /*return*/]; + }); + }); + }; + return PromiseQueue; +}()); + +module.exports = ObsidianGit; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","node_modules/simple-git/src/lib/errors/git-error.js","node_modules/simple-git/src/lib/errors/git-response-error.js","node_modules/simple-git/src/lib/errors/git-construct-error.js","node_modules/simple-git/src/lib/errors/git-plugin-error.js","node_modules/simple-git/src/lib/errors/task-configuration-error.js","node_modules/ms/index.js","node_modules/debug/src/common.js","node_modules/debug/src/browser.js","node_modules/has-flag/index.js","node_modules/supports-color/index.js","node_modules/debug/src/node.js","node_modules/debug/src/index.js","node_modules/@kwsites/file-exists/dist/src/index.js","node_modules/@kwsites/file-exists/dist/index.js","node_modules/simple-git/src/lib/utils/util.js","node_modules/simple-git/src/lib/utils/argument-filters.js","node_modules/simple-git/src/lib/utils/exit-codes.js","node_modules/simple-git/src/lib/utils/git-output-streams.js","node_modules/simple-git/src/lib/utils/line-parser.js","node_modules/simple-git/src/lib/utils/simple-git-options.js","node_modules/simple-git/src/lib/utils/task-options.js","node_modules/simple-git/src/lib/utils/task-parser.js","node_modules/simple-git/src/lib/utils/index.js","node_modules/simple-git/src/lib/tasks/check-is-repo.js","node_modules/simple-git/src/lib/responses/CleanSummary.js","node_modules/simple-git/src/lib/tasks/task.js","node_modules/simple-git/src/lib/tasks/clean.js","node_modules/simple-git/src/lib/tasks/reset.js","node_modules/simple-git/src/lib/api.js","node_modules/simple-git/src/lib/plugins/command-config-prefixing-plugin.js","node_modules/simple-git/src/lib/plugins/error-detection.plugin.js","node_modules/simple-git/src/lib/plugins/plugin-store.js","node_modules/simple-git/src/lib/plugins/progress-monitor-plugin.js","node_modules/simple-git/src/lib/plugins/simple-git-plugin.js","node_modules/simple-git/src/lib/plugins/timout-plugin.js","node_modules/simple-git/src/lib/plugins/index.js","node_modules/simple-git/src/lib/git-logger.js","node_modules/simple-git/src/lib/runners/tasks-pending-queue.js","node_modules/simple-git/src/lib/runners/git-executor-chain.js","node_modules/simple-git/src/lib/runners/git-executor.js","node_modules/simple-git/src/lib/task-callback.js","node_modules/simple-git/src/lib/parsers/parse-remote-objects.js","node_modules/simple-git/src/lib/parsers/parse-remote-messages.js","node_modules/simple-git/src/lib/parsers/parse-push.js","node_modules/simple-git/src/lib/tasks/push.js","node_modules/simple-git/src/lib/simple-git-api.js","node_modules/@kwsites/promise-deferred/dist/index.js","node_modules/simple-git/src/lib/runners/scheduler.js","node_modules/simple-git/src/lib/tasks/apply-patch.js","node_modules/simple-git/src/lib/responses/BranchDeleteSummary.js","node_modules/simple-git/src/lib/parsers/parse-branch-delete.js","node_modules/simple-git/src/lib/responses/BranchSummary.js","node_modules/simple-git/src/lib/parsers/parse-branch.js","node_modules/simple-git/src/lib/tasks/branch.js","node_modules/simple-git/src/lib/responses/CheckIgnore.js","node_modules/simple-git/src/lib/tasks/check-ignore.js","node_modules/simple-git/src/lib/tasks/clone.js","node_modules/simple-git/src/lib/responses/ConfigList.js","node_modules/simple-git/src/lib/tasks/config.js","node_modules/simple-git/src/lib/parsers/parse-commit.js","node_modules/simple-git/src/lib/tasks/commit.js","node_modules/simple-git/src/lib/responses/DiffSummary.js","node_modules/simple-git/src/lib/parsers/parse-diff-summary.js","node_modules/simple-git/src/lib/tasks/diff.js","node_modules/simple-git/src/lib/parsers/parse-fetch.js","node_modules/simple-git/src/lib/tasks/fetch.js","node_modules/simple-git/src/lib/tasks/hash-object.js","node_modules/simple-git/src/lib/responses/InitSummary.js","node_modules/simple-git/src/lib/tasks/init.js","node_modules/simple-git/src/lib/parsers/parse-list-log-summary.js","node_modules/simple-git/src/lib/tasks/log.js","node_modules/simple-git/src/lib/responses/MergeSummary.js","node_modules/simple-git/src/lib/responses/PullSummary.js","node_modules/simple-git/src/lib/parsers/parse-pull.js","node_modules/simple-git/src/lib/parsers/parse-merge.js","node_modules/simple-git/src/lib/tasks/merge.js","node_modules/simple-git/src/lib/parsers/parse-move.js","node_modules/simple-git/src/lib/tasks/move.js","node_modules/simple-git/src/lib/tasks/pull.js","node_modules/simple-git/src/lib/responses/GetRemoteSummary.js","node_modules/simple-git/src/lib/tasks/remote.js","node_modules/simple-git/src/lib/tasks/stash-list.js","node_modules/simple-git/src/lib/responses/FileStatusSummary.js","node_modules/simple-git/src/lib/responses/StatusSummary.js","node_modules/simple-git/src/lib/tasks/status.js","node_modules/simple-git/src/lib/tasks/sub-module.js","node_modules/simple-git/src/lib/responses/TagList.js","node_modules/simple-git/src/lib/tasks/tag.js","node_modules/simple-git/src/git.js","node_modules/simple-git/src/lib/git-factory.js","node_modules/simple-git/src/lib/runners/promise-wrapped.js","node_modules/simple-git/src/index.js","main.ts"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GitError = void 0;\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 */\nclass GitError extends Error {\n    constructor(task, message) {\n        super(message);\n        this.task = task;\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\nexports.GitError = GitError;\n//# sourceMappingURL=git-error.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GitResponseError = void 0;\nconst git_error_1 = require(\"./git-error\");\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 */\nclass GitResponseError extends git_error_1.GitError {\n    constructor(\n    /**\n     * `.git` access the parsed response that is treated as being an error\n     */\n    git, message) {\n        super(undefined, message || String(git));\n        this.git = git;\n    }\n}\nexports.GitResponseError = GitResponseError;\n//# sourceMappingURL=git-response-error.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GitConstructError = void 0;\nconst git_error_1 = require(\"./git-error\");\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 */\nclass GitConstructError extends git_error_1.GitError {\n    constructor(config, message) {\n        super(undefined, message);\n        this.config = config;\n    }\n}\nexports.GitConstructError = GitConstructError;\n//# sourceMappingURL=git-construct-error.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GitPluginError = void 0;\nconst git_error_1 = require(\"./git-error\");\nclass GitPluginError extends git_error_1.GitError {\n    constructor(task, plugin, message) {\n        super(task, message);\n        this.task = task;\n        this.plugin = plugin;\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\nexports.GitPluginError = GitPluginError;\n//# sourceMappingURL=git-plugin-error.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.TaskConfigurationError = void 0;\nconst git_error_1 = require(\"./git-error\");\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 */\nclass TaskConfigurationError extends git_error_1.GitError {\n    constructor(message) {\n        super(undefined, message);\n    }\n}\nexports.TaskConfigurationError = TaskConfigurationError;\n//# sourceMappingURL=task-configuration-error.js.map","/**\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 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\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: () => enableOverride === null ? createDebug.enabled(namespace) : enableOverride,\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\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.substr(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","'use strict';\n\nmodule.exports = (flag, argv = process.argv) => {\n\tconst prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');\n\tconst position = argv.indexOf(prefix + flag);\n\tconst terminatorPosition = argv.indexOf('--');\n\treturn position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);\n};\n","'use strict';\nconst os = require('os');\nconst tty = require('tty');\nconst hasFlag = require('has-flag');\n\nconst {env} = process;\n\nlet forceColor;\nif (hasFlag('no-color') ||\n\thasFlag('no-colors') ||\n\thasFlag('color=false') ||\n\thasFlag('color=never')) {\n\tforceColor = 0;\n} else if (hasFlag('color') ||\n\thasFlag('colors') ||\n\thasFlag('color=true') ||\n\thasFlag('color=always')) {\n\tforceColor = 1;\n}\n\nif ('FORCE_COLOR' in env) {\n\tif (env.FORCE_COLOR === 'true') {\n\t\tforceColor = 1;\n\t} else if (env.FORCE_COLOR === 'false') {\n\t\tforceColor = 0;\n\t} else {\n\t\tforceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);\n\t}\n}\n\nfunction translateLevel(level) {\n\tif (level === 0) {\n\t\treturn false;\n\t}\n\n\treturn {\n\t\tlevel,\n\t\thasBasic: true,\n\t\thas256: level >= 2,\n\t\thas16m: level >= 3\n\t};\n}\n\nfunction supportsColor(haveStream, streamIsTTY) {\n\tif (forceColor === 0) {\n\t\treturn 0;\n\t}\n\n\tif (hasFlag('color=16m') ||\n\t\thasFlag('color=full') ||\n\t\thasFlag('color=truecolor')) {\n\t\treturn 3;\n\t}\n\n\tif (hasFlag('color=256')) {\n\t\treturn 2;\n\t}\n\n\tif (haveStream && !streamIsTTY && forceColor === undefined) {\n\t\treturn 0;\n\t}\n\n\tconst min = forceColor || 0;\n\n\tif (env.TERM === 'dumb') {\n\t\treturn min;\n\t}\n\n\tif (process.platform === 'win32') {\n\t\t// Windows 10 build 10586 is the first Windows release that supports 256 colors.\n\t\t// Windows 10 build 14931 is the first release that supports 16m/TrueColor.\n\t\tconst osRelease = os.release().split('.');\n\t\tif (\n\t\t\tNumber(osRelease[0]) >= 10 &&\n\t\t\tNumber(osRelease[2]) >= 10586\n\t\t) {\n\t\t\treturn Number(osRelease[2]) >= 14931 ? 3 : 2;\n\t\t}\n\n\t\treturn 1;\n\t}\n\n\tif ('CI' in env) {\n\t\tif (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {\n\t\t\treturn 1;\n\t\t}\n\n\t\treturn min;\n\t}\n\n\tif ('TEAMCITY_VERSION' in env) {\n\t\treturn /^(9\\.(0*[1-9]\\d*)\\.|\\d{2,}\\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;\n\t}\n\n\tif (env.COLORTERM === 'truecolor') {\n\t\treturn 3;\n\t}\n\n\tif ('TERM_PROGRAM' in env) {\n\t\tconst version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);\n\n\t\tswitch (env.TERM_PROGRAM) {\n\t\t\tcase 'iTerm.app':\n\t\t\t\treturn version >= 3 ? 3 : 2;\n\t\t\tcase 'Apple_Terminal':\n\t\t\t\treturn 2;\n\t\t\t// No default\n\t\t}\n\t}\n\n\tif (/-256(color)?$/i.test(env.TERM)) {\n\t\treturn 2;\n\t}\n\n\tif (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {\n\t\treturn 1;\n\t}\n\n\tif ('COLORTERM' in env) {\n\t\treturn 1;\n\t}\n\n\treturn min;\n}\n\nfunction getSupportLevel(stream) {\n\tconst level = supportsColor(stream, stream && stream.isTTY);\n\treturn translateLevel(level);\n}\n\nmodule.exports = {\n\tsupportsColor: getSupportLevel,\n\tstdout: translateLevel(supportsColor(true, tty.isatty(1))),\n\tstderr: translateLevel(supportsColor(true, tty.isatty(2)))\n};\n","/**\n * Module dependencies.\n */\n\nconst tty = require('tty');\nconst util = require('util');\n\n/**\n * This is the Node.js implementation of `debug()`.\n */\n\nexports.init = init;\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.destroy = util.deprecate(\n\t() => {},\n\t'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'\n);\n\n/**\n * Colors.\n */\n\nexports.colors = [6, 2, 3, 4, 5, 1];\n\ntry {\n\t// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)\n\t// eslint-disable-next-line import/no-extraneous-dependencies\n\tconst supportsColor = require('supports-color');\n\n\tif (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {\n\t\texports.colors = [\n\t\t\t20,\n\t\t\t21,\n\t\t\t26,\n\t\t\t27,\n\t\t\t32,\n\t\t\t33,\n\t\t\t38,\n\t\t\t39,\n\t\t\t40,\n\t\t\t41,\n\t\t\t42,\n\t\t\t43,\n\t\t\t44,\n\t\t\t45,\n\t\t\t56,\n\t\t\t57,\n\t\t\t62,\n\t\t\t63,\n\t\t\t68,\n\t\t\t69,\n\t\t\t74,\n\t\t\t75,\n\t\t\t76,\n\t\t\t77,\n\t\t\t78,\n\t\t\t79,\n\t\t\t80,\n\t\t\t81,\n\t\t\t92,\n\t\t\t93,\n\t\t\t98,\n\t\t\t99,\n\t\t\t112,\n\t\t\t113,\n\t\t\t128,\n\t\t\t129,\n\t\t\t134,\n\t\t\t135,\n\t\t\t148,\n\t\t\t149,\n\t\t\t160,\n\t\t\t161,\n\t\t\t162,\n\t\t\t163,\n\t\t\t164,\n\t\t\t165,\n\t\t\t166,\n\t\t\t167,\n\t\t\t168,\n\t\t\t169,\n\t\t\t170,\n\t\t\t171,\n\t\t\t172,\n\t\t\t173,\n\t\t\t178,\n\t\t\t179,\n\t\t\t184,\n\t\t\t185,\n\t\t\t196,\n\t\t\t197,\n\t\t\t198,\n\t\t\t199,\n\t\t\t200,\n\t\t\t201,\n\t\t\t202,\n\t\t\t203,\n\t\t\t204,\n\t\t\t205,\n\t\t\t206,\n\t\t\t207,\n\t\t\t208,\n\t\t\t209,\n\t\t\t214,\n\t\t\t215,\n\t\t\t220,\n\t\t\t221\n\t\t];\n\t}\n} catch (error) {\n\t// Swallow - we only care if `supports-color` is available; it doesn't have to be.\n}\n\n/**\n * Build up the default `inspectOpts` object from the environment variables.\n *\n *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js\n */\n\nexports.inspectOpts = Object.keys(process.env).filter(key => {\n\treturn /^debug_/i.test(key);\n}).reduce((obj, key) => {\n\t// Camel-case\n\tconst prop = key\n\t\t.substring(6)\n\t\t.toLowerCase()\n\t\t.replace(/_([a-z])/g, (_, k) => {\n\t\t\treturn k.toUpperCase();\n\t\t});\n\n\t// Coerce string value into JS value\n\tlet val = process.env[key];\n\tif (/^(yes|on|true|enabled)$/i.test(val)) {\n\t\tval = true;\n\t} else if (/^(no|off|false|disabled)$/i.test(val)) {\n\t\tval = false;\n\t} else if (val === 'null') {\n\t\tval = null;\n\t} else {\n\t\tval = Number(val);\n\t}\n\n\tobj[prop] = val;\n\treturn obj;\n}, {});\n\n/**\n * Is stdout a TTY? Colored output is enabled when `true`.\n */\n\nfunction useColors() {\n\treturn 'colors' in exports.inspectOpts ?\n\t\tBoolean(exports.inspectOpts.colors) :\n\t\ttty.isatty(process.stderr.fd);\n}\n\n/**\n * Adds ANSI color escape codes if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n\tconst {namespace: name, useColors} = this;\n\n\tif (useColors) {\n\t\tconst c = this.color;\n\t\tconst colorCode = '\\u001B[3' + (c < 8 ? c : '8;5;' + c);\n\t\tconst prefix = `  ${colorCode};1m${name} \\u001B[0m`;\n\n\t\targs[0] = prefix + args[0].split('\\n').join('\\n' + prefix);\n\t\targs.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\\u001B[0m');\n\t} else {\n\t\targs[0] = getDate() + name + ' ' + args[0];\n\t}\n}\n\nfunction getDate() {\n\tif (exports.inspectOpts.hideDate) {\n\t\treturn '';\n\t}\n\treturn new Date().toISOString() + ' ';\n}\n\n/**\n * Invokes `util.format()` with the specified arguments and writes to stderr.\n */\n\nfunction log(...args) {\n\treturn process.stderr.write(util.format(...args) + '\\n');\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\nfunction save(namespaces) {\n\tif (namespaces) {\n\t\tprocess.env.DEBUG = namespaces;\n\t} else {\n\t\t// If you set a process.env field to null or undefined, it gets cast to the\n\t\t// string 'null' or 'undefined'. Just delete instead.\n\t\tdelete process.env.DEBUG;\n\t}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n\treturn process.env.DEBUG;\n}\n\n/**\n * Init logic for `debug` instances.\n *\n * Create a new `inspectOpts` object in case `useColors` is set\n * differently for a particular `debug` instance.\n */\n\nfunction init(debug) {\n\tdebug.inspectOpts = {};\n\n\tconst keys = Object.keys(exports.inspectOpts);\n\tfor (let i = 0; i < keys.length; i++) {\n\t\tdebug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];\n\t}\n}\n\nmodule.exports = require('./common')(exports);\n\nconst {formatters} = module.exports;\n\n/**\n * Map %o to `util.inspect()`, all on a single line.\n */\n\nformatters.o = function (v) {\n\tthis.inspectOpts.colors = this.useColors;\n\treturn util.inspect(v, this.inspectOpts)\n\t\t.split('\\n')\n\t\t.map(str => str.trim())\n\t\t.join(' ');\n};\n\n/**\n * Map %O to `util.inspect()`, allowing multiple lines if needed.\n */\n\nformatters.O = function (v) {\n\tthis.inspectOpts.colors = this.useColors;\n\treturn util.inspect(v, this.inspectOpts);\n};\n","/**\n * Detect Electron renderer / nwjs process, which is node, but we should\n * treat as a browser.\n */\n\nif (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {\n\tmodule.exports = require('./browser.js');\n} else {\n\tmodule.exports = require('./node.js');\n}\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst fs_1 = require(\"fs\");\nconst debug_1 = __importDefault(require(\"debug\"));\nconst log = debug_1.default('@kwsites/file-exists');\nfunction check(path, isFile, isDirectory) {\n    log(`checking %s`, path);\n    try {\n        const stat = fs_1.statSync(path);\n        if (stat.isFile() && isFile) {\n            log(`[OK] path represents a file`);\n            return true;\n        }\n        if (stat.isDirectory() && isDirectory) {\n            log(`[OK] path represents a directory`);\n            return true;\n        }\n        log(`[FAIL] path represents something other than a file or directory`);\n        return false;\n    }\n    catch (e) {\n        if (e.code === 'ENOENT') {\n            log(`[FAIL] path is not accessible: %o`, e);\n            return false;\n        }\n        log(`[FATAL] %o`, e);\n        throw e;\n    }\n}\n/**\n * Synchronous validation of a path existing either as a file or as a directory.\n *\n * @param {string} path The path to check\n * @param {number} type One or both of the exported numeric constants\n */\nfunction exists(path, type = exports.READABLE) {\n    return check(path, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);\n}\nexports.exists = exists;\n/**\n * Constant representing a file\n */\nexports.FILE = 1;\n/**\n * Constant representing a folder\n */\nexports.FOLDER = 2;\n/**\n * Constant representing either a file or a folder\n */\nexports.READABLE = exports.FILE + exports.FOLDER;\n//# sourceMappingURL=index.js.map","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__export(require(\"./src\"));\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.bufferToString = exports.prefixedArray = exports.asNumber = exports.asStringArray = exports.asArray = exports.objectToString = exports.remove = exports.including = exports.append = exports.folderExists = exports.forEachLineWithContent = exports.toLinesWithContent = exports.last = exports.first = exports.splitOn = exports.isUserFunction = exports.asFunction = exports.NOOP = void 0;\nconst file_exists_1 = require(\"@kwsites/file-exists\");\nconst NOOP = () => {\n};\nexports.NOOP = NOOP;\n/**\n * Returns either the source argument when it is a `Function`, or the default\n * `NOOP` function constant\n */\nfunction asFunction(source) {\n    return typeof source === 'function' ? source : exports.NOOP;\n}\nexports.asFunction = asFunction;\n/**\n * Determines whether the supplied argument is both a function, and is not\n * the `NOOP` function.\n */\nfunction isUserFunction(source) {\n    return (typeof source === 'function' && source !== exports.NOOP);\n}\nexports.isUserFunction = isUserFunction;\nfunction splitOn(input, char) {\n    const index = input.indexOf(char);\n    if (index <= 0) {\n        return [input, ''];\n    }\n    return [\n        input.substr(0, index),\n        input.substr(index + 1),\n    ];\n}\nexports.splitOn = splitOn;\nfunction first(input, offset = 0) {\n    return isArrayLike(input) && input.length > offset ? input[offset] : undefined;\n}\nexports.first = first;\nfunction last(input, offset = 0) {\n    if (isArrayLike(input) && input.length > offset) {\n        return input[input.length - 1 - offset];\n    }\n}\nexports.last = last;\nfunction isArrayLike(input) {\n    return !!(input && typeof input.length === 'number');\n}\nfunction toLinesWithContent(input, trimmed = true, separator = '\\n') {\n    return input.split(separator)\n        .reduce((output, line) => {\n        const lineContent = trimmed ? line.trim() : line;\n        if (lineContent) {\n            output.push(lineContent);\n        }\n        return output;\n    }, []);\n}\nexports.toLinesWithContent = toLinesWithContent;\nfunction forEachLineWithContent(input, callback) {\n    return toLinesWithContent(input, true).map(line => callback(line));\n}\nexports.forEachLineWithContent = forEachLineWithContent;\nfunction folderExists(path) {\n    return file_exists_1.exists(path, file_exists_1.FOLDER);\n}\nexports.folderExists = folderExists;\n/**\n * Adds `item` into the `target` `Array` or `Set` when it is not already present and returns the `item`.\n */\nfunction append(target, item) {\n    if (Array.isArray(target)) {\n        if (!target.includes(item)) {\n            target.push(item);\n        }\n    }\n    else {\n        target.add(item);\n    }\n    return item;\n}\nexports.append = append;\n/**\n * Adds `item` into the `target` `Array` when it is not already present and returns the `target`.\n */\nfunction including(target, item) {\n    if (Array.isArray(target) && !target.includes(item)) {\n        target.push(item);\n    }\n    return target;\n}\nexports.including = including;\nfunction remove(target, item) {\n    if (Array.isArray(target)) {\n        const index = target.indexOf(item);\n        if (index >= 0) {\n            target.splice(index, 1);\n        }\n    }\n    else {\n        target.delete(item);\n    }\n    return item;\n}\nexports.remove = remove;\nexports.objectToString = Object.prototype.toString.call.bind(Object.prototype.toString);\nfunction asArray(source) {\n    return Array.isArray(source) ? source : [source];\n}\nexports.asArray = asArray;\nfunction asStringArray(source) {\n    return asArray(source).map(String);\n}\nexports.asStringArray = asStringArray;\nfunction asNumber(source, onNaN = 0) {\n    if (source == null) {\n        return onNaN;\n    }\n    const num = parseInt(source, 10);\n    return isNaN(num) ? onNaN : num;\n}\nexports.asNumber = asNumber;\nfunction prefixedArray(input, prefix) {\n    const output = [];\n    for (let i = 0, max = input.length; i < max; i++) {\n        output.push(prefix, input[i]);\n    }\n    return output;\n}\nexports.prefixedArray = prefixedArray;\nfunction bufferToString(input) {\n    return (Array.isArray(input) ? Buffer.concat(input) : input).toString('utf-8');\n}\nexports.bufferToString = bufferToString;\n//# sourceMappingURL=util.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.filterHasLength = exports.filterFunction = exports.filterPlainObject = exports.filterStringOrStringArray = exports.filterStringArray = exports.filterString = exports.filterPrimitives = exports.filterArray = exports.filterType = void 0;\nconst util_1 = require(\"./util\");\nfunction filterType(input, filter, def) {\n    if (filter(input)) {\n        return input;\n    }\n    return (arguments.length > 2) ? def : undefined;\n}\nexports.filterType = filterType;\nconst filterArray = (input) => {\n    return Array.isArray(input);\n};\nexports.filterArray = filterArray;\nfunction filterPrimitives(input, omit) {\n    return /number|string|boolean/.test(typeof input) && (!omit || !omit.includes((typeof input)));\n}\nexports.filterPrimitives = filterPrimitives;\nconst filterString = (input) => {\n    return typeof input === 'string';\n};\nexports.filterString = filterString;\nconst filterStringArray = (input) => {\n    return Array.isArray(input) && input.every(exports.filterString);\n};\nexports.filterStringArray = filterStringArray;\nconst filterStringOrStringArray = (input) => {\n    return exports.filterString(input) || (Array.isArray(input) && input.every(exports.filterString));\n};\nexports.filterStringOrStringArray = filterStringOrStringArray;\nfunction filterPlainObject(input) {\n    return !!input && util_1.objectToString(input) === '[object Object]';\n}\nexports.filterPlainObject = filterPlainObject;\nfunction filterFunction(input) {\n    return typeof input === 'function';\n}\nexports.filterFunction = filterFunction;\nconst filterHasLength = (input) => {\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};\nexports.filterHasLength = filterHasLength;\n//# sourceMappingURL=argument-filters.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ExitCodes = void 0;\n/**\n * Known process exit codes used by the task parsers to determine whether an error\n * was one they can automatically handle\n */\nvar ExitCodes;\n(function (ExitCodes) {\n    ExitCodes[ExitCodes[\"SUCCESS\"] = 0] = \"SUCCESS\";\n    ExitCodes[ExitCodes[\"ERROR\"] = 1] = \"ERROR\";\n    ExitCodes[ExitCodes[\"UNCLEAN\"] = 128] = \"UNCLEAN\";\n})(ExitCodes = exports.ExitCodes || (exports.ExitCodes = {}));\n//# sourceMappingURL=exit-codes.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GitOutputStreams = void 0;\nclass GitOutputStreams {\n    constructor(stdOut, stdErr) {\n        this.stdOut = stdOut;\n        this.stdErr = stdErr;\n    }\n    asStrings() {\n        return new GitOutputStreams(this.stdOut.toString('utf8'), this.stdErr.toString('utf8'));\n    }\n}\nexports.GitOutputStreams = GitOutputStreams;\n//# sourceMappingURL=git-output-streams.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.RemoteLineParser = exports.LineParser = void 0;\nclass LineParser {\n    constructor(regExp, useMatches) {\n        this.matches = [];\n        this.parse = (line, target) => {\n            this.resetMatches();\n            if (!this._regExp.every((reg, index) => this.addMatch(reg, index, line(index)))) {\n                return false;\n            }\n            return this.useMatches(target, this.prepareMatches()) !== false;\n        };\n        this._regExp = Array.isArray(regExp) ? regExp : [regExp];\n        if (useMatches) {\n            this.useMatches = useMatches;\n        }\n    }\n    // @ts-ignore\n    useMatches(target, match) {\n        throw new Error(`LineParser:useMatches not implemented`);\n    }\n    resetMatches() {\n        this.matches.length = 0;\n    }\n    prepareMatches() {\n        return this.matches;\n    }\n    addMatch(reg, index, line) {\n        const matched = line && reg.exec(line);\n        if (matched) {\n            this.pushMatch(index, matched);\n        }\n        return !!matched;\n    }\n    pushMatch(_index, matched) {\n        this.matches.push(...matched.slice(1));\n    }\n}\nexports.LineParser = LineParser;\nclass RemoteLineParser extends LineParser {\n    addMatch(reg, index, line) {\n        return /^remote:\\s/.test(String(line)) && super.addMatch(reg, index, line);\n    }\n    pushMatch(index, matched) {\n        if (index > 0 || matched.length > 1) {\n            super.pushMatch(index, matched);\n        }\n    }\n}\nexports.RemoteLineParser = RemoteLineParser;\n//# sourceMappingURL=line-parser.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createInstanceConfig = void 0;\nconst defaultOptions = {\n    binary: 'git',\n    maxConcurrentProcesses: 5,\n    config: [],\n};\nfunction createInstanceConfig(...options) {\n    const baseDir = process.cwd();\n    const config = Object.assign(Object.assign({ baseDir }, defaultOptions), ...(options.filter(o => typeof o === 'object' && o)));\n    config.baseDir = config.baseDir || baseDir;\n    return config;\n}\nexports.createInstanceConfig = createInstanceConfig;\n//# sourceMappingURL=simple-git-options.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.trailingFunctionArgument = exports.trailingOptionsArgument = exports.getTrailingOptions = exports.appendTaskOptions = void 0;\nconst argument_filters_1 = require(\"./argument-filters\");\nconst util_1 = require(\"./util\");\nfunction appendTaskOptions(options, commands = []) {\n    if (!argument_filters_1.filterPlainObject(options)) {\n        return commands;\n    }\n    return Object.keys(options).reduce((commands, key) => {\n        const value = options[key];\n        if (argument_filters_1.filterPrimitives(value, ['boolean'])) {\n            commands.push(key + '=' + value);\n        }\n        else {\n            commands.push(key);\n        }\n        return commands;\n    }, commands);\n}\nexports.appendTaskOptions = appendTaskOptions;\nfunction getTrailingOptions(args, initialPrimitive = 0, objectOnly = false) {\n    const command = [];\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    appendTaskOptions(trailingOptionsArgument(args), command);\n    if (!objectOnly) {\n        command.push(...trailingArrayArgument(args));\n    }\n    return command;\n}\nexports.getTrailingOptions = getTrailingOptions;\nfunction trailingArrayArgument(args) {\n    const hasTrailingCallback = typeof util_1.last(args) === 'function';\n    return argument_filters_1.filterType(util_1.last(args, hasTrailingCallback ? 1 : 0), argument_filters_1.filterArray, []);\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 */\nfunction trailingOptionsArgument(args) {\n    const hasTrailingCallback = argument_filters_1.filterFunction(util_1.last(args));\n    return argument_filters_1.filterType(util_1.last(args, hasTrailingCallback ? 1 : 0), argument_filters_1.filterPlainObject);\n}\nexports.trailingOptionsArgument = trailingOptionsArgument;\n/**\n * Returns either the source argument when it is a `Function`, or the default\n * `NOOP` function constant\n */\nfunction trailingFunctionArgument(args, includeNoop = true) {\n    const callback = util_1.asFunction(util_1.last(args));\n    return includeNoop || util_1.isUserFunction(callback) ? callback : undefined;\n}\nexports.trailingFunctionArgument = trailingFunctionArgument;\n//# sourceMappingURL=task-options.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseStringResponse = exports.callTaskParser = void 0;\nconst util_1 = require(\"./util\");\nfunction callTaskParser(parser, streams) {\n    return parser(streams.stdOut, streams.stdErr);\n}\nexports.callTaskParser = callTaskParser;\nfunction parseStringResponse(result, parsers, ...texts) {\n    texts.forEach(text => {\n        for (let lines = util_1.toLinesWithContent(text), 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            parsers.some(({ parse }) => parse(line, result));\n        }\n    });\n    return result;\n}\nexports.parseStringResponse = parseStringResponse;\n//# sourceMappingURL=task-parser.js.map","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__exportStar(require(\"./argument-filters\"), exports);\n__exportStar(require(\"./exit-codes\"), exports);\n__exportStar(require(\"./git-output-streams\"), exports);\n__exportStar(require(\"./line-parser\"), exports);\n__exportStar(require(\"./simple-git-options\"), exports);\n__exportStar(require(\"./task-options\"), exports);\n__exportStar(require(\"./task-parser\"), exports);\n__exportStar(require(\"./util\"), exports);\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.checkIsBareRepoTask = exports.checkIsRepoRootTask = exports.checkIsRepoTask = exports.CheckRepoActions = void 0;\nconst utils_1 = require(\"../utils\");\nvar CheckRepoActions;\n(function (CheckRepoActions) {\n    CheckRepoActions[\"BARE\"] = \"bare\";\n    CheckRepoActions[\"IN_TREE\"] = \"tree\";\n    CheckRepoActions[\"IS_REPO_ROOT\"] = \"root\";\n})(CheckRepoActions = exports.CheckRepoActions || (exports.CheckRepoActions = {}));\nconst onError = ({ exitCode }, error, done, fail) => {\n    if (exitCode === utils_1.ExitCodes.UNCLEAN && isNotRepoMessage(error)) {\n        return done(Buffer.from('false'));\n    }\n    fail(error);\n};\nconst parser = (text) => {\n    return text.trim() === 'true';\n};\nfunction checkIsRepoTask(action) {\n    switch (action) {\n        case CheckRepoActions.BARE:\n            return checkIsBareRepoTask();\n        case CheckRepoActions.IS_REPO_ROOT:\n            return checkIsRepoRootTask();\n    }\n    const commands = ['rev-parse', '--is-inside-work-tree'];\n    return {\n        commands,\n        format: 'utf-8',\n        onError,\n        parser,\n    };\n}\nexports.checkIsRepoTask = checkIsRepoTask;\nfunction checkIsRepoRootTask() {\n    const commands = ['rev-parse', '--git-dir'];\n    return {\n        commands,\n        format: 'utf-8',\n        onError,\n        parser(path) {\n            return /^\\.(git)?$/.test(path.trim());\n        },\n    };\n}\nexports.checkIsRepoRootTask = checkIsRepoRootTask;\nfunction checkIsBareRepoTask() {\n    const commands = ['rev-parse', '--is-bare-repository'];\n    return {\n        commands,\n        format: 'utf-8',\n        onError,\n        parser,\n    };\n}\nexports.checkIsBareRepoTask = checkIsBareRepoTask;\nfunction isNotRepoMessage(error) {\n    return /(Not a git repository|Kein Git-Repository)/i.test(String(error));\n}\n//# sourceMappingURL=check-is-repo.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.cleanSummaryParser = exports.CleanResponse = void 0;\nconst utils_1 = require(\"../utils\");\nclass CleanResponse {\n    constructor(dryRun) {\n        this.dryRun = dryRun;\n        this.paths = [];\n        this.files = [];\n        this.folders = [];\n    }\n}\nexports.CleanResponse = CleanResponse;\nconst removalRegexp = /^[a-z]+\\s*/i;\nconst dryRunRemovalRegexp = /^[a-z]+\\s+[a-z]+\\s*/i;\nconst isFolderRegexp = /\\/$/;\nfunction cleanSummaryParser(dryRun, text) {\n    const summary = new CleanResponse(dryRun);\n    const regexp = dryRun ? dryRunRemovalRegexp : removalRegexp;\n    utils_1.toLinesWithContent(text).forEach(line => {\n        const removed = line.replace(regexp, '');\n        summary.paths.push(removed);\n        (isFolderRegexp.test(removed) ? summary.folders : summary.files).push(removed);\n    });\n    return summary;\n}\nexports.cleanSummaryParser = cleanSummaryParser;\n//# sourceMappingURL=CleanSummary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isEmptyTask = exports.isBufferTask = exports.straightThroughBufferTask = exports.straightThroughStringTask = exports.configurationErrorTask = exports.adhocExecTask = exports.EMPTY_COMMANDS = void 0;\nconst task_configuration_error_1 = require(\"../errors/task-configuration-error\");\nexports.EMPTY_COMMANDS = [];\nfunction adhocExecTask(parser) {\n    return {\n        commands: exports.EMPTY_COMMANDS,\n        format: 'utf-8',\n        parser,\n    };\n}\nexports.adhocExecTask = adhocExecTask;\nfunction configurationErrorTask(error) {\n    return {\n        commands: exports.EMPTY_COMMANDS,\n        format: 'utf-8',\n        parser() {\n            throw typeof error === 'string' ? new task_configuration_error_1.TaskConfigurationError(error) : error;\n        }\n    };\n}\nexports.configurationErrorTask = configurationErrorTask;\nfunction straightThroughStringTask(commands, trimmed = false) {\n    return {\n        commands,\n        format: 'utf-8',\n        parser(text) {\n            return trimmed ? String(text).trim() : text;\n        },\n    };\n}\nexports.straightThroughStringTask = straightThroughStringTask;\nfunction straightThroughBufferTask(commands) {\n    return {\n        commands,\n        format: 'buffer',\n        parser(buffer) {\n            return buffer;\n        },\n    };\n}\nexports.straightThroughBufferTask = straightThroughBufferTask;\nfunction isBufferTask(task) {\n    return task.format === 'buffer';\n}\nexports.isBufferTask = isBufferTask;\nfunction isEmptyTask(task) {\n    return !task.commands.length;\n}\nexports.isEmptyTask = isEmptyTask;\n//# sourceMappingURL=task.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isCleanOptionsArray = exports.cleanTask = exports.cleanWithOptionsTask = exports.CleanOptions = exports.CONFIG_ERROR_UNKNOWN_OPTION = exports.CONFIG_ERROR_MODE_REQUIRED = exports.CONFIG_ERROR_INTERACTIVE_MODE = void 0;\nconst CleanSummary_1 = require(\"../responses/CleanSummary\");\nconst utils_1 = require(\"../utils\");\nconst task_1 = require(\"./task\");\nexports.CONFIG_ERROR_INTERACTIVE_MODE = 'Git clean interactive mode is not supported';\nexports.CONFIG_ERROR_MODE_REQUIRED = 'Git clean mode parameter (\"n\" or \"f\") is required';\nexports.CONFIG_ERROR_UNKNOWN_OPTION = 'Git clean unknown option found in: ';\n/**\n * All supported option switches available for use in a `git.clean` operation\n */\nvar CleanOptions;\n(function (CleanOptions) {\n    CleanOptions[\"DRY_RUN\"] = \"n\";\n    CleanOptions[\"FORCE\"] = \"f\";\n    CleanOptions[\"IGNORED_INCLUDED\"] = \"x\";\n    CleanOptions[\"IGNORED_ONLY\"] = \"X\";\n    CleanOptions[\"EXCLUDING\"] = \"e\";\n    CleanOptions[\"QUIET\"] = \"q\";\n    CleanOptions[\"RECURSIVE\"] = \"d\";\n})(CleanOptions = exports.CleanOptions || (exports.CleanOptions = {}));\nconst CleanOptionValues = new Set(['i', ...utils_1.asStringArray(Object.values(CleanOptions))]);\nfunction cleanWithOptionsTask(mode, customArgs) {\n    const { cleanMode, options, valid } = getCleanOptions(mode);\n    if (!cleanMode) {\n        return task_1.configurationErrorTask(exports.CONFIG_ERROR_MODE_REQUIRED);\n    }\n    if (!valid.options) {\n        return task_1.configurationErrorTask(exports.CONFIG_ERROR_UNKNOWN_OPTION + JSON.stringify(mode));\n    }\n    options.push(...customArgs);\n    if (options.some(isInteractiveMode)) {\n        return task_1.configurationErrorTask(exports.CONFIG_ERROR_INTERACTIVE_MODE);\n    }\n    return cleanTask(cleanMode, options);\n}\nexports.cleanWithOptionsTask = cleanWithOptionsTask;\nfunction cleanTask(mode, customArgs) {\n    const commands = ['clean', `-${mode}`, ...customArgs];\n    return {\n        commands,\n        format: 'utf-8',\n        parser(text) {\n            return CleanSummary_1.cleanSummaryParser(mode === CleanOptions.DRY_RUN, text);\n        }\n    };\n}\nexports.cleanTask = cleanTask;\nfunction isCleanOptionsArray(input) {\n    return Array.isArray(input) && input.every(test => CleanOptionValues.has(test));\n}\nexports.isCleanOptionsArray = isCleanOptionsArray;\nfunction getCleanOptions(input) {\n    let cleanMode;\n    let options = [];\n    let valid = { cleanMode: false, options: true };\n    input.replace(/[^a-z]i/g, '').split('').forEach(char => {\n        if (isCleanMode(char)) {\n            cleanMode = char;\n            valid.cleanMode = true;\n        }\n        else {\n            valid.options = valid.options && isKnownOption(options[options.length] = (`-${char}`));\n        }\n    });\n    return {\n        cleanMode,\n        options,\n        valid,\n    };\n}\nfunction isCleanMode(cleanMode) {\n    return cleanMode === CleanOptions.FORCE || cleanMode === CleanOptions.DRY_RUN;\n}\nfunction isKnownOption(option) {\n    return /^-[a-z]$/i.test(option) && CleanOptionValues.has(option.charAt(1));\n}\nfunction isInteractiveMode(option) {\n    if (/^-[^\\-]/.test(option)) {\n        return option.indexOf('i') > 0;\n    }\n    return option === '--interactive';\n}\n//# sourceMappingURL=clean.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getResetMode = exports.resetTask = exports.ResetMode = void 0;\nconst task_1 = require(\"./task\");\nvar ResetMode;\n(function (ResetMode) {\n    ResetMode[\"MIXED\"] = \"mixed\";\n    ResetMode[\"SOFT\"] = \"soft\";\n    ResetMode[\"HARD\"] = \"hard\";\n    ResetMode[\"MERGE\"] = \"merge\";\n    ResetMode[\"KEEP\"] = \"keep\";\n})(ResetMode = exports.ResetMode || (exports.ResetMode = {}));\nconst ResetModes = Array.from(Object.values(ResetMode));\nfunction resetTask(mode, customArgs) {\n    const commands = ['reset'];\n    if (isValidResetMode(mode)) {\n        commands.push(`--${mode}`);\n    }\n    commands.push(...customArgs);\n    return task_1.straightThroughStringTask(commands);\n}\nexports.resetTask = resetTask;\nfunction getResetMode(mode) {\n    if (isValidResetMode(mode)) {\n        return mode;\n    }\n    switch (typeof mode) {\n        case 'string':\n        case 'undefined':\n            return ResetMode.SOFT;\n    }\n    return;\n}\nexports.getResetMode = getResetMode;\nfunction isValidResetMode(mode) {\n    return ResetModes.includes(mode);\n}\n//# sourceMappingURL=reset.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst git_construct_error_1 = require(\"./errors/git-construct-error\");\nconst git_error_1 = require(\"./errors/git-error\");\nconst git_plugin_error_1 = require(\"./errors/git-plugin-error\");\nconst git_response_error_1 = require(\"./errors/git-response-error\");\nconst task_configuration_error_1 = require(\"./errors/task-configuration-error\");\nconst check_is_repo_1 = require(\"./tasks/check-is-repo\");\nconst clean_1 = require(\"./tasks/clean\");\nconst reset_1 = require(\"./tasks/reset\");\nconst api = {\n    CheckRepoActions: check_is_repo_1.CheckRepoActions,\n    CleanOptions: clean_1.CleanOptions,\n    GitConstructError: git_construct_error_1.GitConstructError,\n    GitError: git_error_1.GitError,\n    GitPluginError: git_plugin_error_1.GitPluginError,\n    GitResponseError: git_response_error_1.GitResponseError,\n    ResetMode: reset_1.ResetMode,\n    TaskConfigurationError: task_configuration_error_1.TaskConfigurationError,\n};\nexports.default = api;\n//# sourceMappingURL=api.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.commandConfigPrefixingPlugin = void 0;\nconst utils_1 = require(\"../utils\");\nfunction commandConfigPrefixingPlugin(configuration) {\n    const prefix = utils_1.prefixedArray(configuration, '-c');\n    return {\n        type: 'spawn.args',\n        action(data) {\n            return [...prefix, ...data];\n        },\n    };\n}\nexports.commandConfigPrefixingPlugin = commandConfigPrefixingPlugin;\n//# sourceMappingURL=command-config-prefixing-plugin.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.errorDetectionPlugin = exports.errorDetectionHandler = void 0;\nconst git_error_1 = require(\"../errors/git-error\");\nfunction isTaskError(result) {\n    return !!(result.exitCode && result.stdErr.length);\n}\nfunction getErrorMessage(result) {\n    return Buffer.concat([...result.stdOut, ...result.stdErr]);\n}\nfunction errorDetectionHandler(overwrite = false, isError = isTaskError, errorMessage = getErrorMessage) {\n    return (error, result) => {\n        if ((!overwrite && error) || !isError(result)) {\n            return error;\n        }\n        return errorMessage(result);\n    };\n}\nexports.errorDetectionHandler = errorDetectionHandler;\nfunction errorDetectionPlugin(config) {\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            if (Buffer.isBuffer(error)) {\n                return { error: new git_error_1.GitError(undefined, error.toString('utf-8')) };\n            }\n            return {\n                error\n            };\n        },\n    };\n}\nexports.errorDetectionPlugin = errorDetectionPlugin;\n//# sourceMappingURL=error-detection.plugin.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.PluginStore = void 0;\nconst utils_1 = require(\"../utils\");\nclass PluginStore {\n    constructor() {\n        this.plugins = new Set();\n    }\n    add(plugin) {\n        const plugins = [];\n        utils_1.asArray(plugin).forEach(plugin => plugin && this.plugins.add(utils_1.append(plugins, plugin)));\n        return () => {\n            plugins.forEach(plugin => this.plugins.delete(plugin));\n        };\n    }\n    exec(type, data, context) {\n        let output = data;\n        const contextual = Object.freeze(Object.create(context));\n        for (const plugin of this.plugins) {\n            if (plugin.type === type) {\n                output = plugin.action(output, contextual);\n            }\n        }\n        return output;\n    }\n}\nexports.PluginStore = PluginStore;\n//# sourceMappingURL=plugin-store.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.progressMonitorPlugin = void 0;\nconst utils_1 = require(\"../utils\");\nfunction progressMonitorPlugin(progress) {\n    const progressCommand = '--progress';\n    const progressMethods = ['checkout', 'clone', 'fetch', 'pull', 'push'];\n    const onProgress = {\n        type: 'spawn.after',\n        action(_data, context) {\n            var _a;\n            if (!context.commands.includes(progressCommand)) {\n                return;\n            }\n            (_a = context.spawned.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (chunk) => {\n                const message = /^([a-zA-Z ]+):\\s*(\\d+)% \\((\\d+)\\/(\\d+)\\)/.exec(chunk.toString('utf8'));\n                if (!message) {\n                    return;\n                }\n                progress({\n                    method: context.method,\n                    stage: progressEventStage(message[1]),\n                    progress: utils_1.asNumber(message[2]),\n                    processed: utils_1.asNumber(message[3]),\n                    total: utils_1.asNumber(message[4]),\n                });\n            });\n        }\n    };\n    const onArgs = {\n        type: 'spawn.args',\n        action(args, context) {\n            if (!progressMethods.includes(context.method)) {\n                return args;\n            }\n            return utils_1.including(args, progressCommand);\n        }\n    };\n    return [onArgs, onProgress];\n}\nexports.progressMonitorPlugin = progressMonitorPlugin;\nfunction progressEventStage(input) {\n    return String(input.toLowerCase().split(' ', 1)) || 'unknown';\n}\n//# sourceMappingURL=progress-monitor-plugin.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n//# sourceMappingURL=simple-git-plugin.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.timeoutPlugin = void 0;\nconst git_plugin_error_1 = require(\"../errors/git-plugin-error\");\nfunction timeoutPlugin({ block }) {\n    if (block > 0) {\n        return {\n            type: 'spawn.after',\n            action(_data, context) {\n                var _a, _b;\n                let timeout;\n                function wait() {\n                    timeout && clearTimeout(timeout);\n                    timeout = setTimeout(kill, block);\n                }\n                function stop() {\n                    var _a, _b;\n                    (_a = context.spawned.stdout) === null || _a === void 0 ? void 0 : _a.off('data', wait);\n                    (_b = context.spawned.stderr) === null || _b === void 0 ? void 0 : _b.off('data', wait);\n                    context.spawned.off('exit', stop);\n                    context.spawned.off('close', stop);\n                }\n                function kill() {\n                    stop();\n                    context.kill(new git_plugin_error_1.GitPluginError(undefined, 'timeout', `block timeout reached`));\n                }\n                (_a = context.spawned.stdout) === null || _a === void 0 ? void 0 : _a.on('data', wait);\n                (_b = context.spawned.stderr) === null || _b === void 0 ? void 0 : _b.on('data', wait);\n                context.spawned.on('exit', stop);\n                context.spawned.on('close', stop);\n                wait();\n            }\n        };\n    }\n}\nexports.timeoutPlugin = timeoutPlugin;\n//# sourceMappingURL=timout-plugin.js.map","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__exportStar(require(\"./command-config-prefixing-plugin\"), exports);\n__exportStar(require(\"./error-detection.plugin\"), exports);\n__exportStar(require(\"./plugin-store\"), exports);\n__exportStar(require(\"./progress-monitor-plugin\"), exports);\n__exportStar(require(\"./simple-git-plugin\"), exports);\n__exportStar(require(\"./timout-plugin\"), exports);\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GitLogger = exports.createLogger = void 0;\nconst debug_1 = require(\"debug\");\nconst utils_1 = require(\"./utils\");\ndebug_1.default.formatters.L = (value) => String(utils_1.filterHasLength(value) ? value.length : '-');\ndebug_1.default.formatters.B = (value) => {\n    if (Buffer.isBuffer(value)) {\n        return value.toString('utf8');\n    }\n    return utils_1.objectToString(value);\n};\nfunction createLog() {\n    return debug_1.default('simple-git');\n}\nfunction prefixedLogger(to, prefix, forward) {\n    if (!prefix || !String(prefix).replace(/\\s*/, '')) {\n        return !forward ? to : (message, ...args) => {\n            to(message, ...args);\n            forward(message, ...args);\n        };\n    }\n    return (message, ...args) => {\n        to(`%s ${message}`, prefix, ...args);\n        if (forward) {\n            forward(message, ...args);\n        }\n    };\n}\nfunction childLoggerName(name, childDebugger, { namespace: parentNamespace }) {\n    if (typeof name === 'string') {\n        return name;\n    }\n    const childNamespace = childDebugger && childDebugger.namespace || '';\n    if (childNamespace.startsWith(parentNamespace)) {\n        return childNamespace.substr(parentNamespace.length + 1);\n    }\n    return childNamespace || parentNamespace;\n}\nfunction createLogger(label, verbose, initialStep, infoDebugger = createLog()) {\n    const labelPrefix = label && `[${label}]` || '';\n    const spawned = [];\n    const debugDebugger = (typeof verbose === 'string') ? infoDebugger.extend(verbose) : verbose;\n    const key = childLoggerName(utils_1.filterType(verbose, utils_1.filterString), debugDebugger, infoDebugger);\n    return step(initialStep);\n    function sibling(name, initial) {\n        return utils_1.append(spawned, createLogger(label, key.replace(/^[^:]+/, name), initial, infoDebugger));\n    }\n    function step(phase) {\n        const stepPrefix = phase && `[${phase}]` || '';\n        const debug = debugDebugger && prefixedLogger(debugDebugger, stepPrefix) || utils_1.NOOP;\n        const info = prefixedLogger(infoDebugger, `${labelPrefix} ${stepPrefix}`, debug);\n        return Object.assign(debugDebugger ? debug : info, {\n            label,\n            sibling,\n            info,\n            step,\n        });\n    }\n}\nexports.createLogger = createLogger;\n/**\n * The `GitLogger` is used by the main `SimpleGit` runner to handle logging\n * any warnings or errors.\n */\nclass GitLogger {\n    constructor(_out = createLog()) {\n        this._out = _out;\n        this.error = prefixedLogger(_out, '[ERROR]');\n        this.warn = prefixedLogger(_out, '[WARN]');\n    }\n    silent(silence = false) {\n        if (silence !== this._out.enabled) {\n            return;\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        // enabling the log\n        if (!silence) {\n            if (hasOff) {\n                utils_1.remove(env, `-${namespace}`);\n            }\n            else {\n                env.push(namespace);\n            }\n        }\n        else {\n            if (hasOn) {\n                utils_1.remove(env, namespace);\n            }\n            else {\n                env.push(`-${namespace}`);\n            }\n        }\n        debug_1.default.enable(env.join(','));\n    }\n}\nexports.GitLogger = GitLogger;\n//# sourceMappingURL=git-logger.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.TasksPendingQueue = void 0;\nconst git_error_1 = require(\"../errors/git-error\");\nconst git_logger_1 = require(\"../git-logger\");\nclass TasksPendingQueue {\n    constructor(logLabel = 'GitExecutor') {\n        this.logLabel = logLabel;\n        this._queue = new Map();\n    }\n    withProgress(task) {\n        return this._queue.get(task);\n    }\n    createProgress(task) {\n        const name = TasksPendingQueue.getName(task.commands[0]);\n        const logger = git_logger_1.createLogger(this.logLabel, name);\n        return {\n            task,\n            logger,\n            name,\n        };\n    }\n    push(task) {\n        const progress = this.createProgress(task);\n        progress.logger('Adding task to the queue, commands = %o', task.commands);\n        this._queue.set(task, progress);\n        return progress;\n    }\n    fatal(err) {\n        for (const [task, { logger }] of Array.from(this._queue.entries())) {\n            if (task === err.task) {\n                logger.info(`Failed %o`, err);\n                logger(`Fatal exception, any as-yet un-started tasks run through this executor will not be attempted`);\n            }\n            else {\n                logger.info(`A fatal exception occurred in a previous task, the queue has been purged: %o`, err.message);\n            }\n            this.complete(task);\n        }\n        if (this._queue.size !== 0) {\n            throw new Error(`Queue size should be zero after fatal: ${this._queue.size}`);\n        }\n    }\n    complete(task) {\n        const progress = this.withProgress(task);\n        if (progress) {\n            this._queue.delete(task);\n        }\n    }\n    attempt(task) {\n        const progress = this.withProgress(task);\n        if (!progress) {\n            throw new git_error_1.GitError(undefined, 'TasksPendingQueue: attempt called for an unknown task');\n        }\n        progress.logger('Starting task');\n        return progress;\n    }\n    static getName(name = 'empty') {\n        return `task:${name}:${++TasksPendingQueue.counter}`;\n    }\n}\nexports.TasksPendingQueue = TasksPendingQueue;\nTasksPendingQueue.counter = 0;\n//# sourceMappingURL=tasks-pending-queue.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GitExecutorChain = void 0;\nconst child_process_1 = require(\"child_process\");\nconst git_error_1 = require(\"../errors/git-error\");\nconst task_1 = require(\"../tasks/task\");\nconst utils_1 = require(\"../utils\");\nconst tasks_pending_queue_1 = require(\"./tasks-pending-queue\");\nclass GitExecutorChain {\n    constructor(_executor, _scheduler, _plugins) {\n        this._executor = _executor;\n        this._scheduler = _scheduler;\n        this._plugins = _plugins;\n        this._chain = Promise.resolve();\n        this._queue = new tasks_pending_queue_1.TasksPendingQueue();\n    }\n    get binary() {\n        return this._executor.binary;\n    }\n    get cwd() {\n        return this._executor.cwd;\n    }\n    get env() {\n        return this._executor.env;\n    }\n    get outputHandler() {\n        return this._executor.outputHandler;\n    }\n    chain() {\n        return this;\n    }\n    push(task) {\n        this._queue.push(task);\n        return this._chain = this._chain.then(() => this.attemptTask(task));\n    }\n    attemptTask(task) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const onScheduleComplete = yield this._scheduler.next();\n            const onQueueComplete = () => this._queue.complete(task);\n            try {\n                const { logger } = this._queue.attempt(task);\n                return yield (task_1.isEmptyTask(task)\n                    ? this.attemptEmptyTask(task, logger)\n                    : this.attemptRemoteTask(task, logger));\n            }\n            catch (e) {\n                throw this.onFatalException(task, e);\n            }\n            finally {\n                onQueueComplete();\n                onScheduleComplete();\n            }\n        });\n    }\n    onFatalException(task, e) {\n        const gitError = (e instanceof git_error_1.GitError) ? Object.assign(e, { task }) : new git_error_1.GitError(task, e && String(e));\n        this._chain = Promise.resolve();\n        this._queue.fatal(gitError);\n        return gitError;\n    }\n    attemptRemoteTask(task, logger) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const args = this._plugins.exec('spawn.args', [...task.commands], pluginContext(task, task.commands));\n            const raw = yield this.gitResponse(task, this.binary, args, this.outputHandler, logger.step('SPAWN'));\n            const outputStreams = yield this.handleTaskData(task, args, raw, logger.step('HANDLE'));\n            logger(`passing response to task's parser as a %s`, task.format);\n            if (task_1.isBufferTask(task)) {\n                return utils_1.callTaskParser(task.parser, outputStreams);\n            }\n            return utils_1.callTaskParser(task.parser, outputStreams.asStrings());\n        });\n    }\n    attemptEmptyTask(task, logger) {\n        return __awaiter(this, void 0, void 0, function* () {\n            logger(`empty task bypassing child process to call to task's parser`);\n            return task.parser();\n        });\n    }\n    handleTaskData(task, args, result, logger) {\n        const { exitCode, rejection, stdOut, stdErr } = result;\n        return new Promise((done, fail) => {\n            logger(`Preparing to handle process response exitCode=%d stdOut=`, exitCode);\n            const { error } = this._plugins.exec('task.error', { error: rejection }, Object.assign(Object.assign({}, pluginContext(task, args)), result));\n            if (error && task.onError) {\n                logger.info(`exitCode=%s handling with custom error handler`);\n                return task.onError(result, error, (newStdOut) => {\n                    logger.info(`custom error handler treated as success`);\n                    logger(`custom error returned a %s`, utils_1.objectToString(newStdOut));\n                    done(new utils_1.GitOutputStreams(Array.isArray(newStdOut) ? Buffer.concat(newStdOut) : newStdOut, Buffer.concat(stdErr)));\n                }, fail);\n            }\n            if (error) {\n                logger.info(`handling as error: exitCode=%s stdErr=%s rejection=%o`, exitCode, stdErr.length, rejection);\n                return fail(error);\n            }\n            logger.info(`retrieving task output complete`);\n            done(new utils_1.GitOutputStreams(Buffer.concat(stdOut), Buffer.concat(stdErr)));\n        });\n    }\n    gitResponse(task, command, args, outputHandler, logger) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const outputLogger = logger.sibling('output');\n            const spawnOptions = {\n                cwd: this.cwd,\n                env: this.env,\n                windowsHide: true,\n            };\n            return new Promise((done) => {\n                const stdOut = [];\n                const stdErr = [];\n                let attempted = false;\n                let rejection;\n                function attemptClose(exitCode, event = 'retry') {\n                    // closing when there is content, terminate immediately\n                    if (attempted || stdErr.length || stdOut.length) {\n                        logger.info(`exitCode=%s event=%s rejection=%o`, exitCode, event, rejection);\n                        done({\n                            stdOut,\n                            stdErr,\n                            exitCode,\n                            rejection,\n                        });\n                        attempted = true;\n                    }\n                    // first attempt at closing but no content yet, wait briefly for the close/exit that may follow\n                    if (!attempted) {\n                        attempted = true;\n                        setTimeout(() => attemptClose(exitCode, 'deferred'), 50);\n                        logger('received %s event before content on stdOut/stdErr', event);\n                    }\n                }\n                logger.info(`%s %o`, command, args);\n                logger('%O', spawnOptions);\n                const spawned = child_process_1.spawn(command, args, spawnOptions);\n                spawned.stdout.on('data', onDataReceived(stdOut, 'stdOut', logger, outputLogger.step('stdOut')));\n                spawned.stderr.on('data', onDataReceived(stdErr, 'stdErr', logger, outputLogger.step('stdErr')));\n                spawned.on('error', onErrorReceived(stdErr, logger));\n                spawned.on('close', (code) => attemptClose(code, 'close'));\n                spawned.on('exit', (code) => attemptClose(code, 'exit'));\n                if (outputHandler) {\n                    logger(`Passing child process stdOut/stdErr to custom outputHandler`);\n                    outputHandler(command, spawned.stdout, spawned.stderr, [...args]);\n                }\n                this._plugins.exec('spawn.after', undefined, Object.assign(Object.assign({}, pluginContext(task, args)), { spawned, kill(reason) {\n                        if (spawned.killed) {\n                            return;\n                        }\n                        rejection = reason;\n                        spawned.kill('SIGINT');\n                    } }));\n            });\n        });\n    }\n}\nexports.GitExecutorChain = GitExecutorChain;\nfunction pluginContext(task, commands) {\n    return {\n        method: utils_1.first(task.commands) || '',\n        commands,\n    };\n}\nfunction onErrorReceived(target, logger) {\n    return (err) => {\n        logger(`[ERROR] child process exception %o`, err);\n        target.push(Buffer.from(String(err.stack), 'ascii'));\n    };\n}\nfunction onDataReceived(target, name, logger, output) {\n    return (buffer) => {\n        logger(`%s received %L bytes`, name, buffer);\n        output(`%B`, buffer);\n        target.push(buffer);\n    };\n}\n//# sourceMappingURL=git-executor-chain.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GitExecutor = void 0;\nconst git_executor_chain_1 = require(\"./git-executor-chain\");\nclass GitExecutor {\n    constructor(binary = 'git', cwd, _scheduler, _plugins) {\n        this.binary = binary;\n        this.cwd = cwd;\n        this._scheduler = _scheduler;\n        this._plugins = _plugins;\n        this._chain = new git_executor_chain_1.GitExecutorChain(this, this._scheduler, this._plugins);\n    }\n    chain() {\n        return new git_executor_chain_1.GitExecutorChain(this, this._scheduler, this._plugins);\n    }\n    push(task) {\n        return this._chain.push(task);\n    }\n}\nexports.GitExecutor = GitExecutor;\n//# sourceMappingURL=git-executor.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.taskCallback = void 0;\nconst git_response_error_1 = require(\"./errors/git-response-error\");\nconst utils_1 = require(\"./utils\");\nfunction taskCallback(task, response, callback = utils_1.NOOP) {\n    const onSuccess = (data) => {\n        callback(null, data);\n    };\n    const onError = (err) => {\n        if ((err === null || err === void 0 ? void 0 : err.task) === task) {\n            if (err instanceof git_response_error_1.GitResponseError) {\n                return callback(addDeprecationNoticeToError(err));\n            }\n            callback(err);\n        }\n    };\n    response.then(onSuccess, onError);\n}\nexports.taskCallback = taskCallback;\nfunction addDeprecationNoticeToError(err) {\n    let log = (name) => {\n        console.warn(`simple-git deprecation notice: accessing GitResponseError.${name} should be GitResponseError.git.${name}, this will no longer be available in version 3`);\n        log = utils_1.NOOP;\n    };\n    return Object.create(err, Object.getOwnPropertyNames(err.git).reduce(descriptorReducer, {}));\n    function descriptorReducer(all, name) {\n        if (name in err) {\n            return all;\n        }\n        all[name] = {\n            enumerable: false,\n            configurable: false,\n            get() {\n                log(name);\n                return err.git[name];\n            },\n        };\n        return all;\n    }\n}\n//# sourceMappingURL=task-callback.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.remoteMessagesObjectParsers = void 0;\nconst utils_1 = require(\"../utils\");\nfunction objectEnumerationResult(remoteMessages) {\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}\nfunction asObjectCount(source) {\n    const count = /^\\s*(\\d+)/.exec(source);\n    const delta = /delta (\\d+)/i.exec(source);\n    return {\n        count: utils_1.asNumber(count && count[1] || '0'),\n        delta: utils_1.asNumber(delta && delta[1] || '0'),\n    };\n}\nexports.remoteMessagesObjectParsers = [\n    new utils_1.RemoteLineParser(/^remote:\\s*(enumerating|counting|compressing) objects: (\\d+),/i, (result, [action, count]) => {\n        const key = action.toLowerCase();\n        const enumeration = objectEnumerationResult(result.remoteMessages);\n        Object.assign(enumeration, { [key]: utils_1.asNumber(count) });\n    }),\n    new utils_1.RemoteLineParser(/^remote:\\s*(enumerating|counting|compressing) objects: \\d+% \\(\\d+\\/(\\d+)\\),/i, (result, [action, count]) => {\n        const key = action.toLowerCase();\n        const enumeration = objectEnumerationResult(result.remoteMessages);\n        Object.assign(enumeration, { [key]: utils_1.asNumber(count) });\n    }),\n    new utils_1.RemoteLineParser(/total ([^,]+), reused ([^,]+), pack-reused (\\d+)/i, (result, [total, reused, packReused]) => {\n        const objects = objectEnumerationResult(result.remoteMessages);\n        objects.total = asObjectCount(total);\n        objects.reused = asObjectCount(reused);\n        objects.packReused = utils_1.asNumber(packReused);\n    }),\n];\n//# sourceMappingURL=parse-remote-objects.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.RemoteMessageSummary = exports.parseRemoteMessages = void 0;\nconst utils_1 = require(\"../utils\");\nconst parse_remote_objects_1 = require(\"./parse-remote-objects\");\nconst parsers = [\n    new utils_1.RemoteLineParser(/^remote:\\s*(.+)$/, (result, [text]) => {\n        result.remoteMessages.all.push(text.trim());\n        return false;\n    }),\n    ...parse_remote_objects_1.remoteMessagesObjectParsers,\n    new utils_1.RemoteLineParser([/create a (?:pull|merge) request/i, /\\s(https?:\\/\\/\\S+)$/], (result, [pullRequestUrl]) => {\n        result.remoteMessages.pullRequestUrl = pullRequestUrl;\n    }),\n    new utils_1.RemoteLineParser([/found (\\d+) vulnerabilities.+\\(([^)]+)\\)/i, /\\s(https?:\\/\\/\\S+)$/], (result, [count, summary, url]) => {\n        result.remoteMessages.vulnerabilities = {\n            count: utils_1.asNumber(count),\n            summary,\n            url,\n        };\n    }),\n];\nfunction parseRemoteMessages(_stdOut, stdErr) {\n    return utils_1.parseStringResponse({ remoteMessages: new RemoteMessageSummary() }, parsers, stdErr);\n}\nexports.parseRemoteMessages = parseRemoteMessages;\nclass RemoteMessageSummary {\n    constructor() {\n        this.all = [];\n    }\n}\nexports.RemoteMessageSummary = RemoteMessageSummary;\n//# sourceMappingURL=parse-remote-messages.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parsePushDetail = exports.parsePushResult = void 0;\nconst utils_1 = require(\"../utils\");\nconst parse_remote_messages_1 = require(\"./parse-remote-messages\");\nfunction pushResultPushedItem(local, remote, status) {\n    const deleted = status.includes('deleted');\n    const tag = status.includes('tag') || /^refs\\/tags/.test(local);\n    const alreadyUpdated = !status.includes('new');\n    return {\n        deleted,\n        tag,\n        branch: !tag,\n        new: !alreadyUpdated,\n        alreadyUpdated,\n        local,\n        remote,\n    };\n}\nconst parsers = [\n    new utils_1.LineParser(/^Pushing to (.+)$/, (result, [repo]) => {\n        result.repo = repo;\n    }),\n    new utils_1.LineParser(/^updating local tracking ref '(.+)'/, (result, [local]) => {\n        result.ref = Object.assign(Object.assign({}, (result.ref || {})), { local });\n    }),\n    new utils_1.LineParser(/^[*-=]\\s+([^:]+):(\\S+)\\s+\\[(.+)]$/, (result, [local, remote, type]) => {\n        result.pushed.push(pushResultPushedItem(local, remote, type));\n    }),\n    new utils_1.LineParser(/^Branch '([^']+)' set up to track remote branch '([^']+)' from '([^']+)'/, (result, [local, remote, remoteName]) => {\n        result.branch = Object.assign(Object.assign({}, (result.branch || {})), { local,\n            remote,\n            remoteName });\n    }),\n    new utils_1.LineParser(/^([^:]+):(\\S+)\\s+([a-z0-9]+)\\.\\.([a-z0-9]+)$/, (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];\nconst parsePushResult = (stdOut, stdErr) => {\n    const pushDetail = exports.parsePushDetail(stdOut, stdErr);\n    const responseDetail = parse_remote_messages_1.parseRemoteMessages(stdOut, stdErr);\n    return Object.assign(Object.assign({}, pushDetail), responseDetail);\n};\nexports.parsePushResult = parsePushResult;\nconst parsePushDetail = (stdOut, stdErr) => {\n    return utils_1.parseStringResponse({ pushed: [] }, parsers, stdOut, stdErr);\n};\nexports.parsePushDetail = parsePushDetail;\n//# sourceMappingURL=parse-push.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.pushTask = exports.pushTagsTask = void 0;\nconst parse_push_1 = require(\"../parsers/parse-push\");\nconst utils_1 = require(\"../utils\");\nfunction pushTagsTask(ref = {}, customArgs) {\n    utils_1.append(customArgs, '--tags');\n    return pushTask(ref, customArgs);\n}\nexports.pushTagsTask = pushTagsTask;\nfunction pushTask(ref = {}, customArgs) {\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    utils_1.remove(commands, '-v');\n    utils_1.append(commands, '--verbose');\n    utils_1.append(commands, '--porcelain');\n    return {\n        commands,\n        format: 'utf-8',\n        parser: parse_push_1.parsePushResult,\n    };\n}\nexports.pushTask = pushTask;\n//# sourceMappingURL=push.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SimpleGitApi = void 0;\nconst task_callback_1 = require(\"./task-callback\");\nconst push_1 = require(\"./tasks/push\");\nconst task_1 = require(\"./tasks/task\");\nconst utils_1 = require(\"./utils\");\nclass SimpleGitApi {\n    constructor(_executor) {\n        this._executor = _executor;\n    }\n    _runTask(task, then) {\n        const chain = this._executor.chain();\n        const promise = chain.push(task);\n        if (then) {\n            task_callback_1.taskCallback(task, promise, then);\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    add(files) {\n        return this._runTask(task_1.straightThroughStringTask(['add', ...utils_1.asArray(files)]), utils_1.trailingFunctionArgument(arguments));\n    }\n    push() {\n        const task = push_1.pushTask({\n            remote: utils_1.filterType(arguments[0], utils_1.filterString),\n            branch: utils_1.filterType(arguments[1], utils_1.filterString),\n        }, utils_1.getTrailingOptions(arguments));\n        return this._runTask(task, utils_1.trailingFunctionArgument(arguments));\n    }\n}\nexports.SimpleGitApi = SimpleGitApi;\n//# sourceMappingURL=simple-git-api.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createDeferred = exports.deferred = void 0;\n/**\n * Creates a new `DeferredPromise`\n *\n * ```typescript\n import {deferred} from '@kwsites/promise-deferred`;\n ```\n */\nfunction deferred() {\n    let done;\n    let fail;\n    let status = 'pending';\n    const promise = new Promise((_done, _fail) => {\n        done = _done;\n        fail = _fail;\n    });\n    return {\n        promise,\n        done(result) {\n            if (status === 'pending') {\n                status = 'resolved';\n                done(result);\n            }\n        },\n        fail(error) {\n            if (status === 'pending') {\n                status = 'rejected';\n                fail(error);\n            }\n        },\n        get fulfilled() {\n            return status !== 'pending';\n        },\n        get status() {\n            return status;\n        },\n    };\n}\nexports.deferred = deferred;\n/**\n * Alias of the exported `deferred` function, to help consumers wanting to use `deferred` as the\n * local variable name rather than the factory import name, without needing to rename on import.\n *\n * ```typescript\n import {createDeferred} from '@kwsites/promise-deferred`;\n ```\n */\nexports.createDeferred = deferred;\n/**\n * Default export allows use as:\n *\n * ```typescript\n import deferred from '@kwsites/promise-deferred`;\n ```\n */\nexports.default = deferred;\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Scheduler = void 0;\nconst utils_1 = require(\"../utils\");\nconst promise_deferred_1 = require(\"@kwsites/promise-deferred\");\nconst git_logger_1 = require(\"../git-logger\");\nconst createScheduledTask = (() => {\n    let id = 0;\n    return () => {\n        id++;\n        const { promise, done } = promise_deferred_1.createDeferred();\n        return {\n            promise,\n            done,\n            id,\n        };\n    };\n})();\nclass Scheduler {\n    constructor(concurrency = 2) {\n        this.concurrency = concurrency;\n        this.logger = git_logger_1.createLogger('', 'scheduler');\n        this.pending = [];\n        this.running = [];\n        this.logger(`Constructed, concurrency=%s`, concurrency);\n    }\n    schedule() {\n        if (!this.pending.length || this.running.length >= this.concurrency) {\n            this.logger(`Schedule attempt ignored, pending=%s running=%s concurrency=%s`, this.pending.length, this.running.length, this.concurrency);\n            return;\n        }\n        const task = utils_1.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            utils_1.remove(this.running, task);\n            this.schedule();\n        });\n    }\n    next() {\n        const { promise, id } = utils_1.append(this.pending, createScheduledTask());\n        this.logger(`Scheduling id=%s`, id);\n        this.schedule();\n        return promise;\n    }\n}\nexports.Scheduler = Scheduler;\n//# sourceMappingURL=scheduler.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.applyPatchTask = void 0;\nconst task_1 = require(\"./task\");\nfunction applyPatchTask(patches, customArgs) {\n    return task_1.straightThroughStringTask(['apply', ...customArgs, ...patches]);\n}\nexports.applyPatchTask = applyPatchTask;\n//# sourceMappingURL=apply-patch.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isSingleBranchDeleteFailure = exports.branchDeletionFailure = exports.branchDeletionSuccess = exports.BranchDeletionBatch = void 0;\nclass BranchDeletionBatch {\n    constructor() {\n        this.all = [];\n        this.branches = {};\n        this.errors = [];\n    }\n    get success() {\n        return !this.errors.length;\n    }\n}\nexports.BranchDeletionBatch = BranchDeletionBatch;\nfunction branchDeletionSuccess(branch, hash) {\n    return {\n        branch, hash, success: true,\n    };\n}\nexports.branchDeletionSuccess = branchDeletionSuccess;\nfunction branchDeletionFailure(branch) {\n    return {\n        branch, hash: null, success: false,\n    };\n}\nexports.branchDeletionFailure = branchDeletionFailure;\nfunction isSingleBranchDeleteFailure(test) {\n    return test.success;\n}\nexports.isSingleBranchDeleteFailure = isSingleBranchDeleteFailure;\n//# sourceMappingURL=BranchDeleteSummary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.hasBranchDeletionError = exports.parseBranchDeletions = void 0;\nconst BranchDeleteSummary_1 = require(\"../responses/BranchDeleteSummary\");\nconst utils_1 = require(\"../utils\");\nconst deleteSuccessRegex = /(\\S+)\\s+\\(\\S+\\s([^)]+)\\)/;\nconst deleteErrorRegex = /^error[^']+'([^']+)'/m;\nconst parsers = [\n    new utils_1.LineParser(deleteSuccessRegex, (result, [branch, hash]) => {\n        const deletion = BranchDeleteSummary_1.branchDeletionSuccess(branch, hash);\n        result.all.push(deletion);\n        result.branches[branch] = deletion;\n    }),\n    new utils_1.LineParser(deleteErrorRegex, (result, [branch]) => {\n        const deletion = BranchDeleteSummary_1.branchDeletionFailure(branch);\n        result.errors.push(deletion);\n        result.all.push(deletion);\n        result.branches[branch] = deletion;\n    }),\n];\nconst parseBranchDeletions = (stdOut, stdErr) => {\n    return utils_1.parseStringResponse(new BranchDeleteSummary_1.BranchDeletionBatch(), parsers, stdOut, stdErr);\n};\nexports.parseBranchDeletions = parseBranchDeletions;\nfunction hasBranchDeletionError(data, processExitCode) {\n    return processExitCode === utils_1.ExitCodes.ERROR && deleteErrorRegex.test(data);\n}\nexports.hasBranchDeletionError = hasBranchDeletionError;\n//# sourceMappingURL=parse-branch-delete.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.BranchSummaryResult = void 0;\nclass BranchSummaryResult {\n    constructor() {\n        this.all = [];\n        this.branches = {};\n        this.current = '';\n        this.detached = false;\n    }\n    push(current, detached, name, commit, label) {\n        if (current) {\n            this.detached = detached;\n            this.current = name;\n        }\n        this.all.push(name);\n        this.branches[name] = {\n            current: current,\n            name: name,\n            commit: commit,\n            label: label\n        };\n    }\n}\nexports.BranchSummaryResult = BranchSummaryResult;\n//# sourceMappingURL=BranchSummary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseBranchSummary = void 0;\nconst BranchSummary_1 = require(\"../responses/BranchSummary\");\nconst utils_1 = require(\"../utils\");\nconst parsers = [\n    new utils_1.LineParser(/^(\\*\\s)?\\((?:HEAD )?detached (?:from|at) (\\S+)\\)\\s+([a-z0-9]+)\\s(.*)$/, (result, [current, name, commit, label]) => {\n        result.push(!!current, true, name, commit, label);\n    }),\n    new utils_1.LineParser(/^(\\*\\s)?(\\S+)\\s+([a-z0-9]+)\\s(.*)$/s, (result, [current, name, commit, label]) => {\n        result.push(!!current, false, name, commit, label);\n    })\n];\nfunction parseBranchSummary(stdOut) {\n    return utils_1.parseStringResponse(new BranchSummary_1.BranchSummaryResult(), parsers, stdOut);\n}\nexports.parseBranchSummary = parseBranchSummary;\n//# sourceMappingURL=parse-branch.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.deleteBranchTask = exports.deleteBranchesTask = exports.branchLocalTask = exports.branchTask = exports.containsDeleteBranchCommand = void 0;\nconst git_response_error_1 = require(\"../errors/git-response-error\");\nconst parse_branch_delete_1 = require(\"../parsers/parse-branch-delete\");\nconst parse_branch_1 = require(\"../parsers/parse-branch\");\nconst utils_1 = require(\"../utils\");\nfunction containsDeleteBranchCommand(commands) {\n    const deleteCommands = ['-d', '-D', '--delete'];\n    return commands.some(command => deleteCommands.includes(command));\n}\nexports.containsDeleteBranchCommand = containsDeleteBranchCommand;\nfunction branchTask(customArgs) {\n    const isDelete = containsDeleteBranchCommand(customArgs);\n    const commands = ['branch', ...customArgs];\n    if (commands.length === 1) {\n        commands.push('-a');\n    }\n    if (!commands.includes('-v')) {\n        commands.splice(1, 0, '-v');\n    }\n    return {\n        format: 'utf-8',\n        commands,\n        parser(stdOut, stdErr) {\n            if (isDelete) {\n                return parse_branch_delete_1.parseBranchDeletions(stdOut, stdErr).all[0];\n            }\n            return parse_branch_1.parseBranchSummary(stdOut);\n        },\n    };\n}\nexports.branchTask = branchTask;\nfunction branchLocalTask() {\n    const parser = parse_branch_1.parseBranchSummary;\n    return {\n        format: 'utf-8',\n        commands: ['branch', '-v'],\n        parser,\n    };\n}\nexports.branchLocalTask = branchLocalTask;\nfunction deleteBranchesTask(branches, forceDelete = false) {\n    return {\n        format: 'utf-8',\n        commands: ['branch', '-v', forceDelete ? '-D' : '-d', ...branches],\n        parser(stdOut, stdErr) {\n            return parse_branch_delete_1.parseBranchDeletions(stdOut, stdErr);\n        },\n        onError({ exitCode, stdOut }, error, done, fail) {\n            if (!parse_branch_delete_1.hasBranchDeletionError(String(error), exitCode)) {\n                return fail(error);\n            }\n            done(stdOut);\n        },\n    };\n}\nexports.deleteBranchesTask = deleteBranchesTask;\nfunction deleteBranchTask(branch, forceDelete = false) {\n    const task = {\n        format: 'utf-8',\n        commands: ['branch', '-v', forceDelete ? '-D' : '-d', branch],\n        parser(stdOut, stdErr) {\n            return parse_branch_delete_1.parseBranchDeletions(stdOut, stdErr).branches[branch];\n        },\n        onError({ exitCode, stdErr, stdOut }, error, _, fail) {\n            if (!parse_branch_delete_1.hasBranchDeletionError(String(error), exitCode)) {\n                return fail(error);\n            }\n            throw new git_response_error_1.GitResponseError(task.parser(utils_1.bufferToString(stdOut), utils_1.bufferToString(stdErr)), String(error));\n        },\n    };\n    return task;\n}\nexports.deleteBranchTask = deleteBranchTask;\n//# sourceMappingURL=branch.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseCheckIgnore = void 0;\n/**\n * Parser for the `check-ignore` command - returns each file as a string array\n */\nconst parseCheckIgnore = (text) => {\n    return text.split(/\\n/g)\n        .map(line => line.trim())\n        .filter(file => !!file);\n};\nexports.parseCheckIgnore = parseCheckIgnore;\n//# sourceMappingURL=CheckIgnore.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.checkIgnoreTask = void 0;\nconst CheckIgnore_1 = require(\"../responses/CheckIgnore\");\nfunction checkIgnoreTask(paths) {\n    return {\n        commands: ['check-ignore', ...paths],\n        format: 'utf-8',\n        parser: CheckIgnore_1.parseCheckIgnore,\n    };\n}\nexports.checkIgnoreTask = checkIgnoreTask;\n//# sourceMappingURL=check-ignore.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.cloneMirrorTask = exports.cloneTask = void 0;\nconst task_1 = require(\"./task\");\nconst utils_1 = require(\"../utils\");\nfunction cloneTask(repo, directory, customArgs) {\n    const commands = ['clone', ...customArgs];\n    if (typeof repo === 'string') {\n        commands.push(repo);\n    }\n    if (typeof directory === 'string') {\n        commands.push(directory);\n    }\n    return task_1.straightThroughStringTask(commands);\n}\nexports.cloneTask = cloneTask;\nfunction cloneMirrorTask(repo, directory, customArgs) {\n    utils_1.append(customArgs, '--mirror');\n    return cloneTask(repo, directory, customArgs);\n}\nexports.cloneMirrorTask = cloneMirrorTask;\n//# sourceMappingURL=clone.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.configListParser = exports.ConfigList = void 0;\nconst utils_1 = require(\"../utils\");\nclass ConfigList {\n    constructor() {\n        this.files = [];\n        this.values = Object.create(null);\n    }\n    get all() {\n        if (!this._all) {\n            this._all = this.files.reduce((all, file) => {\n                return Object.assign(all, this.values[file]);\n            }, {});\n        }\n        return this._all;\n    }\n    addFile(file) {\n        if (!(file in this.values)) {\n            const latest = utils_1.last(this.files);\n            this.values[file] = latest ? Object.create(this.values[latest]) : {};\n            this.files.push(file);\n        }\n        return this.values[file];\n    }\n    addValue(file, key, value) {\n        const values = this.addFile(file);\n        if (!values.hasOwnProperty(key)) {\n            values[key] = value;\n        }\n        else if (Array.isArray(values[key])) {\n            values[key].push(value);\n        }\n        else {\n            values[key] = [values[key], value];\n        }\n        this._all = undefined;\n    }\n}\nexports.ConfigList = ConfigList;\nfunction configListParser(text) {\n    const config = new ConfigList();\n    const lines = text.split('\\0');\n    for (let i = 0, max = lines.length - 1; i < max;) {\n        const file = configFilePath(lines[i++]);\n        const [key, value] = utils_1.splitOn(lines[i++], '\\n');\n        config.addValue(file, key, value);\n    }\n    return config;\n}\nexports.configListParser = configListParser;\nfunction configFilePath(filePath) {\n    return filePath.replace(/^(file):/, '');\n}\n//# sourceMappingURL=ConfigList.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.listConfigTask = exports.addConfigTask = void 0;\nconst ConfigList_1 = require(\"../responses/ConfigList\");\nfunction addConfigTask(key, value, append = false) {\n    const commands = ['config', '--local'];\n    if (append) {\n        commands.push('--add');\n    }\n    commands.push(key, value);\n    return {\n        commands,\n        format: 'utf-8',\n        parser(text) {\n            return text;\n        }\n    };\n}\nexports.addConfigTask = addConfigTask;\nfunction listConfigTask() {\n    return {\n        commands: ['config', '--list', '--show-origin', '--null'],\n        format: 'utf-8',\n        parser(text) {\n            return ConfigList_1.configListParser(text);\n        },\n    };\n}\nexports.listConfigTask = listConfigTask;\n//# sourceMappingURL=config.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseCommitResult = void 0;\nconst utils_1 = require(\"../utils\");\nconst parsers = [\n    new utils_1.LineParser(/\\[([^\\s]+)( \\([^)]+\\))? ([^\\]]+)/, (result, [branch, root, commit]) => {\n        result.branch = branch;\n        result.commit = commit;\n        result.root = !!root;\n    }),\n    new utils_1.LineParser(/\\s*Author:\\s(.+)/i, (result, [author]) => {\n        const parts = author.split('<');\n        const email = parts.pop();\n        if (!email || !email.includes('@')) {\n            return;\n        }\n        result.author = {\n            email: email.substr(0, email.length - 1),\n            name: parts.join('<').trim()\n        };\n    }),\n    new utils_1.LineParser(/(\\d+)[^,]*(?:,\\s*(\\d+)[^,]*)(?:,\\s*(\\d+))/g, (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    new utils_1.LineParser(/^(\\d+)[^,]*(?:,\\s*(\\d+)[^(]+\\(([+-]))?/, (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        }\n        else if (direction === '+') {\n            result.summary.insertions = count;\n        }\n    }),\n];\nfunction parseCommitResult(stdOut) {\n    const result = {\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 utils_1.parseStringResponse(result, parsers, stdOut);\n}\nexports.parseCommitResult = parseCommitResult;\n//# sourceMappingURL=parse-commit.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.commitTask = void 0;\nconst parse_commit_1 = require(\"../parsers/parse-commit\");\nfunction commitTask(message, files, customArgs) {\n    const commands = ['commit'];\n    message.forEach((m) => commands.push('-m', m));\n    commands.push(...files, ...customArgs);\n    return {\n        commands,\n        format: 'utf-8',\n        parser: parse_commit_1.parseCommitResult,\n    };\n}\nexports.commitTask = commitTask;\n//# sourceMappingURL=commit.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DiffSummary = void 0;\n/***\n * The DiffSummary is returned as a response to getting `git().status()`\n */\nclass DiffSummary {\n    constructor() {\n        this.changed = 0;\n        this.deletions = 0;\n        this.insertions = 0;\n        this.files = [];\n    }\n}\nexports.DiffSummary = DiffSummary;\n//# sourceMappingURL=DiffSummary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseDiffResult = void 0;\nconst DiffSummary_1 = require(\"../responses/DiffSummary\");\nfunction parseDiffResult(stdOut) {\n    const lines = stdOut.trim().split('\\n');\n    const status = new DiffSummary_1.DiffSummary();\n    readSummaryLine(status, lines.pop());\n    for (let i = 0, max = lines.length; i < max; i++) {\n        const line = lines[i];\n        textFileChange(line, status) || binaryFileChange(line, status);\n    }\n    return status;\n}\nexports.parseDiffResult = parseDiffResult;\nfunction readSummaryLine(status, summary) {\n    (summary || '')\n        .trim()\n        .split(', ')\n        .forEach(function (text) {\n        const summary = /(\\d+)\\s([a-z]+)/.exec(text);\n        if (!summary) {\n            return;\n        }\n        summaryType(status, summary[2], parseInt(summary[1], 10));\n    });\n}\nfunction summaryType(status, key, value) {\n    const match = (/([a-z]+?)s?\\b/.exec(key));\n    if (!match || !statusUpdate[match[1]]) {\n        return;\n    }\n    statusUpdate[match[1]](status, value);\n}\nconst statusUpdate = {\n    file(status, value) {\n        status.changed = value;\n    },\n    deletion(status, value) {\n        status.deletions = value;\n    },\n    insertion(status, value) {\n        status.insertions = value;\n    }\n};\nfunction textFileChange(input, { files }) {\n    const line = input.trim().match(/^(.+)\\s+\\|\\s+(\\d+)(\\s+[+\\-]+)?$/);\n    if (line) {\n        var alterations = (line[3] || '').trim();\n        files.push({\n            file: line[1].trim(),\n            changes: parseInt(line[2], 10),\n            insertions: alterations.replace(/-/g, '').length,\n            deletions: alterations.replace(/\\+/g, '').length,\n            binary: false\n        });\n        return true;\n    }\n    return false;\n}\nfunction binaryFileChange(input, { files }) {\n    const line = input.match(/^(.+) \\|\\s+Bin ([0-9.]+) -> ([0-9.]+) ([a-z]+)$/);\n    if (line) {\n        files.push({\n            file: line[1].trim(),\n            before: +line[2],\n            after: +line[3],\n            binary: true\n        });\n        return true;\n    }\n    return false;\n}\n//# sourceMappingURL=parse-diff-summary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.diffSummaryTask = void 0;\nconst parse_diff_summary_1 = require(\"../parsers/parse-diff-summary\");\nfunction diffSummaryTask(customArgs) {\n    return {\n        commands: ['diff', '--stat=4096', ...customArgs],\n        format: 'utf-8',\n        parser(stdOut) {\n            return parse_diff_summary_1.parseDiffResult(stdOut);\n        }\n    };\n}\nexports.diffSummaryTask = diffSummaryTask;\n//# sourceMappingURL=diff.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseFetchResult = void 0;\nconst utils_1 = require(\"../utils\");\nconst parsers = [\n    new utils_1.LineParser(/From (.+)$/, (result, [remote]) => {\n        result.remote = remote;\n    }),\n    new utils_1.LineParser(/\\* \\[new branch]\\s+(\\S+)\\s*-> (.+)$/, (result, [name, tracking]) => {\n        result.branches.push({\n            name,\n            tracking,\n        });\n    }),\n    new utils_1.LineParser(/\\* \\[new tag]\\s+(\\S+)\\s*-> (.+)$/, (result, [name, tracking]) => {\n        result.tags.push({\n            name,\n            tracking,\n        });\n    })\n];\nfunction parseFetchResult(stdOut, stdErr) {\n    const result = {\n        raw: stdOut,\n        remote: null,\n        branches: [],\n        tags: [],\n    };\n    return utils_1.parseStringResponse(result, parsers, stdOut, stdErr);\n}\nexports.parseFetchResult = parseFetchResult;\n//# sourceMappingURL=parse-fetch.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.fetchTask = void 0;\nconst parse_fetch_1 = require(\"../parsers/parse-fetch\");\nfunction fetchTask(remote, branch, customArgs) {\n    const commands = ['fetch', ...customArgs];\n    if (remote && branch) {\n        commands.push(remote, branch);\n    }\n    return {\n        commands,\n        format: 'utf-8',\n        parser: parse_fetch_1.parseFetchResult,\n    };\n}\nexports.fetchTask = fetchTask;\n//# sourceMappingURL=fetch.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.hashObjectTask = void 0;\nconst task_1 = require(\"./task\");\n/**\n * Task used by `git.hashObject`\n */\nfunction hashObjectTask(filePath, write) {\n    const commands = ['hash-object', filePath];\n    if (write) {\n        commands.push('-w');\n    }\n    return task_1.straightThroughStringTask(commands, true);\n}\nexports.hashObjectTask = hashObjectTask;\n//# sourceMappingURL=hash-object.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseInit = exports.InitSummary = void 0;\nclass InitSummary {\n    constructor(bare, path, existing, gitDir) {\n        this.bare = bare;\n        this.path = path;\n        this.existing = existing;\n        this.gitDir = gitDir;\n    }\n}\nexports.InitSummary = InitSummary;\nconst initResponseRegex = /^Init.+ repository in (.+)$/;\nconst reInitResponseRegex = /^Rein.+ in (.+)$/;\nfunction parseInit(bare, path, text) {\n    const response = String(text).trim();\n    let result;\n    if ((result = initResponseRegex.exec(response))) {\n        return new InitSummary(bare, path, false, result[1]);\n    }\n    if ((result = reInitResponseRegex.exec(response))) {\n        return new InitSummary(bare, path, true, result[1]);\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    return new InitSummary(bare, path, /^re/i.test(response), gitDir);\n}\nexports.parseInit = parseInit;\n//# sourceMappingURL=InitSummary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.initTask = void 0;\nconst InitSummary_1 = require(\"../responses/InitSummary\");\nconst bareCommand = '--bare';\nfunction hasBareCommand(command) {\n    return command.includes(bareCommand);\n}\nfunction initTask(bare = false, path, customArgs) {\n    const commands = ['init', ...customArgs];\n    if (bare && !hasBareCommand(commands)) {\n        commands.splice(1, 0, bareCommand);\n    }\n    return {\n        commands,\n        format: 'utf-8',\n        parser(text) {\n            return InitSummary_1.parseInit(commands.includes('--bare'), path, text);\n        }\n    };\n}\nexports.initTask = initTask;\n//# sourceMappingURL=init.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createListLogSummaryParser = exports.SPLITTER = exports.COMMIT_BOUNDARY = exports.START_BOUNDARY = void 0;\nconst utils_1 = require(\"../utils\");\nconst parse_diff_summary_1 = require(\"./parse-diff-summary\");\nexports.START_BOUNDARY = 'òòòòòò ';\nexports.COMMIT_BOUNDARY = ' òò';\nexports.SPLITTER = ' ò ';\nconst defaultFieldNames = ['hash', 'date', 'message', 'refs', 'author_name', 'author_email'];\nfunction lineBuilder(tokens, fields) {\n    return fields.reduce((line, field, index) => {\n        line[field] = tokens[index] || '';\n        return line;\n    }, Object.create({ diff: null }));\n}\nfunction createListLogSummaryParser(splitter = exports.SPLITTER, fields = defaultFieldNames) {\n    return function (stdOut) {\n        const all = utils_1.toLinesWithContent(stdOut, true, exports.START_BOUNDARY)\n            .map(function (item) {\n            const lineDetail = item.trim().split(exports.COMMIT_BOUNDARY);\n            const listLogLine = lineBuilder(lineDetail[0].trim().split(splitter), fields);\n            if (lineDetail.length > 1 && !!lineDetail[1].trim()) {\n                listLogLine.diff = parse_diff_summary_1.parseDiffResult(lineDetail[1]);\n            }\n            return listLogLine;\n        });\n        return {\n            all,\n            latest: all.length && all[0] || null,\n            total: all.length,\n        };\n    };\n}\nexports.createListLogSummaryParser = createListLogSummaryParser;\n//# sourceMappingURL=parse-list-log-summary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.logTask = exports.parseLogOptions = void 0;\nconst parse_list_log_summary_1 = require(\"../parsers/parse-list-log-summary\");\nconst utils_1 = require(\"../utils\");\nvar excludeOptions;\n(function (excludeOptions) {\n    excludeOptions[excludeOptions[\"--pretty\"] = 0] = \"--pretty\";\n    excludeOptions[excludeOptions[\"max-count\"] = 1] = \"max-count\";\n    excludeOptions[excludeOptions[\"maxCount\"] = 2] = \"maxCount\";\n    excludeOptions[excludeOptions[\"n\"] = 3] = \"n\";\n    excludeOptions[excludeOptions[\"file\"] = 4] = \"file\";\n    excludeOptions[excludeOptions[\"format\"] = 5] = \"format\";\n    excludeOptions[excludeOptions[\"from\"] = 6] = \"from\";\n    excludeOptions[excludeOptions[\"to\"] = 7] = \"to\";\n    excludeOptions[excludeOptions[\"splitter\"] = 8] = \"splitter\";\n    excludeOptions[excludeOptions[\"symmetric\"] = 9] = \"symmetric\";\n    excludeOptions[excludeOptions[\"multiLine\"] = 10] = \"multiLine\";\n    excludeOptions[excludeOptions[\"strictDate\"] = 11] = \"strictDate\";\n})(excludeOptions || (excludeOptions = {}));\nfunction prettyFormat(format, splitter) {\n    const fields = [];\n    const formatStr = [];\n    Object.keys(format).forEach((field) => {\n        fields.push(field);\n        formatStr.push(String(format[field]));\n    });\n    return [\n        fields, formatStr.join(splitter)\n    ];\n}\nfunction userOptions(input) {\n    const output = Object.assign({}, input);\n    Object.keys(input).forEach(key => {\n        if (key in excludeOptions) {\n            delete output[key];\n        }\n    });\n    return output;\n}\nfunction parseLogOptions(opt = {}, customArgs = []) {\n    const splitter = opt.splitter || parse_list_log_summary_1.SPLITTER;\n    const format = opt.format || {\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: '%aN',\n        author_email: '%ae'\n    };\n    const [fields, formatStr] = prettyFormat(format, splitter);\n    const suffix = [];\n    const command = [\n        `--pretty=format:${parse_list_log_summary_1.START_BOUNDARY}${formatStr}${parse_list_log_summary_1.COMMIT_BOUNDARY}`,\n        ...customArgs,\n    ];\n    const maxCount = opt.n || opt['max-count'] || opt.maxCount;\n    if (maxCount) {\n        command.push(`--max-count=${maxCount}`);\n    }\n    if (opt.from && opt.to) {\n        const rangeOperator = (opt.symmetric !== false) ? '...' : '..';\n        suffix.push(`${opt.from}${rangeOperator}${opt.to}`);\n    }\n    if (opt.file) {\n        suffix.push('--follow', opt.file);\n    }\n    utils_1.appendTaskOptions(userOptions(opt), command);\n    return {\n        fields,\n        splitter,\n        commands: [\n            ...command,\n            ...suffix,\n        ],\n    };\n}\nexports.parseLogOptions = parseLogOptions;\nfunction logTask(splitter, fields, customArgs) {\n    return {\n        commands: ['log', ...customArgs],\n        format: 'utf-8',\n        parser: parse_list_log_summary_1.createListLogSummaryParser(splitter, fields),\n    };\n}\nexports.logTask = logTask;\n//# sourceMappingURL=log.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MergeSummaryDetail = exports.MergeSummaryConflict = void 0;\nclass MergeSummaryConflict {\n    constructor(reason, file = null, meta) {\n        this.reason = reason;\n        this.file = file;\n        this.meta = meta;\n    }\n    toString() {\n        return `${this.file}:${this.reason}`;\n    }\n}\nexports.MergeSummaryConflict = MergeSummaryConflict;\nclass MergeSummaryDetail {\n    constructor() {\n        this.conflicts = [];\n        this.merges = [];\n        this.result = 'success';\n    }\n    get failed() {\n        return this.conflicts.length > 0;\n    }\n    get reason() {\n        return this.result;\n    }\n    toString() {\n        if (this.conflicts.length) {\n            return `CONFLICTS: ${this.conflicts.join(', ')}`;\n        }\n        return 'OK';\n    }\n}\nexports.MergeSummaryDetail = MergeSummaryDetail;\n//# sourceMappingURL=MergeSummary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.PullSummary = void 0;\nclass PullSummary {\n    constructor() {\n        this.remoteMessages = {\n            all: [],\n        };\n        this.created = [];\n        this.deleted = [];\n        this.files = [];\n        this.deletions = {};\n        this.insertions = {};\n        this.summary = {\n            changes: 0,\n            deletions: 0,\n            insertions: 0,\n        };\n    }\n}\nexports.PullSummary = PullSummary;\n//# sourceMappingURL=PullSummary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parsePullResult = exports.parsePullDetail = void 0;\nconst PullSummary_1 = require(\"../responses/PullSummary\");\nconst utils_1 = require(\"../utils\");\nconst parse_remote_messages_1 = require(\"./parse-remote-messages\");\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+ (.+)/;\nconst parsers = [\n    new utils_1.LineParser(FILE_UPDATE_REGEX, (result, [file, insertions, deletions]) => {\n        result.files.push(file);\n        if (insertions) {\n            result.insertions[file] = insertions.length;\n        }\n        if (deletions) {\n            result.deletions[file] = deletions.length;\n        }\n    }),\n    new utils_1.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 utils_1.LineParser(ACTION_REGEX, (result, [action, file]) => {\n        utils_1.append(result.files, file);\n        utils_1.append((action === 'create') ? result.created : result.deleted, file);\n    }),\n];\nconst parsePullDetail = (stdOut, stdErr) => {\n    return utils_1.parseStringResponse(new PullSummary_1.PullSummary(), parsers, stdOut, stdErr);\n};\nexports.parsePullDetail = parsePullDetail;\nconst parsePullResult = (stdOut, stdErr) => {\n    return Object.assign(new PullSummary_1.PullSummary(), exports.parsePullDetail(stdOut, stdErr), parse_remote_messages_1.parseRemoteMessages(stdOut, stdErr));\n};\nexports.parsePullResult = parsePullResult;\n//# sourceMappingURL=parse-pull.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseMergeDetail = exports.parseMergeResult = void 0;\nconst MergeSummary_1 = require(\"../responses/MergeSummary\");\nconst utils_1 = require(\"../utils\");\nconst parse_pull_1 = require(\"./parse-pull\");\nconst parsers = [\n    new utils_1.LineParser(/^Auto-merging\\s+(.+)$/, (summary, [autoMerge]) => {\n        summary.merges.push(autoMerge);\n    }),\n    new utils_1.LineParser(/^CONFLICT\\s+\\((.+)\\): Merge conflict in (.+)$/, (summary, [reason, file]) => {\n        summary.conflicts.push(new MergeSummary_1.MergeSummaryConflict(reason, file));\n    }),\n    new utils_1.LineParser(/^CONFLICT\\s+\\((.+\\/delete)\\): (.+) deleted in (.+) and/, (summary, [reason, file, deleteRef]) => {\n        summary.conflicts.push(new MergeSummary_1.MergeSummaryConflict(reason, file, { deleteRef }));\n    }),\n    new utils_1.LineParser(/^CONFLICT\\s+\\((.+)\\):/, (summary, [reason]) => {\n        summary.conflicts.push(new MergeSummary_1.MergeSummaryConflict(reason, null));\n    }),\n    new utils_1.LineParser(/^Automatic merge failed;\\s+(.+)$/, (summary, [result]) => {\n        summary.result = result;\n    }),\n];\n/**\n * Parse the complete response from `git.merge`\n */\nconst parseMergeResult = (stdOut, stdErr) => {\n    return Object.assign(exports.parseMergeDetail(stdOut, stdErr), parse_pull_1.parsePullResult(stdOut, stdErr));\n};\nexports.parseMergeResult = parseMergeResult;\n/**\n * Parse the merge specific detail (ie: not the content also available in the pull detail) from `git.mnerge`\n * @param stdOut\n */\nconst parseMergeDetail = (stdOut) => {\n    return utils_1.parseStringResponse(new MergeSummary_1.MergeSummaryDetail(), parsers, stdOut);\n};\nexports.parseMergeDetail = parseMergeDetail;\n//# sourceMappingURL=parse-merge.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.mergeTask = void 0;\nconst git_response_error_1 = require(\"../errors/git-response-error\");\nconst parse_merge_1 = require(\"../parsers/parse-merge\");\nconst task_1 = require(\"./task\");\nfunction mergeTask(customArgs) {\n    if (!customArgs.length) {\n        return task_1.configurationErrorTask('Git.merge requires at least one option');\n    }\n    return {\n        commands: ['merge', ...customArgs],\n        format: 'utf-8',\n        parser(stdOut, stdErr) {\n            const merge = parse_merge_1.parseMergeResult(stdOut, stdErr);\n            if (merge.failed) {\n                throw new git_response_error_1.GitResponseError(merge);\n            }\n            return merge;\n        }\n    };\n}\nexports.mergeTask = mergeTask;\n//# sourceMappingURL=merge.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseMoveResult = void 0;\nconst utils_1 = require(\"../utils\");\nconst parsers = [\n    new utils_1.LineParser(/^Renaming (.+) to (.+)$/, (result, [from, to]) => {\n        result.moves.push({ from, to });\n    }),\n];\nfunction parseMoveResult(stdOut) {\n    return utils_1.parseStringResponse({ moves: [] }, parsers, stdOut);\n}\nexports.parseMoveResult = parseMoveResult;\n//# sourceMappingURL=parse-move.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.moveTask = void 0;\nconst parse_move_1 = require(\"../parsers/parse-move\");\nconst utils_1 = require(\"../utils\");\nfunction moveTask(from, to) {\n    return {\n        commands: ['mv', '-v', ...utils_1.asArray(from), to],\n        format: 'utf-8',\n        parser: parse_move_1.parseMoveResult,\n    };\n}\nexports.moveTask = moveTask;\n//# sourceMappingURL=move.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.pullTask = void 0;\nconst parse_pull_1 = require(\"../parsers/parse-pull\");\nfunction pullTask(remote, branch, customArgs) {\n    const commands = ['pull', ...customArgs];\n    if (remote && branch) {\n        commands.splice(1, 0, remote, branch);\n    }\n    return {\n        commands,\n        format: 'utf-8',\n        parser(stdOut, stdErr) {\n            return parse_pull_1.parsePullResult(stdOut, stdErr);\n        }\n    };\n}\nexports.pullTask = pullTask;\n//# sourceMappingURL=pull.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseGetRemotesVerbose = exports.parseGetRemotes = void 0;\nconst utils_1 = require(\"../utils\");\nfunction parseGetRemotes(text) {\n    const remotes = {};\n    forEach(text, ([name]) => remotes[name] = { name });\n    return Object.values(remotes);\n}\nexports.parseGetRemotes = parseGetRemotes;\nfunction parseGetRemotesVerbose(text) {\n    const remotes = {};\n    forEach(text, ([name, url, purpose]) => {\n        if (!remotes.hasOwnProperty(name)) {\n            remotes[name] = {\n                name: name,\n                refs: { fetch: '', push: '' },\n            };\n        }\n        if (purpose && url) {\n            remotes[name].refs[purpose.replace(/[^a-z]/g, '')] = url;\n        }\n    });\n    return Object.values(remotes);\n}\nexports.parseGetRemotesVerbose = parseGetRemotesVerbose;\nfunction forEach(text, handler) {\n    utils_1.forEachLineWithContent(text, (line) => handler(line.split(/\\s+/)));\n}\n//# sourceMappingURL=GetRemoteSummary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.removeRemoteTask = exports.remoteTask = exports.listRemotesTask = exports.getRemotesTask = exports.addRemoteTask = void 0;\nconst GetRemoteSummary_1 = require(\"../responses/GetRemoteSummary\");\nconst task_1 = require(\"./task\");\nfunction addRemoteTask(remoteName, remoteRepo, customArgs = []) {\n    return task_1.straightThroughStringTask(['remote', 'add', ...customArgs, remoteName, remoteRepo]);\n}\nexports.addRemoteTask = addRemoteTask;\nfunction getRemotesTask(verbose) {\n    const commands = ['remote'];\n    if (verbose) {\n        commands.push('-v');\n    }\n    return {\n        commands,\n        format: 'utf-8',\n        parser: verbose ? GetRemoteSummary_1.parseGetRemotesVerbose : GetRemoteSummary_1.parseGetRemotes,\n    };\n}\nexports.getRemotesTask = getRemotesTask;\nfunction listRemotesTask(customArgs = []) {\n    const commands = [...customArgs];\n    if (commands[0] !== 'ls-remote') {\n        commands.unshift('ls-remote');\n    }\n    return task_1.straightThroughStringTask(commands);\n}\nexports.listRemotesTask = listRemotesTask;\nfunction remoteTask(customArgs = []) {\n    const commands = [...customArgs];\n    if (commands[0] !== 'remote') {\n        commands.unshift('remote');\n    }\n    return task_1.straightThroughStringTask(commands);\n}\nexports.remoteTask = remoteTask;\nfunction removeRemoteTask(remoteName) {\n    return task_1.straightThroughStringTask(['remote', 'remove', remoteName]);\n}\nexports.removeRemoteTask = removeRemoteTask;\n//# sourceMappingURL=remote.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.stashListTask = void 0;\nconst parse_list_log_summary_1 = require(\"../parsers/parse-list-log-summary\");\nconst log_1 = require(\"./log\");\nfunction stashListTask(opt = {}, customArgs) {\n    const options = log_1.parseLogOptions(opt);\n    const parser = parse_list_log_summary_1.createListLogSummaryParser(options.splitter, options.fields);\n    return {\n        commands: ['stash', 'list', ...options.commands, ...customArgs],\n        format: 'utf-8',\n        parser,\n    };\n}\nexports.stashListTask = stashListTask;\n//# sourceMappingURL=stash-list.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.FileStatusSummary = exports.fromPathRegex = void 0;\nexports.fromPathRegex = /^(.+) -> (.+)$/;\nclass FileStatusSummary {\n    constructor(path, index, working_dir) {\n        this.path = path;\n        this.index = index;\n        this.working_dir = working_dir;\n        if ('R' === (index + working_dir)) {\n            const detail = exports.fromPathRegex.exec(path) || [null, path, path];\n            this.from = detail[1] || '';\n            this.path = detail[2] || '';\n        }\n    }\n}\nexports.FileStatusSummary = FileStatusSummary;\n//# sourceMappingURL=FileStatusSummary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseStatusSummary = exports.StatusSummary = void 0;\nconst utils_1 = require(\"../utils\");\nconst FileStatusSummary_1 = require(\"./FileStatusSummary\");\n/**\n * The StatusSummary is returned as a response to getting `git().status()`\n */\nclass StatusSummary {\n    constructor() {\n        this.not_added = [];\n        this.conflicted = [];\n        this.created = [];\n        this.deleted = [];\n        this.modified = [];\n        this.renamed = [];\n        /**\n         * All files represented as an array of objects containing the `path` and status in `index` and\n         * in the `working_dir`.\n         */\n        this.files = [];\n        this.staged = [];\n        /**\n         * Number of commits ahead of the tracked branch\n         */\n        this.ahead = 0;\n        /**\n         *Number of commits behind the tracked branch\n         */\n        this.behind = 0;\n        /**\n         * Name of the current branch\n         */\n        this.current = null;\n        /**\n         * Name of the branch being tracked\n         */\n        this.tracking = null;\n    }\n    /**\n     * Gets whether this StatusSummary represents a clean working branch.\n     */\n    isClean() {\n        return !this.files.length;\n    }\n}\nexports.StatusSummary = StatusSummary;\nvar PorcelainFileStatus;\n(function (PorcelainFileStatus) {\n    PorcelainFileStatus[\"ADDED\"] = \"A\";\n    PorcelainFileStatus[\"DELETED\"] = \"D\";\n    PorcelainFileStatus[\"MODIFIED\"] = \"M\";\n    PorcelainFileStatus[\"RENAMED\"] = \"R\";\n    PorcelainFileStatus[\"COPIED\"] = \"C\";\n    PorcelainFileStatus[\"UNMERGED\"] = \"U\";\n    PorcelainFileStatus[\"UNTRACKED\"] = \"?\";\n    PorcelainFileStatus[\"IGNORED\"] = \"!\";\n    PorcelainFileStatus[\"NONE\"] = \" \";\n})(PorcelainFileStatus || (PorcelainFileStatus = {}));\nfunction renamedFile(line) {\n    const detail = /^(.+) -> (.+)$/.exec(line);\n    if (!detail) {\n        return {\n            from: line, to: line\n        };\n    }\n    return {\n        from: String(detail[1]),\n        to: String(detail[2]),\n    };\n}\nfunction parser(indexX, indexY, handler) {\n    return [`${indexX}${indexY}`, handler];\n}\nfunction conflicts(indexX, ...indexY) {\n    return indexY.map(y => parser(indexX, y, (result, file) => utils_1.append(result.conflicted, file)));\n}\nconst parsers = new Map([\n    parser(PorcelainFileStatus.NONE, PorcelainFileStatus.ADDED, (result, file) => utils_1.append(result.created, file)),\n    parser(PorcelainFileStatus.NONE, PorcelainFileStatus.DELETED, (result, file) => utils_1.append(result.deleted, file)),\n    parser(PorcelainFileStatus.NONE, PorcelainFileStatus.MODIFIED, (result, file) => utils_1.append(result.modified, file)),\n    parser(PorcelainFileStatus.ADDED, PorcelainFileStatus.NONE, (result, file) => utils_1.append(result.created, file) && utils_1.append(result.staged, file)),\n    parser(PorcelainFileStatus.ADDED, PorcelainFileStatus.MODIFIED, (result, file) => utils_1.append(result.created, file) && utils_1.append(result.staged, file) && utils_1.append(result.modified, file)),\n    parser(PorcelainFileStatus.DELETED, PorcelainFileStatus.NONE, (result, file) => utils_1.append(result.deleted, file) && utils_1.append(result.staged, file)),\n    parser(PorcelainFileStatus.MODIFIED, PorcelainFileStatus.NONE, (result, file) => utils_1.append(result.modified, file) && utils_1.append(result.staged, file)),\n    parser(PorcelainFileStatus.MODIFIED, PorcelainFileStatus.MODIFIED, (result, file) => utils_1.append(result.modified, file) && utils_1.append(result.staged, file)),\n    parser(PorcelainFileStatus.RENAMED, PorcelainFileStatus.NONE, (result, file) => {\n        utils_1.append(result.renamed, renamedFile(file));\n    }),\n    parser(PorcelainFileStatus.RENAMED, PorcelainFileStatus.MODIFIED, (result, file) => {\n        const renamed = renamedFile(file);\n        utils_1.append(result.renamed, renamed);\n        utils_1.append(result.modified, renamed.to);\n    }),\n    parser(PorcelainFileStatus.UNTRACKED, PorcelainFileStatus.UNTRACKED, (result, file) => utils_1.append(result.not_added, file)),\n    ...conflicts(PorcelainFileStatus.ADDED, PorcelainFileStatus.ADDED, PorcelainFileStatus.UNMERGED),\n    ...conflicts(PorcelainFileStatus.DELETED, PorcelainFileStatus.DELETED, PorcelainFileStatus.UNMERGED),\n    ...conflicts(PorcelainFileStatus.UNMERGED, PorcelainFileStatus.ADDED, PorcelainFileStatus.DELETED, PorcelainFileStatus.UNMERGED),\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            regexResult = aheadReg.exec(line);\n            result.ahead = regexResult && +regexResult[1] || 0;\n            regexResult = behindReg.exec(line);\n            result.behind = regexResult && +regexResult[1] || 0;\n            regexResult = currentReg.exec(line);\n            result.current = regexResult && regexResult[1];\n            regexResult = trackingReg.exec(line);\n            result.tracking = regexResult && regexResult[1];\n            regexResult = onEmptyBranchReg.exec(line);\n            result.current = regexResult && regexResult[1] || result.current;\n        }]\n]);\nconst parseStatusSummary = function (text) {\n    const lines = text.trim().split('\\n');\n    const status = new StatusSummary();\n    for (let i = 0, l = lines.length; i < l; i++) {\n        splitLine(status, lines[i]);\n    }\n    return status;\n};\nexports.parseStatusSummary = parseStatusSummary;\nfunction splitLine(result, lineStr) {\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    function data(index, workingDir, path) {\n        const raw = `${index}${workingDir}`;\n        const handler = parsers.get(raw);\n        if (handler) {\n            handler(result, path);\n        }\n        if (raw !== '##') {\n            result.files.push(new FileStatusSummary_1.FileStatusSummary(path, index, workingDir));\n        }\n    }\n}\n//# sourceMappingURL=StatusSummary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.statusTask = void 0;\nconst StatusSummary_1 = require(\"../responses/StatusSummary\");\nfunction statusTask(customArgs) {\n    return {\n        format: 'utf-8',\n        commands: ['status', '--porcelain', '-b', '-u', ...customArgs],\n        parser(text) {\n            return StatusSummary_1.parseStatusSummary(text);\n        }\n    };\n}\nexports.statusTask = statusTask;\n//# sourceMappingURL=status.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.updateSubModuleTask = exports.subModuleTask = exports.initSubModuleTask = exports.addSubModuleTask = void 0;\nconst task_1 = require(\"./task\");\nfunction addSubModuleTask(repo, path) {\n    return subModuleTask(['add', repo, path]);\n}\nexports.addSubModuleTask = addSubModuleTask;\nfunction initSubModuleTask(customArgs) {\n    return subModuleTask(['init', ...customArgs]);\n}\nexports.initSubModuleTask = initSubModuleTask;\nfunction subModuleTask(customArgs) {\n    const commands = [...customArgs];\n    if (commands[0] !== 'submodule') {\n        commands.unshift('submodule');\n    }\n    return task_1.straightThroughStringTask(commands);\n}\nexports.subModuleTask = subModuleTask;\nfunction updateSubModuleTask(customArgs) {\n    return subModuleTask(['update', ...customArgs]);\n}\nexports.updateSubModuleTask = updateSubModuleTask;\n//# sourceMappingURL=sub-module.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseTagList = exports.TagList = void 0;\nclass TagList {\n    constructor(all, latest) {\n        this.all = all;\n        this.latest = latest;\n    }\n}\nexports.TagList = TagList;\nconst parseTagList = function (data, customSort = false) {\n    const tags = data\n        .split('\\n')\n        .map(trimmed)\n        .filter(Boolean);\n    if (!customSort) {\n        tags.sort(function (tagA, tagB) {\n            const partsA = tagA.split('.');\n            const partsB = tagB.split('.');\n            if (partsA.length === 1 || partsB.length === 1) {\n                return singleSorted(toNumber(partsA[0]), toNumber(partsB[0]));\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                if (diff) {\n                    return diff;\n                }\n            }\n            return 0;\n        });\n    }\n    const latest = customSort ? tags[0] : [...tags].reverse().find((tag) => tag.indexOf('.') >= 0);\n    return new TagList(tags, latest);\n};\nexports.parseTagList = parseTagList;\nfunction singleSorted(a, b) {\n    const aIsNum = isNaN(a);\n    const bIsNum = isNaN(b);\n    if (aIsNum !== bIsNum) {\n        return aIsNum ? 1 : -1;\n    }\n    return aIsNum ? sorted(a, b) : 0;\n}\nfunction sorted(a, b) {\n    return a === b ? 0 : a > b ? 1 : -1;\n}\nfunction trimmed(input) {\n    return input.trim();\n}\nfunction toNumber(input) {\n    if (typeof input === 'string') {\n        return parseInt(input.replace(/^\\D+/g, ''), 10) || 0;\n    }\n    return 0;\n}\n//# sourceMappingURL=TagList.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.addAnnotatedTagTask = exports.addTagTask = exports.tagListTask = void 0;\nconst TagList_1 = require(\"../responses/TagList\");\n/**\n * Task used by `git.tags`\n */\nfunction tagListTask(customArgs = []) {\n    const hasCustomSort = customArgs.some((option) => /^--sort=/.test(option));\n    return {\n        format: 'utf-8',\n        commands: ['tag', '-l', ...customArgs],\n        parser(text) {\n            return TagList_1.parseTagList(text, hasCustomSort);\n        },\n    };\n}\nexports.tagListTask = tagListTask;\n/**\n * Task used by `git.addTag`\n */\nfunction addTagTask(name) {\n    return {\n        format: 'utf-8',\n        commands: ['tag', name],\n        parser() {\n            return { name };\n        }\n    };\n}\nexports.addTagTask = addTagTask;\n/**\n * Task used by `git.addTag`\n */\nfunction addAnnotatedTagTask(name, tagMessage) {\n    return {\n        format: 'utf-8',\n        commands: ['tag', '-a', '-m', tagMessage, name],\n        parser() {\n            return { name };\n        }\n    };\n}\nexports.addAnnotatedTagTask = addAnnotatedTagTask;\n//# sourceMappingURL=tag.js.map","const {GitExecutor} = require('./lib/runners/git-executor');\nconst {SimpleGitApi} = require('./lib/simple-git-api');\n\nconst {Scheduler} = require('./lib/runners/scheduler');\nconst {GitLogger} = require('./lib/git-logger');\nconst {adhocExecTask, configurationErrorTask} = require('./lib/tasks/task');\nconst {\n   NOOP,\n   asArray,\n   filterArray,\n   filterPrimitives,\n   filterString,\n   filterStringOrStringArray,\n   filterType,\n   folderExists,\n   getTrailingOptions,\n   trailingFunctionArgument,\n   trailingOptionsArgument\n} = require('./lib/utils');\nconst {applyPatchTask} = require('./lib/tasks/apply-patch')\nconst {branchTask, branchLocalTask, deleteBranchesTask, deleteBranchTask} = 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 {addConfigTask, listConfigTask} = require('./lib/tasks/config');\nconst {cleanWithOptionsTask, isCleanOptionsArray} = require('./lib/tasks/clean');\nconst {commitTask} = require('./lib/tasks/commit');\nconst {diffSummaryTask} = require('./lib/tasks/diff');\nconst {fetchTask} = require('./lib/tasks/fetch');\nconst {hashObjectTask} = require('./lib/tasks/hash-object');\nconst {initTask} = require('./lib/tasks/init');\nconst {logTask, parseLogOptions} = require('./lib/tasks/log');\nconst {mergeTask} = require('./lib/tasks/merge');\nconst {moveTask} = require(\"./lib/tasks/move\");\nconst {pullTask} = require('./lib/tasks/pull');\nconst {pushTagsTask} = require('./lib/tasks/push');\nconst {addRemoteTask, getRemotesTask, listRemotesTask, remoteTask, removeRemoteTask} = require('./lib/tasks/remote');\nconst {getResetMode, resetTask} = require('./lib/tasks/reset');\nconst {stashListTask} = require('./lib/tasks/stash-list');\nconst {statusTask} = require('./lib/tasks/status');\nconst {addSubModuleTask, initSubModuleTask, subModuleTask, updateSubModuleTask} = 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, options.baseDir,\n      new Scheduler(options.maxConcurrentProcesses), plugins,\n   );\n   this._logger = new GitLogger();\n}\n\n(Git.prototype = Object.create(SimpleGitApi.prototype)).constructor = Git;\n\n/**\n * Logging utility for printing out info or error messages to the user\n * @type {GitLogger}\n * @private\n */\nGit.prototype._logger = null;\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 * Sets the working directory of the subsequent commands.\n */\nGit.prototype.cwd = function (workingDirectory) {\n   const task = (typeof workingDirectory !== 'string')\n      ? configurationErrorTask('Git.cwd: workingDirectory must be supplied as a string')\n      : adhocExecTask(() => {\n         if (!folderExists(workingDirectory)) {\n            throw new Error(`Git.cwd: cannot change to non-directory \"${ workingDirectory }\"`);\n         }\n\n         return (this._executor.cwd = workingDirectory);\n      });\n\n   return this._runTask(task, trailingFunctionArgument(arguments) || NOOP);\n};\n\n/**\n * Sets a handler function to be called whenever a new child process is created, the handler function will be called\n * with the name of the command being run and the stdout & stderr streams used by the ChildProcess.\n *\n * @example\n * require('simple-git')\n *    .outputHandler(function (command, stdout, stderr) {\n *       stdout.pipe(process.stdout);\n *    })\n *    .checkout('https://github.com/user/repo.git');\n *\n * @see https://nodejs.org/api/child_process.html#child_process_class_childprocess\n * @see https://nodejs.org/api/stream.html#stream_class_stream_readable\n * @param {Function} outputHandler\n * @returns {Git}\n */\nGit.prototype.outputHandler = function (outputHandler) {\n   this._executor.outputHandler = outputHandler;\n   return this;\n};\n\n/**\n * Initialize a git repo\n *\n * @param {Boolean} [bare=false]\n * @param {Function} [then]\n */\nGit.prototype.init = function (bare, then) {\n   return this._runTask(\n      initTask(bare === true, this._executor.cwd, getTrailingOptions(arguments)),\n      trailingFunctionArgument(arguments),\n   );\n};\n\n/**\n * Check the status of the local repo\n */\nGit.prototype.status = function () {\n   return this._runTask(\n      statusTask(getTrailingOptions(arguments)),\n      trailingFunctionArgument(arguments),\n   );\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\n/**\n * Stash the local repo\n *\n * @param {Object|Array} [options]\n * @param {Function} [then]\n */\nGit.prototype.stash = function (options, then) {\n   return this._runTask(\n      straightThroughStringTask(['stash', ...getTrailingOptions(arguments)]),\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/**\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 * Commits changes in the current working directory - when specific file paths are supplied, only changes on those\n * files will be committed.\n *\n * @param {string|string[]} message\n * @param {string|string[]} [files]\n * @param {Object} [options]\n * @param {Function} [then]\n */\nGit.prototype.commit = function (message, files, options, then) {\n   const next = trailingFunctionArgument(arguments);\n   const messages = [];\n\n   if (filterStringOrStringArray(message)) {\n      messages.push(...asArray(message));\n   } else {\n      console.warn('simple-git deprecation notice: git.commit: requires the commit message to be supplied as a string/string[], this will be an error in version 3');\n   }\n\n   return this._runTask(\n      commitTask(\n         messages,\n         asArray(filterType(files, filterStringOrStringArray, [])),\n         [...filterType(options, filterArray, []), ...getTrailingOptions(arguments, 0, true)]\n      ),\n      next\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(filterType(remote, filterString), filterType(branch, filterString), getTrailingOptions(arguments)),\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(filterType(remote, filterString), filterType(branch, filterString), getTrailingOptions(arguments)),\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('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   this._logger.silent(!!silence);\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(\n         configurationErrorTask('Commit must be a string'),\n         next,\n      );\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 = (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 * Check out a tag or revision, any number of additional arguments can be passed to the `git checkout` command\n * by supplying either a string or array of strings as the first argument.\n */\nGit.prototype.checkout = function () {\n   const commands = ['checkout', ...getTrailingOptions(arguments, true)];\n   return this._runTask(\n      straightThroughStringTask(commands),\n      trailingFunctionArgument(arguments),\n   );\n};\n\n/**\n * Check out a remote branch\n *\n * @param {string} branchName name of branch\n * @param {string} startPoint (e.g origin/development)\n * @param {Function} [then]\n */\nGit.prototype.checkoutBranch = function (branchName, startPoint, then) {\n   return this.checkout(['-b', branchName, startPoint], trailingFunctionArgument(arguments));\n};\n\n/**\n * Check out a local branch\n */\nGit.prototype.checkoutLocalBranch = function (branchName, then) {\n   return this.checkout(['-b', branchName], trailingFunctionArgument(arguments));\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(\n      branchLocalTask(),\n      trailingFunctionArgument(arguments),\n   );\n};\n\n/**\n * Add config to local git instance\n *\n * @param {string} key configuration key (e.g user.name)\n * @param {string} value for the given key (e.g your name)\n * @param {boolean} [append=false] optionally append the key/value pair (equivalent of passing `--add` option).\n * @param {Function} [then]\n */\nGit.prototype.addConfig = function (key, value, append, then) {\n   return this._runTask(\n      addConfigTask(key, value, typeof append === \"boolean\" ? append : false),\n      trailingFunctionArgument(arguments),\n   );\n};\n\nGit.prototype.listConfig = function () {\n   return this._runTask(listConfigTask(), 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(\n      ...getTrailingOptions(arguments, 0, true),\n   );\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), next);\n};\n\nGit.prototype.submoduleAdd = function (repo, path, then) {\n   return this._runTask(\n      addSubModuleTask(repo, path),\n      trailingFunctionArgument(arguments),\n   );\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(\n      removeRemoteTask(remoteName),\n      trailingFunctionArgument(arguments),\n   );\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(\n      getRemotesTask(verbose === true),\n      trailingFunctionArgument(arguments),\n   );\n};\n\n/**\n * Compute object ID from a file\n */\nGit.prototype.hashObject = function (path, write) {\n   return this._runTask(\n      hashObjectTask(path, write === true),\n      trailingFunctionArgument(arguments),\n   );\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 * Merges from one branch to another, equivalent to running `git merge ${from} $[to}`, the `options` argument can\n * either be an array of additional parameters to pass to the command or null / omitted to be ignored.\n *\n * @param {string} from\n * @param {string} to\n */\nGit.prototype.mergeFromTo = function (from, to) {\n   if (!(filterString(from) && filterString(to))) {\n      return this._runTask(configurationErrorTask(\n         `Git.mergeFromTo requires that the 'from' and 'to' arguments are supplied as strings`\n      ));\n   }\n\n   return this._runTask(\n      mergeTask([from, to, ...getTrailingOptions(arguments)]),\n      trailingFunctionArgument(arguments, false),\n   );\n};\n\n/**\n * Runs a merge, `options` can be either an array of arguments\n * supported by the [`git merge`](https://git-scm.com/docs/git-merge)\n * or an options object.\n *\n * Conflicts during the merge result in an error response,\n * the response type whether it was an error or success will be a MergeSummary instance.\n * When successful, the MergeSummary has all detail from a the PullSummary\n *\n * @param {Object | string[]} [options]\n * @param {Function} [then]\n * @returns {*}\n *\n * @see ./responses/MergeSummary.js\n * @see ./responses/PullSummary.js\n */\nGit.prototype.merge = function () {\n   return this._runTask(\n      mergeTask(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(\n      straightThroughStringTask(command),\n      trailingFunctionArgument(arguments)\n   );\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({remote: filterType(remote, filterString)}, getTrailingOptions(arguments));\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 = format === 'buffer'\n      ? straightThroughBufferTask(command)\n      : straightThroughStringTask(command);\n\n   return this._runTask(task, handler);\n};\n\nGit.prototype.diff = function (options, then) {\n   const command = ['diff', ...getTrailingOptions(arguments)];\n\n   if (typeof options === 'string') {\n      command.splice(1, 0, options);\n      this._logger.warn('Git#diff: supplying options as a single string is now deprecated, switch to an array of strings');\n   }\n\n   return this._runTask(\n      straightThroughStringTask(command),\n      trailingFunctionArgument(arguments),\n   );\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(`git.applyPatch requires one or more string patches as the first argument`)\n      : applyPatchTask(asArray(patches), getTrailingOptions([].slice.call(arguments, 1)));\n\n   return this._runTask(\n      task,\n      trailingFunctionArgument(arguments),\n   );\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 * Show various types of objects, for example the file at a certain commit\n *\n * @param {string[]} [options]\n * @param {Function} [then]\n */\nGit.prototype.show = function (options, then) {\n   return this._runTask(\n      straightThroughStringTask(['show', ...getTrailingOptions(arguments, 1)]),\n      trailingFunctionArgument(arguments)\n   );\n};\n\n/**\n */\nGit.prototype.clean = function (mode, options, then) {\n   const usingCleanOptionsArray = isCleanOptionsArray(mode);\n   const cleanMode = 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\n/**\n * Call a simple function at the next step in the chain.\n * @param {Function} [then]\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 * Show commit logs from `HEAD` to the first commit.\n * If provided between `options.from` and `options.to` tags or branch.\n *\n * Additionally you can provide options.file, which is the path to a file in your repository. Then only this file will be considered.\n *\n * To use a custom splitter in the log format, set `options.splitter` to be the string the log should be split on.\n *\n * Options can also be supplied as a standard options object for adding custom properties supported by the git log command.\n * For any other set of options, supply options as an array of strings to be appended to the git log command.\n */\nGit.prototype.log = function (options) {\n   const next = trailingFunctionArgument(arguments);\n\n   if (filterString(arguments[0]) && filterString(arguments[1])) {\n      return this._runTask(\n         configurationErrorTask(`git.log(string, string) should be replaced with git.log({ from: string, to: string })`),\n         next\n      );\n   }\n\n   const parsedOptions = parseLogOptions(\n      trailingOptionsArgument(arguments) || {},\n      filterArray(options) && options || []\n   );\n\n   return this._runTask(\n      logTask(parsedOptions.splitter, parsedOptions.fields, parsedOptions.commands),\n      next,\n   )\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","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.gitInstanceFactory = exports.gitExportFactory = exports.esModuleFactory = void 0;\nconst api_1 = require(\"./api\");\nconst plugins_1 = require(\"./plugins\");\nconst utils_1 = require(\"./utils\");\nconst Git = require('../git');\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 */\nfunction esModuleFactory(defaultExport) {\n    return Object.defineProperties(defaultExport, {\n        __esModule: { value: true },\n        default: { value: defaultExport },\n    });\n}\nexports.esModuleFactory = esModuleFactory;\nfunction gitExportFactory(factory, extra) {\n    return Object.assign(function (...args) {\n        return factory.apply(null, args);\n    }, api_1.default, extra || {});\n}\nexports.gitExportFactory = gitExportFactory;\nfunction gitInstanceFactory(baseDir, options) {\n    const plugins = new plugins_1.PluginStore();\n    const config = utils_1.createInstanceConfig(baseDir && (typeof baseDir === 'string' ? { baseDir } : baseDir) || {}, options);\n    if (!utils_1.folderExists(config.baseDir)) {\n        throw new api_1.default.GitConstructError(config, `Cannot use simple-git on a directory that does not exist`);\n    }\n    if (Array.isArray(config.config)) {\n        plugins.add(plugins_1.commandConfigPrefixingPlugin(config.config));\n    }\n    config.progress && plugins.add(plugins_1.progressMonitorPlugin(config.progress));\n    config.timeout && plugins.add(plugins_1.timeoutPlugin(config.timeout));\n    plugins.add(plugins_1.errorDetectionPlugin(plugins_1.errorDetectionHandler(true)));\n    config.errors && plugins.add(plugins_1.errorDetectionPlugin(config.errors));\n    return new Git(config, plugins);\n}\nexports.gitInstanceFactory = gitInstanceFactory;\n//# sourceMappingURL=git-factory.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.gitP = void 0;\nconst git_response_error_1 = require(\"../errors/git-response-error\");\nconst git_factory_1 = require(\"../git-factory\");\nconst functionNamesBuilderApi = [\n    '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];\nfunction gitP(...args) {\n    let git;\n    let chain = Promise.resolve();\n    try {\n        git = git_factory_1.gitInstanceFactory(...args);\n    }\n    catch (e) {\n        chain = Promise.reject(e);\n    }\n    function builderReturn() {\n        return promiseApi;\n    }\n    function chainReturn() {\n        return chain;\n    }\n    const promiseApi = [...functionNamesBuilderApi, ...functionNamesPromiseApi].reduce((api, name) => {\n        const isAsync = functionNamesPromiseApi.includes(name);\n        const valid = isAsync ? asyncWrapper(name, git) : syncWrapper(name, git, api);\n        const alternative = isAsync ? chainReturn : builderReturn;\n        Object.defineProperty(api, name, {\n            enumerable: false,\n            configurable: false,\n            value: git ? valid : alternative,\n        });\n        return api;\n    }, {});\n    return promiseApi;\n    function asyncWrapper(fn, git) {\n        return function (...args) {\n            if (typeof args[args.length] === 'function') {\n                throw new TypeError('Promise interface requires that handlers are not supplied inline, ' +\n                    'trailing function not allowed in call to ' + fn);\n            }\n            return chain.then(function () {\n                return new Promise(function (resolve, reject) {\n                    const callback = (err, result) => {\n                        if (err) {\n                            return reject(toError(err));\n                        }\n                        resolve(result);\n                    };\n                    args.push(callback);\n                    git[fn].apply(git, args);\n                });\n            });\n        };\n    }\n    function syncWrapper(fn, git, api) {\n        return (...args) => {\n            git[fn](...args);\n            return api;\n        };\n    }\n}\nexports.gitP = gitP;\nfunction toError(error) {\n    if (error instanceof Error) {\n        return error;\n    }\n    if (typeof error === 'string') {\n        return new Error(error);\n    }\n    return new git_response_error_1.GitResponseError(error);\n}\n//# sourceMappingURL=promise-wrapped.js.map","\nconst {gitP} = require('./lib/runners/promise-wrapped');\nconst {esModuleFactory, gitInstanceFactory, gitExportFactory} = require('./lib/git-factory');\n\nmodule.exports = esModuleFactory(\n   gitExportFactory(gitInstanceFactory, {gitP})\n);\n","import { spawnSync } from \"child_process\";\nimport { FileSystemAdapter, FuzzySuggestModal, Notice, Plugin, PluginSettingTab, Setting, SuggestModal, TFile } from \"obsidian\";\nimport simpleGit, { FileStatusResult, SimpleGit } from \"simple-git\";\n\nenum PluginState {\n    idle,\n    status,\n    pull,\n    add,\n    commit,\n    push,\n    conflicted,\n}\ninterface ObsidianGitSettings {\n    commitMessage: string;\n    commitDateFormat: string;\n    autoSaveInterval: number;\n    autoPullInterval: number;\n    autoPullOnBoot: boolean;\n    disablePush: boolean;\n    pullBeforePush: boolean;\n    disablePopups: boolean;\n    listChangedFilesInMessageBody: boolean;\n    showStatusBar: boolean;\n    lastAutoBackUp: string;\n    lastAutoPull: string;\n}\nconst DEFAULT_SETTINGS: ObsidianGitSettings = {\n    commitMessage: \"vault backup: {{date}}\",\n    commitDateFormat: \"YYYY-MM-DD HH:mm:ss\",\n    autoSaveInterval: 0,\n    autoPullInterval: 0,\n    autoPullOnBoot: false,\n    disablePush: false,\n    pullBeforePush: true,\n    disablePopups: false,\n    listChangedFilesInMessageBody: false,\n    showStatusBar: true,\n    lastAutoBackUp: \"\",\n    lastAutoPull: \"\"\n};\n\nexport default class ObsidianGit extends Plugin {\n    git: SimpleGit;\n    settings: ObsidianGitSettings;\n    statusBar: StatusBar;\n    state: PluginState;\n    timeoutIDBackup: number;\n    timeoutIDPull: number;\n    lastUpdate: number;\n    gitReady = false;\n    promiseQueue: PromiseQueue = new PromiseQueue();\n    conflictOutputFile = \"conflict-files-obsidian-git.md\";\n\n    setState(state: PluginState) {\n        this.state = state;\n        this.statusBar?.display();\n    }\n\n    async onload() {\n        console.log('loading ' + this.manifest.name + \" plugin\");\n        await this.loadSettings();\n\n        this.addSettingTab(new ObsidianGitSettingsTab(this.app, this));\n\n        this.addCommand({\n            id: \"pull\",\n            name: \"Pull from remote repository\",\n            callback: () => this.promiseQueue.addTask(() => this.pullChangesFromRemote()),\n        });\n\n        this.addCommand({\n            id: \"push\",\n            name: \"Commit *all* changes and push to remote repository\",\n            callback: () => this.promiseQueue.addTask(() => this.createBackup(false))\n        });\n\n        this.addCommand({\n            id: \"commit-push-specified-message\",\n            name: \"Commit and push all changes with specified message\",\n            callback: () => new CustomMessageModal(this).open()\n        });\n\n        this.addCommand({\n            id: \"list-changed-files\",\n            name: \"List changed files\",\n            callback: async () => {\n                const status = await this.git.status();\n                new ChangedFilesModal(this, status.files).open();\n            }\n        });\n        if (this.settings.showStatusBar) {\n            // init statusBar\n            let statusBarEl = this.addStatusBarItem();\n            this.statusBar = new StatusBar(statusBarEl, this);\n            this.registerInterval(\n                window.setInterval(() => this.statusBar.display(), 1000)\n            );\n        }\n\n        this.init();\n    }\n\n    async onunload() {\n        window.clearTimeout(this.timeoutIDBackup);\n        window.clearTimeout(this.timeoutIDPull);\n        console.log('unloading ' + this.manifest.name + \" plugin\");\n    }\n    async loadSettings() {\n        this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\n    }\n    async saveSettings() {\n        await this.saveData(this.settings);\n    }\n\n    async init(): Promise<void> {\n        if (!this.isGitInstalled()) {\n            this.displayError(\"Cannot run git command\");\n            return;\n        }\n        try {\n            const adapter = this.app.vault.adapter as FileSystemAdapter;\n            const path = adapter.getBasePath();\n\n            this.git = simpleGit(path);\n\n            const isValidRepo = await this.git.checkIsRepo();\n\n            if (!isValidRepo) {\n                this.displayError(\"Valid git repository not found.\");\n            } else {\n                this.gitReady = true;\n                this.setState(PluginState.idle);\n\n                if (this.settings.autoPullOnBoot) {\n                    this.promiseQueue.addTask(() => this.pullChangesFromRemote());\n                }\n\n                if (this.settings.autoSaveInterval > 0) {\n                    const now = new Date();\n                    const last = new Date(this.settings.lastAutoBackUp);\n\n                    const diff = this.settings.autoSaveInterval - (Math.round(((now.getTime() - last.getTime()) / 1000) / 60));\n                    this.startAutoBackup(diff <= 0 ? 0 : diff);\n                }\n                if (this.settings.autoPullInterval > 0) {\n                    const now = new Date();\n                    const last = new Date(this.settings.lastAutoPull);\n\n                    const diff = this.settings.autoPullInterval - (Math.round(((now.getTime() - last.getTime()) / 1000) / 60));\n                    this.startAutoPull(diff <= 0 ? 0 : diff);\n                }\n            }\n\n        } catch (error) {\n            this.displayError(error);\n            console.error(error);\n        }\n    }\n\n    async pullChangesFromRemote(): Promise<void> {\n\n        if (!this.gitReady) {\n            await this.init();\n        }\n\n        if (!this.gitReady) return;\n\n        const filesUpdated = await this.pull();\n        if (filesUpdated > 0) {\n            this.displayMessage(`Pulled new changes. ${filesUpdated} files updated`);\n        } else {\n            this.displayMessage(\"Everything is up-to-date\");\n        }\n\n        const status = await this.git.status();\n        if (status.conflicted.length > 0) {\n            this.displayError(`You have ${status.conflicted.length} conflict files`);\n        }\n\n        this.lastUpdate = Date.now();\n        this.setState(PluginState.idle);\n    }\n\n    async createBackup(fromAutoBackup: boolean, commitMessage?: string): Promise<void> {\n        if (!this.gitReady) {\n            await this.init();\n        }\n        if (!this.gitReady) return;\n\n        this.setState(PluginState.status);\n        let status = await this.git.status();\n\n\n        if (!fromAutoBackup) {\n            const file = this.app.vault.getAbstractFileByPath(this.conflictOutputFile);\n            await this.app.vault.delete(file);\n        }\n\n        // check for conflict files on auto backup\n        if (fromAutoBackup && status.conflicted.length > 0) {\n            this.setState(PluginState.idle);\n            this.displayError(`Did not commit, because you have ${status.conflicted.length} conflict files. Please resolve them and commit per command.`);\n            this.handleConflict(status.conflicted);\n            return;\n        }\n\n        const changedFiles = (await this.git.status()).files;\n\n        if (changedFiles.length !== 0) {\n            await this.add();\n            status = await this.git.status();\n            await this.commit(commitMessage);\n\n            this.lastUpdate = Date.now();\n            this.displayMessage(`Committed ${status.staged.length} files`);\n        } else {\n            this.displayMessage(\"No changes to commit\");\n        }\n\n        if (!this.settings.disablePush) {\n            const trackingBranch = status.tracking;\n            const currentBranch = status.current;\n\n            if (!trackingBranch) {\n                this.displayError(\"Did not push. No upstream branch is set! See README for instructions\", 10000);\n                this.setState(PluginState.idle);\n                return;\n            }\n\n            const remoteChangedFiles = (await this.git.diffSummary([currentBranch, trackingBranch])).changed;\n\n            // Prevent plugin to pull/push at every call of createBackup. Only if unpushed commits are present\n            if (remoteChangedFiles > 0) {\n                if (this.settings.pullBeforePush) {\n                    const pulledFilesLength = await this.pull();\n                    if (pulledFilesLength > 0) {\n                        this.displayMessage(`Pulled ${pulledFilesLength} files from remote`);\n                    }\n                }\n\n                // Refresh because of pull\n                status = await this.git.status();\n\n                if (status.conflicted.length > 0) {\n                    this.displayError(`Cannot push. You have ${status.conflicted.length} conflict files`);\n                    this.handleConflict(status.conflicted);\n                    return;\n                } else {\n                    const remoteChangedFiles = (await this.git.diffSummary([currentBranch, trackingBranch])).changed;\n\n                    await this.push();\n                    this.displayMessage(`Pushed ${remoteChangedFiles} files to remote`);\n                }\n            } else {\n                this.displayMessage(\"No changes to push\");\n            }\n        }\n        this.setState(PluginState.idle);\n    }\n\n\n    // region: main methods\n\n    isGitInstalled(): boolean {\n        // https://github.com/steveukx/git-js/issues/402\n        const command = spawnSync('git', ['--version'], {\n            stdio: 'ignore'\n        });\n\n        if (command.error) {\n            console.error(command.error);\n            return false;\n        }\n        return true;\n    }\n\n    async add(): Promise<void> {\n        this.setState(PluginState.add);\n        await this.git.add(\n            \"./*\",\n            (err: Error | null) =>\n                err && this.displayError(`Cannot add files: ${err.message}`)\n        );\n    }\n\n    async commit(message?: string): Promise<void> {\n        this.setState(PluginState.commit);\n        let commitMessage: string | string[] = message ?? await this.formatCommitMessage(this.settings.commitMessage);\n        if (this.settings.listChangedFilesInMessageBody) {\n            commitMessage = [commitMessage, \"Affected files:\", (await this.git.status()).staged.join(\"\\n\")];\n        }\n        await this.git.commit(commitMessage);\n    }\n\n    async push(): Promise<void> {\n        this.setState(PluginState.push);\n        await this.git.env({ ...process.env, \"OBSIDIAN_GIT\": 1 }).push(\n            (err: Error | null) => {\n                err && this.displayError(`Push failed ${err.message}`);\n            }\n        );\n\n        this.lastUpdate = Date.now();\n    }\n\n    async pull(): Promise<number> {\n        this.setState(PluginState.pull);\n        const pullResult = await this.git.pull([\"--no-rebase\"],\n            async (err: Error | null) => {\n                if (err) {\n                    this.displayError(`Pull failed ${err.message}`);\n                    const status = await this.git.status();\n                    if (status.conflicted.length > 0) {\n                        this.handleConflict(status.conflicted);\n                    }\n                }\n            }\n        );\n        this.lastUpdate = Date.now();\n        return pullResult.files.length;\n    }\n\n    // endregion: main methods\n\n    startAutoBackup(minutes?: number) {\n        this.timeoutIDBackup = window.setTimeout(\n            () => {\n                this.promiseQueue.addTask(() => this.createBackup(true));\n                this.settings.lastAutoBackUp = new Date().toString();\n                this.saveSettings();\n                this.startAutoBackup();\n            },\n            (minutes ?? this.settings.autoSaveInterval) * 60000\n        );\n    }\n\n    startAutoPull(minutes?: number) {\n        this.timeoutIDPull = window.setTimeout(\n            () => {\n                this.promiseQueue.addTask(() => this.pullChangesFromRemote());\n                this.settings.lastAutoPull = new Date().toString();\n                this.saveSettings();\n                this.startAutoPull();\n            },\n            (minutes ?? this.settings.autoPullInterval) * 60000\n        );\n    }\n\n    clearAutoBackup(): boolean {\n        if (this.timeoutIDBackup) {\n            window.clearTimeout(this.timeoutIDBackup);\n            return true;\n        }\n        return false;\n    }\n\n    clearAutoPull(): boolean {\n        if (this.timeoutIDPull) {\n            window.clearTimeout(this.timeoutIDPull);\n            return true;\n        }\n        return false;\n    }\n\n    async handleConflict(conflicted: string[]): Promise<void> {\n        this.setState(PluginState.conflicted);\n        const lines = [\n            \"# Conflict files\",\n            \"Please resolve them and commit per command (This file will be deleted before the commit).\",\n            ...conflicted.map(e => {\n                const file = this.app.vault.getAbstractFileByPath(e);\n                if (file instanceof TFile) {\n                    const link = this.app.metadataCache.fileToLinktext(file, \"/\");\n                    return `- [[${link}]]`;\n                } else {\n                    return `- Not a file: ${e}`;\n                }\n            })\n        ];\n        this.writeAndOpenFile(lines.join(\"\\n\"));\n    }\n\n    async writeAndOpenFile(text: string) {\n        await this.app.vault.adapter.write(this.conflictOutputFile, text);\n\n        let fileIsAlreadyOpened = false;\n        this.app.workspace.iterateAllLeaves(leaf => {\n            if (leaf.getDisplayText() != \"\" && this.conflictOutputFile.startsWith(leaf.getDisplayText())) {\n                fileIsAlreadyOpened = true;\n            }\n        });\n        if (!fileIsAlreadyOpened) {\n            this.app.workspace.openLinkText(this.conflictOutputFile, \"/\", true);\n        }\n    }\n\n    // region: displaying / formatting messages\n    displayMessage(message: string, timeout: number = 4 * 1000): void {\n        this.statusBar?.displayMessage(message.toLowerCase(), timeout);\n\n        if (!this.settings.disablePopups) {\n            new Notice(message);\n        }\n\n        console.log(`git obsidian message: ${message}`);\n    }\n    displayError(message: string, timeout: number = 0): void {\n        new Notice(message);\n        console.log(`git obsidian error: ${message}`);\n        this.statusBar?.displayMessage(message.toLowerCase(), timeout);\n    }\n\n    async formatCommitMessage(template: string): Promise<string> {\n        if (template.includes(\"{{numFiles}}\")) {\n            let status = await this.git.status();\n            let numFiles = status.files.length;\n            template = template.replace(\"{{numFiles}}\", String(numFiles));\n        }\n\n        if (template.includes(\"{{files}}\")) {\n            let status = await this.git.status();\n\n            let changeset: { [key: string]: string[]; } = {};\n            status.files.forEach((value: FileStatusResult) => {\n                if (value.index in changeset) {\n                    changeset[value.index].push(value.path);\n                } else {\n                    changeset[value.index] = [value.path];\n                }\n            });\n\n            let chunks = [];\n            for (let [action, files] of Object.entries(changeset)) {\n                chunks.push(action + \" \" + files.join(\" \"));\n            }\n\n            let files = chunks.join(\", \");\n\n            template = template.replace(\"{{files}}\", files);\n        }\n\n        let moment = (window as any).moment;\n        return template.replace(\n            \"{{date}}\",\n            moment().format(this.settings.commitDateFormat)\n        );\n    }\n\n    // endregion: displaying / formatting stuff\n}\n\n\nclass ObsidianGitSettingsTab extends PluginSettingTab {\n    display(): void {\n        let { containerEl } = this;\n        const plugin: ObsidianGit = (this as any).plugin;\n\n        containerEl.empty();\n        containerEl.createEl(\"h2\", { text: \"Git Backup settings\" });\n\n        new Setting(containerEl)\n            .setName(\"Vault backup interval (minutes)\")\n            .setDesc(\n                \"Commit and push changes every X minutes. To disable automatic backup, specify negative value or zero (default)\"\n            )\n            .addText((text) =>\n                text\n                    .setValue(String(plugin.settings.autoSaveInterval))\n                    .onChange((value) => {\n                        if (!isNaN(Number(value))) {\n                            plugin.settings.autoSaveInterval = Number(value);\n                            plugin.saveSettings();\n\n                            if (plugin.settings.autoSaveInterval > 0) {\n                                plugin.clearAutoBackup();\n                                plugin.startAutoBackup(plugin.settings.autoSaveInterval);\n                                new Notice(\n                                    `Automatic backup enabled! Every ${plugin.settings.autoSaveInterval} minutes.`\n                                );\n                            } else if (\n                                plugin.settings.autoSaveInterval <= 0 &&\n                                plugin.timeoutIDBackup\n                            ) {\n                                plugin.clearAutoBackup() &&\n                                    new Notice(\"Automatic backup disabled!\");\n                            }\n                        } else {\n                            new Notice(\"Please specify a valid number.\");\n                        }\n                    })\n            );\n        new Setting(containerEl)\n            .setName(\"Auto pull interval (minutes)\")\n            .setDesc(\n                \"Pull changes every X minutes. To disable automatic pull, specify negative value or zero (default)\"\n            )\n            .addText((text) =>\n                text\n                    .setValue(String(plugin.settings.autoPullInterval))\n                    .onChange((value) => {\n                        if (!isNaN(Number(value))) {\n                            plugin.settings.autoPullInterval = Number(value);\n                            plugin.saveSettings();\n\n                            if (plugin.settings.autoPullInterval > 0) {\n                                plugin.clearAutoPull();\n                                plugin.startAutoPull(plugin.settings.autoSaveInterval);\n                                new Notice(\n                                    `Automatic pull enabled! Every ${plugin.settings.autoPullInterval} minutes.`\n                                );\n                            } else if (\n                                plugin.settings.autoPullInterval <= 0 &&\n                                plugin.timeoutIDPull\n                            ) {\n                                plugin.clearAutoPull() &&\n                                    new Notice(\"Automatic pull disabled!\");\n                            }\n                        } else {\n                            new Notice(\"Please specify a valid number.\");\n                        }\n                    })\n            );\n\n        new Setting(containerEl)\n            .setName(\"Commit message\")\n            .setDesc(\n                \"Specify custom commit message. Available placeholders: {{date}}\" +\n                \" (see below) and {{numFiles}} (number of changed files in the commit)\"\n            )\n            .addText((text) =>\n                text\n                    .setPlaceholder(\"vault backup\")\n                    .setValue(\n                        plugin.settings.commitMessage\n                            ? plugin.settings.commitMessage\n                            : \"\"\n                    )\n                    .onChange((value) => {\n                        plugin.settings.commitMessage = value;\n                        plugin.saveSettings();\n                    })\n            );\n\n        new Setting(containerEl)\n            .setName(\"{{date}} placeholder format\")\n            .setDesc('Specify custom date format. E.g. \"YYYY-MM-DD HH:mm:ss\"')\n            .addText((text) =>\n                text\n                    .setPlaceholder(plugin.settings.commitDateFormat)\n                    .setValue(plugin.settings.commitDateFormat)\n                    .onChange(async (value) => {\n                        plugin.settings.commitDateFormat = value;\n                        await plugin.saveSettings();\n                    })\n            );\n\n        new Setting(containerEl)\n            .setName(\"Preview commit message\")\n            .addButton((button) =>\n                button.setButtonText(\"Preview\").onClick(async () => {\n                    let commitMessagePreview = await plugin.formatCommitMessage(\n                        plugin.settings.commitMessage\n                    );\n                    new Notice(`${commitMessagePreview}`);\n                })\n            );\n\n        new Setting(containerEl)\n            .setName(\"List filenames affected by commit in the commit body\")\n            .addToggle((toggle) =>\n                toggle\n                    .setValue(plugin.settings.listChangedFilesInMessageBody)\n                    .onChange((value) => {\n                        plugin.settings.listChangedFilesInMessageBody = value;\n                        plugin.saveSettings();\n                    })\n            );\n\n        new Setting(containerEl)\n            .setName(\"Current branch\")\n            .setDesc(\"Switch to a different branch\")\n            .addDropdown(async (dropdown) => {\n                const branchInfo = await plugin.git.branchLocal();\n                for (const branch of branchInfo.all) {\n                    dropdown.addOption(branch, branch);\n                }\n                dropdown.setValue(branchInfo.current);\n                dropdown.onChange(async (option) => {\n                    await plugin.git.checkout(\n                        option,\n                        [],\n                        async (err: Error) => {\n                            if (err) {\n                                new Notice(err.message);\n                                dropdown.setValue(branchInfo.current);\n                            } else {\n                                new Notice(`Checked out to ${option}`);\n                            }\n                        }\n                    );\n                });\n            });\n\n        new Setting(containerEl)\n            .setName(\"Pull updates on startup\")\n            .setDesc(\"Automatically pull updates when Obsidian starts\")\n            .addToggle((toggle) =>\n                toggle\n                    .setValue(plugin.settings.autoPullOnBoot)\n                    .onChange((value) => {\n                        plugin.settings.autoPullOnBoot = value;\n                        plugin.saveSettings();\n                    })\n            );\n\n        new Setting(containerEl)\n            .setName(\"Disable push\")\n            .setDesc(\"Do not push changes to the remote repository\")\n            .addToggle((toggle) =>\n                toggle\n                    .setValue(plugin.settings.disablePush)\n                    .onChange((value) => {\n                        plugin.settings.disablePush = value;\n                        plugin.saveSettings();\n                    })\n            );\n\n        new Setting(containerEl)\n            .setName(\"Pull changes before push\")\n            .setDesc(\"Commit -> pull -> push (Only if pushing is enabled)\")\n            .addToggle((toggle) =>\n                toggle\n                    .setValue(plugin.settings.pullBeforePush)\n                    .onChange((value) => {\n                        plugin.settings.pullBeforePush = value;\n                        plugin.saveSettings();\n                    })\n            );\n\n        new Setting(containerEl)\n            .setName(\"Disable notifications\")\n            .setDesc(\n                \"Disable notifications for git operations to minimize distraction (refer to status bar for updates)\"\n            )\n            .addToggle((toggle) =>\n                toggle\n                    .setValue(plugin.settings.disablePopups)\n                    .onChange((value) => {\n                        plugin.settings.disablePopups = value;\n                        plugin.saveSettings();\n                    })\n            );\n\n        new Setting(containerEl)\n            .setName(\"Show status bar\")\n            .setDesc(\"Obsidian must be restarted for the changes to take affect\")\n            .addToggle((toggle) =>\n                toggle\n                    .setValue(plugin.settings.showStatusBar)\n                    .onChange((value) => {\n                        plugin.settings.showStatusBar = value;\n                        plugin.saveSettings();\n                    })\n            );\n    }\n}\n\ninterface StatusBarMessage {\n    message: string;\n    timeout: number;\n}\n\nclass StatusBar {\n    public messages: StatusBarMessage[] = [];\n    public currentMessage: StatusBarMessage;\n    public lastMessageTimestamp: number;\n\n    private statusBarEl: HTMLElement;\n    private plugin: ObsidianGit;\n\n    constructor(statusBarEl: HTMLElement, plugin: ObsidianGit) {\n        this.statusBarEl = statusBarEl;\n        this.plugin = plugin;\n    }\n\n    public displayMessage(message: string, timeout: number) {\n        this.messages.push({\n            message: `git: ${message.slice(0, 100)}`,\n            timeout: timeout,\n        });\n        this.display();\n    }\n\n    public display() {\n        if (this.messages.length > 0 && !this.currentMessage) {\n            this.currentMessage = this.messages.shift();\n            this.statusBarEl.setText(this.currentMessage.message);\n            this.lastMessageTimestamp = Date.now();\n        } else if (this.currentMessage) {\n            const messageAge = Date.now() - this.lastMessageTimestamp;\n            if (messageAge >= this.currentMessage.timeout) {\n                this.currentMessage = null;\n                this.lastMessageTimestamp = null;\n            }\n        } else {\n            this.displayState();\n        }\n    }\n\n    private displayState() {\n        switch (this.plugin.state) {\n            case PluginState.idle:\n                this.displayFromNow(this.plugin.lastUpdate);\n                break;\n            case PluginState.status:\n                this.statusBarEl.setText(\"git: checking repo status..\");\n                break;\n            case PluginState.add:\n                this.statusBarEl.setText(\"git: adding files to repo..\");\n                break;\n            case PluginState.commit:\n                this.statusBarEl.setText(\"git: committing changes..\");\n                break;\n            case PluginState.push:\n                this.statusBarEl.setText(\"git: pushing changes..\");\n                break;\n            case PluginState.pull:\n                this.statusBarEl.setText(\"git: pulling changes..\");\n                break;\n            case PluginState.conflicted:\n                this.statusBarEl.setText(\"git: you have conflict files..\");\n                break;\n            default:\n                this.statusBarEl.setText(\"git: failed on initialization!\");\n                break;\n        }\n    }\n\n    private displayFromNow(timestamp: number): void {\n        if (timestamp) {\n            let moment = (window as any).moment;\n            let fromNow = moment(timestamp).fromNow();\n            this.statusBarEl.setText(`git: last update ${fromNow}..`);\n        } else {\n            this.statusBarEl.setText(`git: ready`);\n        }\n    }\n}\nclass CustomMessageModal extends SuggestModal<string> {\n    plugin: ObsidianGit;\n\n    constructor(plugin: ObsidianGit) {\n        super(plugin.app);\n        this.plugin = plugin;\n        this.setPlaceholder(\"Type your message and select optional the version with the added date.\");\n    }\n\n\n    getSuggestions(query: string): string[] {\n        const date = (window as any).moment().format(this.plugin.settings.commitDateFormat);\n        if (query == \"\") query = \"...\";\n        return [query, `${date}: ${query}`, `${query}: ${date}`];\n    }\n\n    renderSuggestion(value: string, el: HTMLElement): void {\n        el.innerText = value;\n    }\n\n    onChooseSuggestion(item: string, _: MouseEvent | KeyboardEvent): void {\n        this.plugin.promiseQueue.addTask(() => this.plugin.createBackup(false, item));\n    }\n\n}\nclass ChangedFilesModal extends FuzzySuggestModal<FileStatusResult> {\n    plugin: ObsidianGit;\n    changedFiles: FileStatusResult[];\n\n    constructor(plugin: ObsidianGit, changedFiles: FileStatusResult[]) {\n        super(plugin.app);\n        this.plugin = plugin;\n        this.changedFiles = changedFiles;\n        this.setPlaceholder(\"Not supported files will be opened by default app!\");\n    }\n\n    getItems(): FileStatusResult[] {\n        return this.changedFiles;\n    }\n\n    getItemText(item: FileStatusResult): string {\n        if (item.index == \"?\" && item.working_dir == \"?\") {\n            return `Untracked | ${item.path}`;\n        }\n\n        let working_dir = \"\";\n        let index = \"\";\n\n        if (item.working_dir != \" \") working_dir = `Working dir: ${item.working_dir} `;\n        if (item.index != \" \") index = `Index: ${item.index}`;\n\n        return `${working_dir}${index} | ${item.path}`;\n    }\n\n    onChooseItem(item: FileStatusResult, _: MouseEvent | KeyboardEvent): void {\n        if (this.plugin.app.metadataCache.getFirstLinkpathDest(item.path, \"\") == null) {\n            (this.app as any).openWithDefaultApp(item.path);\n        } else {\n            this.plugin.app.workspace.openLinkText(item.path, \"/\");\n        }\n    }\n}\n\nclass PromiseQueue {\n    tasks: (() => Promise<any>)[] = [];\n\n    addTask(task: () => Promise<any>) {\n        this.tasks.push(task);\n        if (this.tasks.length === 1) {\n            this.handleTask();\n        }\n    }\n    async handleTask() {\n        if (this.tasks.length > 0) {\n            this.tasks[0]().finally(() => {\n                this.tasks.shift();\n                this.handleTask();\n            });\n        }\n    }\n}"],"names":["git_error_1","require$$0","os","tty","util","require$$1","this","fs_1","file_exists_1","util_1","argument_filters_1","require$$2","require$$3","require$$4","require$$5","require$$6","require$$7","utils_1","task_configuration_error_1","task_1","CleanSummary_1","check_is_repo_1","clean_1","git_construct_error_1","git_plugin_error_1","git_response_error_1","reset_1","debug_1","git_logger_1","tasks_pending_queue_1","task","gitError","child_process_1","git_executor_chain_1","parse_remote_objects_1","parse_remote_messages_1","parse_push_1","task_callback_1","push_1","promise_deferred_1","BranchDeleteSummary_1","BranchSummary_1","parse_branch_delete_1","parse_branch_1","CheckIgnore_1","parse_commit_1","parse_diff_summary_1","parse_fetch_1","parse_list_log_summary_1","MergeSummary_1","parse_pull_1","parse_merge_1","parse_move_1","GetRemoteSummary_1","log_1","require$$8","require$$9","require$$10","require$$11","require$$12","require$$13","require$$14","require$$15","require$$16","require$$17","require$$18","require$$19","require$$20","require$$21","require$$22","require$$23","require$$24","require$$25","require$$26","require$$27","require$$28","plugins","plugins_1","Git","git_factory_1","simpleGit","spawnSync","TFile","Notice","Plugin","Setting","PluginSettingTab","SuggestModal","FuzzySuggestModal"],"mappings":";;;;;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,aAAa,GAAG,SAAS,CAAC,EAAE,CAAC,EAAE;AACnC,IAAI,aAAa,GAAG,MAAM,CAAC,cAAc;AACzC,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE,YAAY,KAAK,IAAI,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,EAAE,CAAC;AACpF,QAAQ,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AAC1G,IAAI,OAAO,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC/B,CAAC,CAAC;AACF;AACO,SAAS,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE;AAChC,IAAI,IAAI,OAAO,CAAC,KAAK,UAAU,IAAI,CAAC,KAAK,IAAI;AAC7C,QAAQ,MAAM,IAAI,SAAS,CAAC,sBAAsB,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,+BAA+B,CAAC,CAAC;AAClG,IAAI,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACxB,IAAI,SAAS,EAAE,GAAG,EAAE,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,EAAE;AAC3C,IAAI,CAAC,CAAC,SAAS,GAAG,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,SAAS,GAAG,CAAC,CAAC,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;AACzF,CAAC;AACD;AACO,IAAI,QAAQ,GAAG,WAAW;AACjC,IAAI,QAAQ,GAAG,MAAM,CAAC,MAAM,IAAI,SAAS,QAAQ,CAAC,CAAC,EAAE;AACrD,QAAQ,KAAK,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;AAC7D,YAAY,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;AAC7B,YAAY,KAAK,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACzF,SAAS;AACT,QAAQ,OAAO,CAAC,CAAC;AACjB,MAAK;AACL,IAAI,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;AAC3C,EAAC;AA4BD;AACO,SAAS,SAAS,CAAC,OAAO,EAAE,UAAU,EAAE,CAAC,EAAE,SAAS,EAAE;AAC7D,IAAI,SAAS,KAAK,CAAC,KAAK,EAAE,EAAE,OAAO,KAAK,YAAY,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,CAAC,UAAU,OAAO,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;AAChH,IAAI,OAAO,KAAK,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,EAAE,UAAU,OAAO,EAAE,MAAM,EAAE;AAC/D,QAAQ,SAAS,SAAS,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE;AACnG,QAAQ,SAAS,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE;AACtG,QAAQ,SAAS,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,EAAE;AACtH,QAAQ,IAAI,CAAC,CAAC,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,UAAU,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9E,KAAK,CAAC,CAAC;AACP,CAAC;AACD;AACO,SAAS,WAAW,CAAC,OAAO,EAAE,IAAI,EAAE;AAC3C,IAAI,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AACrH,IAAI,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,OAAO,MAAM,KAAK,UAAU,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,WAAW,EAAE,OAAO,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AAC7J,IAAI,SAAS,IAAI,CAAC,CAAC,EAAE,EAAE,OAAO,UAAU,CAAC,EAAE,EAAE,OAAO,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE;AACtE,IAAI,SAAS,IAAI,CAAC,EAAE,EAAE;AACtB,QAAQ,IAAI,CAAC,EAAE,MAAM,IAAI,SAAS,CAAC,iCAAiC,CAAC,CAAC;AACtE,QAAQ,OAAO,CAAC,EAAE,IAAI;AACtB,YAAY,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AACzK,YAAY,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;AACpD,YAAY,QAAQ,EAAE,CAAC,CAAC,CAAC;AACzB,gBAAgB,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,MAAM;AAC9C,gBAAgB,KAAK,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;AACxE,gBAAgB,KAAK,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;AACjE,gBAAgB,KAAK,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,SAAS;AACjE,gBAAgB;AAChB,oBAAoB,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,EAAE;AAChI,oBAAoB,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE;AAC1G,oBAAoB,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;AACzF,oBAAoB,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE;AACvF,oBAAoB,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;AAC1C,oBAAoB,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,SAAS;AAC3C,aAAa;AACb,YAAY,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;AACvC,SAAS,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE;AAClE,QAAQ,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AACzF,KAAK;AACL,CAAC;AA0DD;AACO,SAAS,aAAa,CAAC,EAAE,EAAE,IAAI,EAAE;AACxC,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE;AACrE,QAAQ,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;AACxB,IAAI,OAAO,EAAE,CAAC;AACd;;;;;;;;;;;;;;;;;;;ACvKA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,gBAAgB,GAAG,KAAK,CAAC,CAAC;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,QAAQ,SAAS,KAAK,CAAC;AAC7B,IAAI,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE;AAC/B,QAAQ,KAAK,CAAC,OAAO,CAAC,CAAC;AACvB,QAAQ,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;AACzB,QAAQ,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;AAC1D,KAAK;AACL,CAAC;AACD,gBAAgB,GAAG,QAAQ,CAAC;AAC5B;;;;ACnCA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,wBAAwB,GAAG,KAAK,CAAC,CAAC;AACS;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,gBAAgB,SAASA,QAAW,CAAC,QAAQ,CAAC;AACpD,IAAI,WAAW;AACf;AACA;AACA;AACA,IAAI,GAAG,EAAE,OAAO,EAAE;AAClB,QAAQ,KAAK,CAAC,SAAS,EAAE,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;AACjD,QAAQ,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;AACvB,KAAK;AACL,CAAC;AACD,wBAAwB,GAAG,gBAAgB,CAAC;AAC5C;;;;AClCA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,yBAAyB,GAAG,KAAK,CAAC,CAAC;AACQ;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,iBAAiB,SAASA,QAAW,CAAC,QAAQ,CAAC;AACrD,IAAI,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE;AACjC,QAAQ,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;AAClC,QAAQ,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;AAC7B,KAAK;AACL,CAAC;AACD,yBAAyB,GAAG,iBAAiB,CAAC;AAC9C;;;;ACnBA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,sBAAsB,GAAG,KAAK,CAAC,CAAC;AACW;AAC3C,MAAM,cAAc,SAASA,QAAW,CAAC,QAAQ,CAAC;AAClD,IAAI,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;AACvC,QAAQ,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAC7B,QAAQ,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;AACzB,QAAQ,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;AAC7B,QAAQ,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;AAC1D,KAAK;AACL,CAAC;AACD,sBAAsB,GAAG,cAAc,CAAC;AACxC;;;;ACZA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,8BAA8B,GAAG,KAAK,CAAC,CAAC;AACG;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,sBAAsB,SAASA,QAAW,CAAC,QAAQ,CAAC;AAC1D,IAAI,WAAW,CAAC,OAAO,EAAE;AACzB,QAAQ,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;AAClC,KAAK;AACL,CAAC;AACD,8BAA8B,GAAG,sBAAsB,CAAC;AACxD;;;AClBA;AACA;AACA;AACA;AACA,IAAI,CAAC,GAAG,IAAI,CAAC;AACb,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;AACf,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;AACf,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;AACf,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACd,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAc,GAAG,SAAS,GAAG,EAAE,OAAO,EAAE;AACxC,EAAE,OAAO,GAAG,OAAO,IAAI,EAAE,CAAC;AAC1B,EAAE,IAAI,IAAI,GAAG,OAAO,GAAG,CAAC;AACxB,EAAE,IAAI,IAAI,KAAK,QAAQ,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE;AAC3C,IAAI,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC;AACtB,GAAG,MAAM,IAAI,IAAI,KAAK,QAAQ,IAAI,QAAQ,CAAC,GAAG,CAAC,EAAE;AACjD,IAAI,OAAO,OAAO,CAAC,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;AACvD,GAAG;AACH,EAAE,MAAM,IAAI,KAAK;AACjB,IAAI,uDAAuD;AAC3D,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC;AACzB,GAAG,CAAC;AACJ,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,KAAK,CAAC,GAAG,EAAE;AACpB,EAAE,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AACpB,EAAE,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,EAAE;AACxB,IAAI,OAAO;AACX,GAAG;AACH,EAAE,IAAI,KAAK,GAAG,kIAAkI,CAAC,IAAI;AACrJ,IAAI,GAAG;AACP,GAAG,CAAC;AACJ,EAAE,IAAI,CAAC,KAAK,EAAE;AACd,IAAI,OAAO;AACX,GAAG;AACH,EAAE,IAAI,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/B,EAAE,IAAI,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,WAAW,EAAE,CAAC;AAC9C,EAAE,QAAQ,IAAI;AACd,IAAI,KAAK,OAAO,CAAC;AACjB,IAAI,KAAK,MAAM,CAAC;AAChB,IAAI,KAAK,KAAK,CAAC;AACf,IAAI,KAAK,IAAI,CAAC;AACd,IAAI,KAAK,GAAG;AACZ,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;AACnB,IAAI,KAAK,OAAO,CAAC;AACjB,IAAI,KAAK,MAAM,CAAC;AAChB,IAAI,KAAK,GAAG;AACZ,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;AACnB,IAAI,KAAK,MAAM,CAAC;AAChB,IAAI,KAAK,KAAK,CAAC;AACf,IAAI,KAAK,GAAG;AACZ,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;AACnB,IAAI,KAAK,OAAO,CAAC;AACjB,IAAI,KAAK,MAAM,CAAC;AAChB,IAAI,KAAK,KAAK,CAAC;AACf,IAAI,KAAK,IAAI,CAAC;AACd,IAAI,KAAK,GAAG;AACZ,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;AACnB,IAAI,KAAK,SAAS,CAAC;AACnB,IAAI,KAAK,QAAQ,CAAC;AAClB,IAAI,KAAK,MAAM,CAAC;AAChB,IAAI,KAAK,KAAK,CAAC;AACf,IAAI,KAAK,GAAG;AACZ,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;AACnB,IAAI,KAAK,SAAS,CAAC;AACnB,IAAI,KAAK,QAAQ,CAAC;AAClB,IAAI,KAAK,MAAM,CAAC;AAChB,IAAI,KAAK,KAAK,CAAC;AACf,IAAI,KAAK,GAAG;AACZ,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;AACnB,IAAI,KAAK,cAAc,CAAC;AACxB,IAAI,KAAK,aAAa,CAAC;AACvB,IAAI,KAAK,OAAO,CAAC;AACjB,IAAI,KAAK,MAAM,CAAC;AAChB,IAAI,KAAK,IAAI;AACb,MAAM,OAAO,CAAC,CAAC;AACf,IAAI;AACJ,MAAM,OAAO,SAAS,CAAC;AACvB,GAAG;AACH,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,QAAQ,CAAC,EAAE,EAAE;AACtB,EAAE,IAAI,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;AAC3B,EAAE,IAAI,KAAK,IAAI,CAAC,EAAE;AAClB,IAAI,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC;AACpC,GAAG;AACH,EAAE,IAAI,KAAK,IAAI,CAAC,EAAE;AAClB,IAAI,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC;AACpC,GAAG;AACH,EAAE,IAAI,KAAK,IAAI,CAAC,EAAE;AAClB,IAAI,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC;AACpC,GAAG;AACH,EAAE,IAAI,KAAK,IAAI,CAAC,EAAE;AAClB,IAAI,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC;AACpC,GAAG;AACH,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;AACnB,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,OAAO,CAAC,EAAE,EAAE;AACrB,EAAE,IAAI,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;AAC3B,EAAE,IAAI,KAAK,IAAI,CAAC,EAAE;AAClB,IAAI,OAAO,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;AACvC,GAAG;AACH,EAAE,IAAI,KAAK,IAAI,CAAC,EAAE;AAClB,IAAI,OAAO,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;AACxC,GAAG;AACH,EAAE,IAAI,KAAK,IAAI,CAAC,EAAE;AAClB,IAAI,OAAO,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;AAC1C,GAAG;AACH,EAAE,IAAI,KAAK,IAAI,CAAC,EAAE;AAClB,IAAI,OAAO,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;AAC1C,GAAG;AACH,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;AACpB,CAAC;AACD;AACA;AACA;AACA;AACA;AACA,SAAS,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE;AACpC,EAAE,IAAI,QAAQ,GAAG,KAAK,IAAI,CAAC,GAAG,GAAG,CAAC;AAClC,EAAE,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,GAAG,GAAG,IAAI,IAAI,QAAQ,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AACjE;;AChKA;AACA;AACA;AACA;AACA;AACA,SAAS,KAAK,CAAC,GAAG,EAAE;AACpB,CAAC,WAAW,CAAC,KAAK,GAAG,WAAW,CAAC;AACjC,CAAC,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC;AACnC,CAAC,WAAW,CAAC,MAAM,GAAG,MAAM,CAAC;AAC7B,CAAC,WAAW,CAAC,OAAO,GAAG,OAAO,CAAC;AAC/B,CAAC,WAAW,CAAC,MAAM,GAAG,MAAM,CAAC;AAC7B,CAAC,WAAW,CAAC,OAAO,GAAG,OAAO,CAAC;AAC/B,CAAC,WAAW,CAAC,QAAQ,GAAGC,EAAa,CAAC;AACtC,CAAC,WAAW,CAAC,OAAO,GAAG,OAAO,CAAC;AAC/B;AACA,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,IAAI;AACjC,EAAE,WAAW,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;AAC9B,EAAE,CAAC,CAAC;AACJ;AACA;AACA;AACA;AACA;AACA,CAAC,WAAW,CAAC,KAAK,GAAG,EAAE,CAAC;AACxB,CAAC,WAAW,CAAC,KAAK,GAAG,EAAE,CAAC;AACxB;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,WAAW,CAAC,UAAU,GAAG,EAAE,CAAC;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,SAAS,WAAW,CAAC,SAAS,EAAE;AACjC,EAAE,IAAI,IAAI,GAAG,CAAC,CAAC;AACf;AACA,EAAE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AAC7C,GAAG,IAAI,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;AACzD,GAAG,IAAI,IAAI,CAAC,CAAC;AACb,GAAG;AACH;AACA,EAAE,OAAO,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AACxE,EAAE;AACF,CAAC,WAAW,CAAC,WAAW,GAAG,WAAW,CAAC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,SAAS,WAAW,CAAC,SAAS,EAAE;AACjC,EAAE,IAAI,QAAQ,CAAC;AACf,EAAE,IAAI,cAAc,GAAG,IAAI,CAAC;AAC5B;AACA,EAAE,SAAS,KAAK,CAAC,GAAG,IAAI,EAAE;AAC1B;AACA,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE;AACvB,IAAI,OAAO;AACX,IAAI;AACJ;AACA,GAAG,MAAM,IAAI,GAAG,KAAK,CAAC;AACtB;AACA;AACA,GAAG,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;AACnC,GAAG,MAAM,EAAE,GAAG,IAAI,IAAI,QAAQ,IAAI,IAAI,CAAC,CAAC;AACxC,GAAG,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;AAClB,GAAG,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC;AACxB,GAAG,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;AACpB,GAAG,QAAQ,GAAG,IAAI,CAAC;AACnB;AACA,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AACzC;AACA,GAAG,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE;AACpC;AACA,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AACvB,IAAI;AACJ;AACA;AACA,GAAG,IAAI,KAAK,GAAG,CAAC,CAAC;AACjB,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK;AACjE;AACA,IAAI,IAAI,KAAK,KAAK,IAAI,EAAE;AACxB,KAAK,OAAO,GAAG,CAAC;AAChB,KAAK;AACL,IAAI,KAAK,EAAE,CAAC;AACZ,IAAI,MAAM,SAAS,GAAG,WAAW,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;AACrD,IAAI,IAAI,OAAO,SAAS,KAAK,UAAU,EAAE;AACzC,KAAK,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;AAC7B,KAAK,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AACvC;AACA;AACA,KAAK,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;AAC3B,KAAK,KAAK,EAAE,CAAC;AACb,KAAK;AACL,IAAI,OAAO,KAAK,CAAC;AACjB,IAAI,CAAC,CAAC;AACN;AACA;AACA,GAAG,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAC3C;AACA,GAAG,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,IAAI,WAAW,CAAC,GAAG,CAAC;AAC7C,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAC3B,GAAG;AACH;AACA,EAAE,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC;AAC9B,EAAE,KAAK,CAAC,SAAS,GAAG,WAAW,CAAC,SAAS,EAAE,CAAC;AAC5C,EAAE,KAAK,CAAC,KAAK,GAAG,WAAW,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;AACnD,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;AACxB,EAAE,KAAK,CAAC,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC;AACtC;AACA,EAAE,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE;AAC1C,GAAG,UAAU,EAAE,IAAI;AACnB,GAAG,YAAY,EAAE,KAAK;AACtB,GAAG,GAAG,EAAE,MAAM,cAAc,KAAK,IAAI,GAAG,WAAW,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,cAAc;AACvF,GAAG,GAAG,EAAE,CAAC,IAAI;AACb,IAAI,cAAc,GAAG,CAAC,CAAC;AACvB,IAAI;AACJ,GAAG,CAAC,CAAC;AACL;AACA;AACA,EAAE,IAAI,OAAO,WAAW,CAAC,IAAI,KAAK,UAAU,EAAE;AAC9C,GAAG,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC3B,GAAG;AACH;AACA,EAAE,OAAO,KAAK,CAAC;AACf,EAAE;AACF;AACA,CAAC,SAAS,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE;AACvC,EAAE,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,SAAS,IAAI,OAAO,SAAS,KAAK,WAAW,GAAG,GAAG,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC,CAAC;AAClH,EAAE,QAAQ,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC;AAC1B,EAAE,OAAO,QAAQ,CAAC;AAClB,EAAE;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,SAAS,MAAM,CAAC,UAAU,EAAE;AAC7B,EAAE,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;AAC/B;AACA,EAAE,WAAW,CAAC,KAAK,GAAG,EAAE,CAAC;AACzB,EAAE,WAAW,CAAC,KAAK,GAAG,EAAE,CAAC;AACzB;AACA,EAAE,IAAI,CAAC,CAAC;AACR,EAAE,MAAM,KAAK,GAAG,CAAC,OAAO,UAAU,KAAK,QAAQ,GAAG,UAAU,GAAG,EAAE,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;AACnF,EAAE,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC;AAC3B;AACA,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;AAC5B,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;AAClB;AACA,IAAI,SAAS;AACb,IAAI;AACJ;AACA,GAAG,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAC/C;AACA,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;AAC9B,IAAI,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,GAAG,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;AACzE,IAAI,MAAM;AACV,IAAI,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,GAAG,GAAG,UAAU,GAAG,GAAG,CAAC,CAAC,CAAC;AAC/D,IAAI;AACJ,GAAG;AACH,EAAE;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,SAAS,OAAO,GAAG;AACpB,EAAE,MAAM,UAAU,GAAG;AACrB,GAAG,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC;AACxC,GAAG,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,SAAS,IAAI,GAAG,GAAG,SAAS,CAAC;AAC1E,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACd,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AACzB,EAAE,OAAO,UAAU,CAAC;AACpB,EAAE;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,SAAS,OAAO,CAAC,IAAI,EAAE;AACxB,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE;AACrC,GAAG,OAAO,IAAI,CAAC;AACf,GAAG;AACH;AACA,EAAE,IAAI,CAAC,CAAC;AACR,EAAE,IAAI,GAAG,CAAC;AACV;AACA,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,WAAW,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;AAC5D,GAAG,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;AACxC,IAAI,OAAO,KAAK,CAAC;AACjB,IAAI;AACJ,GAAG;AACH;AACA,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,WAAW,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;AAC5D,GAAG,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;AACxC,IAAI,OAAO,IAAI,CAAC;AAChB,IAAI;AACJ,GAAG;AACH;AACA,EAAE,OAAO,KAAK,CAAC;AACf,EAAE;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,SAAS,WAAW,CAAC,MAAM,EAAE;AAC9B,EAAE,OAAO,MAAM,CAAC,QAAQ,EAAE;AAC1B,IAAI,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;AAC9C,IAAI,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;AAC5B,EAAE;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE;AACtB,EAAE,IAAI,GAAG,YAAY,KAAK,EAAE;AAC5B,GAAG,OAAO,GAAG,CAAC,KAAK,IAAI,GAAG,CAAC,OAAO,CAAC;AACnC,GAAG;AACH,EAAE,OAAO,GAAG,CAAC;AACb,EAAE;AACF;AACA;AACA;AACA;AACA;AACA,CAAC,SAAS,OAAO,GAAG;AACpB,EAAE,OAAO,CAAC,IAAI,CAAC,uIAAuI,CAAC,CAAC;AACxJ,EAAE;AACF;AACA,CAAC,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;AACxC;AACA,CAAC,OAAO,WAAW,CAAC;AACpB,CAAC;AACD;AACA,UAAc,GAAG,KAAK;;;ACpQtB;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,GAAG,UAAU,CAAC;AAChC,YAAY,GAAG,IAAI,CAAC;AACpB,YAAY,GAAG,IAAI,CAAC;AACpB,iBAAiB,GAAG,SAAS,CAAC;AAC9B,eAAe,GAAG,YAAY,EAAE,CAAC;AACjC,eAAe,GAAG,CAAC,MAAM;AACzB,CAAC,IAAI,MAAM,GAAG,KAAK,CAAC;AACpB;AACA,CAAC,OAAO,MAAM;AACd,EAAE,IAAI,CAAC,MAAM,EAAE;AACf,GAAG,MAAM,GAAG,IAAI,CAAC;AACjB,GAAG,OAAO,CAAC,IAAI,CAAC,uIAAuI,CAAC,CAAC;AACzJ,GAAG;AACH,EAAE,CAAC;AACH,CAAC,GAAG,CAAC;AACL;AACA;AACA;AACA;AACA;AACA,cAAc,GAAG;AACjB,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,SAAS,GAAG;AACrB;AACA;AACA;AACA,CAAC,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,MAAM,CAAC,OAAO,KAAK,MAAM,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;AACvH,EAAE,OAAO,IAAI,CAAC;AACd,EAAE;AACF;AACA;AACA,CAAC,IAAI,OAAO,SAAS,KAAK,WAAW,IAAI,SAAS,CAAC,SAAS,IAAI,SAAS,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,uBAAuB,CAAC,EAAE;AAClI,EAAE,OAAO,KAAK,CAAC;AACf,EAAE;AACF;AACA;AACA;AACA,CAAC,OAAO,CAAC,OAAO,QAAQ,KAAK,WAAW,IAAI,QAAQ,CAAC,eAAe,IAAI,QAAQ,CAAC,eAAe,CAAC,KAAK,IAAI,QAAQ,CAAC,eAAe,CAAC,KAAK,CAAC,gBAAgB;AACzJ;AACA,GAAG,OAAO,MAAM,KAAK,WAAW,IAAI,MAAM,CAAC,OAAO,KAAK,MAAM,CAAC,OAAO,CAAC,OAAO,KAAK,MAAM,CAAC,OAAO,CAAC,SAAS,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;AACrI;AACA;AACA,GAAG,OAAO,SAAS,KAAK,WAAW,IAAI,SAAS,CAAC,SAAS,IAAI,SAAS,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,gBAAgB,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC;AACzJ;AACA,GAAG,OAAO,SAAS,KAAK,WAAW,IAAI,SAAS,CAAC,SAAS,IAAI,SAAS,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAC;AAC7H,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,UAAU,CAAC,IAAI,EAAE;AAC1B,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,EAAE;AACtC,EAAE,IAAI,CAAC,SAAS;AAChB,GAAG,IAAI,CAAC,SAAS,GAAG,KAAK,GAAG,GAAG,CAAC;AAChC,EAAE,IAAI,CAAC,CAAC,CAAC;AACT,GAAG,IAAI,CAAC,SAAS,GAAG,KAAK,GAAG,GAAG,CAAC;AAChC,EAAE,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC3C;AACA,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;AACtB,EAAE,OAAO;AACT,EAAE;AACF;AACA,CAAC,MAAM,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC;AAClC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,gBAAgB,CAAC,CAAC;AACxC;AACA;AACA;AACA;AACA,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC;AACf,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC;AACf,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,EAAE,KAAK,IAAI;AACzC,EAAE,IAAI,KAAK,KAAK,IAAI,EAAE;AACtB,GAAG,OAAO;AACV,GAAG;AACH,EAAE,KAAK,EAAE,CAAC;AACV,EAAE,IAAI,KAAK,KAAK,IAAI,EAAE;AACtB;AACA;AACA,GAAG,KAAK,GAAG,KAAK,CAAC;AACjB,GAAG;AACH,EAAE,CAAC,CAAC;AACJ;AACA,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAC1B,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,GAAG,KAAK,MAAM,EAAE,CAAC,CAAC;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI,CAAC,UAAU,EAAE;AAC1B,CAAC,IAAI;AACL,EAAE,IAAI,UAAU,EAAE;AAClB,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;AAChD,GAAG,MAAM;AACT,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;AACvC,GAAG;AACH,EAAE,CAAC,OAAO,KAAK,EAAE;AACjB;AACA;AACA,EAAE;AACF,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI,GAAG;AAChB,CAAC,IAAI,CAAC,CAAC;AACP,CAAC,IAAI;AACL,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;AACvC,EAAE,CAAC,OAAO,KAAK,EAAE;AACjB;AACA;AACA,EAAE;AACF;AACA;AACA,CAAC,IAAI,CAAC,CAAC,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,KAAK,IAAI,OAAO,EAAE;AAC/D,EAAE,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC;AACxB,EAAE;AACF;AACA,CAAC,OAAO,CAAC,CAAC;AACV,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,YAAY,GAAG;AACxB,CAAC,IAAI;AACL;AACA;AACA,EAAE,OAAO,YAAY,CAAC;AACtB,EAAE,CAAC,OAAO,KAAK,EAAE;AACjB;AACA;AACA,EAAE;AACF,CAAC;AACD;AACA,cAAc,GAAGA,MAAmB,CAAC,OAAO,CAAC,CAAC;AAC9C;AACA,MAAM,CAAC,UAAU,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC;AACpC;AACA;AACA;AACA;AACA;AACA,UAAU,CAAC,CAAC,GAAG,UAAU,CAAC,EAAE;AAC5B,CAAC,IAAI;AACL,EAAE,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAC3B,EAAE,CAAC,OAAO,KAAK,EAAE;AACjB,EAAE,OAAO,8BAA8B,GAAG,KAAK,CAAC,OAAO,CAAC;AACxD,EAAE;AACF,CAAC;;;AC1QD,WAAc,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,KAAK;AAChD,CAAC,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC,CAAC;AAC7E,CAAC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;AAC9C,CAAC,MAAM,kBAAkB,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAC/C,CAAC,OAAO,QAAQ,KAAK,CAAC,CAAC,KAAK,kBAAkB,KAAK,CAAC,CAAC,IAAI,QAAQ,GAAG,kBAAkB,CAAC,CAAC;AACxF,CAAC;;ACFD,MAAM,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC;AACtB;AACA,IAAI,UAAU,CAAC;AACf,IAAI,OAAO,CAAC,UAAU,CAAC;AACvB,CAAC,OAAO,CAAC,WAAW,CAAC;AACrB,CAAC,OAAO,CAAC,aAAa,CAAC;AACvB,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE;AACzB,CAAC,UAAU,GAAG,CAAC,CAAC;AAChB,CAAC,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;AAC3B,CAAC,OAAO,CAAC,QAAQ,CAAC;AAClB,CAAC,OAAO,CAAC,YAAY,CAAC;AACtB,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE;AAC1B,CAAC,UAAU,GAAG,CAAC,CAAC;AAChB,CAAC;AACD;AACA,IAAI,aAAa,IAAI,GAAG,EAAE;AAC1B,CAAC,IAAI,GAAG,CAAC,WAAW,KAAK,MAAM,EAAE;AACjC,EAAE,UAAU,GAAG,CAAC,CAAC;AACjB,EAAE,MAAM,IAAI,GAAG,CAAC,WAAW,KAAK,OAAO,EAAE;AACzC,EAAE,UAAU,GAAG,CAAC,CAAC;AACjB,EAAE,MAAM;AACR,EAAE,UAAU,GAAG,GAAG,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAC7F,EAAE;AACF,CAAC;AACD;AACA,SAAS,cAAc,CAAC,KAAK,EAAE;AAC/B,CAAC,IAAI,KAAK,KAAK,CAAC,EAAE;AAClB,EAAE,OAAO,KAAK,CAAC;AACf,EAAE;AACF;AACA,CAAC,OAAO;AACR,EAAE,KAAK;AACP,EAAE,QAAQ,EAAE,IAAI;AAChB,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;AACpB,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;AACpB,EAAE,CAAC;AACH,CAAC;AACD;AACA,SAAS,aAAa,CAAC,UAAU,EAAE,WAAW,EAAE;AAChD,CAAC,IAAI,UAAU,KAAK,CAAC,EAAE;AACvB,EAAE,OAAO,CAAC,CAAC;AACX,EAAE;AACF;AACA,CAAC,IAAI,OAAO,CAAC,WAAW,CAAC;AACzB,EAAE,OAAO,CAAC,YAAY,CAAC;AACvB,EAAE,OAAO,CAAC,iBAAiB,CAAC,EAAE;AAC9B,EAAE,OAAO,CAAC,CAAC;AACX,EAAE;AACF;AACA,CAAC,IAAI,OAAO,CAAC,WAAW,CAAC,EAAE;AAC3B,EAAE,OAAO,CAAC,CAAC;AACX,EAAE;AACF;AACA,CAAC,IAAI,UAAU,IAAI,CAAC,WAAW,IAAI,UAAU,KAAK,SAAS,EAAE;AAC7D,EAAE,OAAO,CAAC,CAAC;AACX,EAAE;AACF;AACA,CAAC,MAAM,GAAG,GAAG,UAAU,IAAI,CAAC,CAAC;AAC7B;AACA,CAAC,IAAI,GAAG,CAAC,IAAI,KAAK,MAAM,EAAE;AAC1B,EAAE,OAAO,GAAG,CAAC;AACb,EAAE;AACF;AACA,CAAC,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,EAAE;AACnC;AACA;AACA,EAAE,MAAM,SAAS,GAAGC,sBAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAC5C,EAAE;AACF,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;AAC7B,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK;AAChC,IAAI;AACJ,GAAG,OAAO,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC;AAChD,GAAG;AACH;AACA,EAAE,OAAO,CAAC,CAAC;AACX,EAAE;AACF;AACA,CAAC,IAAI,IAAI,IAAI,GAAG,EAAE;AAClB,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,gBAAgB,EAAE,WAAW,CAAC,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,GAAG,CAAC,IAAI,GAAG,CAAC,OAAO,KAAK,UAAU,EAAE;AAC9I,GAAG,OAAO,CAAC,CAAC;AACZ,GAAG;AACH;AACA,EAAE,OAAO,GAAG,CAAC;AACb,EAAE;AACF;AACA,CAAC,IAAI,kBAAkB,IAAI,GAAG,EAAE;AAChC,EAAE,OAAO,+BAA+B,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC5E,EAAE;AACF;AACA,CAAC,IAAI,GAAG,CAAC,SAAS,KAAK,WAAW,EAAE;AACpC,EAAE,OAAO,CAAC,CAAC;AACX,EAAE;AACF;AACA,CAAC,IAAI,cAAc,IAAI,GAAG,EAAE;AAC5B,EAAE,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,GAAG,CAAC,oBAAoB,IAAI,EAAE,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAC/E;AACA,EAAE,QAAQ,GAAG,CAAC,YAAY;AAC1B,GAAG,KAAK,WAAW;AACnB,IAAI,OAAO,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAChC,GAAG,KAAK,gBAAgB;AACxB,IAAI,OAAO,CAAC,CAAC;AACb;AACA,GAAG;AACH,EAAE;AACF;AACA,CAAC,IAAI,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;AACtC,EAAE,OAAO,CAAC,CAAC;AACX,EAAE;AACF;AACA,CAAC,IAAI,6DAA6D,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;AACnF,EAAE,OAAO,CAAC,CAAC;AACX,EAAE;AACF;AACA,CAAC,IAAI,WAAW,IAAI,GAAG,EAAE;AACzB,EAAE,OAAO,CAAC,CAAC;AACX,EAAE;AACF;AACA,CAAC,OAAO,GAAG,CAAC;AACZ,CAAC;AACD;AACA,SAAS,eAAe,CAAC,MAAM,EAAE;AACjC,CAAC,MAAM,KAAK,GAAG,aAAa,CAAC,MAAM,EAAE,MAAM,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;AAC7D,CAAC,OAAO,cAAc,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC;AACD;AACA,mBAAc,GAAG;AACjB,CAAC,aAAa,EAAE,eAAe;AAC/B,CAAC,MAAM,EAAE,cAAc,CAAC,aAAa,CAAC,IAAI,EAAEC,uBAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3D,CAAC,MAAM,EAAE,cAAc,CAAC,aAAa,CAAC,IAAI,EAAEA,uBAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3D,CAAC;;;ACtID;AACA;AACA;AACA;AAC2B;AACE;AAC7B;AACA;AACA;AACA;AACA;AACA,YAAY,GAAG,IAAI,CAAC;AACpB,WAAW,GAAG,GAAG,CAAC;AAClB,kBAAkB,GAAG,UAAU,CAAC;AAChC,YAAY,GAAG,IAAI,CAAC;AACpB,YAAY,GAAG,IAAI,CAAC;AACpB,iBAAiB,GAAG,SAAS,CAAC;AAC9B,eAAe,GAAGC,wBAAI,CAAC,SAAS;AAChC,CAAC,MAAM,EAAE;AACT,CAAC,uIAAuI;AACxI,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA,cAAc,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AACpC;AACA,IAAI;AACJ;AACA;AACA,CAAC,MAAM,aAAa,GAAGH,eAAyB,CAAC;AACjD;AACA,CAAC,IAAI,aAAa,IAAI,CAAC,aAAa,CAAC,MAAM,IAAI,aAAa,EAAE,KAAK,IAAI,CAAC,EAAE;AAC1E,EAAE,cAAc,GAAG;AACnB,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,EAAE;AACL,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,GAAG;AACN,GAAG,CAAC;AACJ,EAAE;AACF,CAAC,CAAC,OAAO,KAAK,EAAE;AAChB;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,IAAI;AAC7D,CAAC,OAAO,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK;AACxB;AACA,CAAC,MAAM,IAAI,GAAG,GAAG;AACjB,GAAG,SAAS,CAAC,CAAC,CAAC;AACf,GAAG,WAAW,EAAE;AAChB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK;AAClC,GAAG,OAAO,CAAC,CAAC,WAAW,EAAE,CAAC;AAC1B,GAAG,CAAC,CAAC;AACL;AACA;AACA,CAAC,IAAI,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC5B,CAAC,IAAI,0BAA0B,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;AAC3C,EAAE,GAAG,GAAG,IAAI,CAAC;AACb,EAAE,MAAM,IAAI,4BAA4B,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;AACpD,EAAE,GAAG,GAAG,KAAK,CAAC;AACd,EAAE,MAAM,IAAI,GAAG,KAAK,MAAM,EAAE;AAC5B,EAAE,GAAG,GAAG,IAAI,CAAC;AACb,EAAE,MAAM;AACR,EAAE,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AACpB,EAAE;AACF;AACA,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC;AACjB,CAAC,OAAO,GAAG,CAAC;AACZ,CAAC,EAAE,EAAE,CAAC,CAAC;AACP;AACA;AACA;AACA;AACA;AACA,SAAS,SAAS,GAAG;AACrB,CAAC,OAAO,QAAQ,IAAI,OAAO,CAAC,WAAW;AACvC,EAAE,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC;AACrC,EAAEE,uBAAG,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAChC,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,UAAU,CAAC,IAAI,EAAE;AAC1B,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,EAAE,SAAS,CAAC,GAAG,IAAI,CAAC;AAC3C;AACA,CAAC,IAAI,SAAS,EAAE;AAChB,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC;AACvB,EAAE,MAAM,SAAS,GAAG,UAAU,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC;AAC1D,EAAE,MAAM,MAAM,GAAG,CAAC,EAAE,EAAE,SAAS,CAAC,GAAG,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;AACtD;AACA,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;AAC7D,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,CAAC;AACjF,EAAE,MAAM;AACR,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;AAC7C,EAAE;AACF,CAAC;AACD;AACA,SAAS,OAAO,GAAG;AACnB,CAAC,IAAI,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE;AACnC,EAAE,OAAO,EAAE,CAAC;AACZ,EAAE;AACF,CAAC,OAAO,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC;AACvC,CAAC;AACD;AACA;AACA;AACA;AACA;AACA,SAAS,GAAG,CAAC,GAAG,IAAI,EAAE;AACtB,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,CAACC,wBAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;AAC1D,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI,CAAC,UAAU,EAAE;AAC1B,CAAC,IAAI,UAAU,EAAE;AACjB,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,UAAU,CAAC;AACjC,EAAE,MAAM;AACR;AACA;AACA,EAAE,OAAO,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC;AAC3B,EAAE;AACF,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI,GAAG;AAChB,CAAC,OAAO,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC;AAC1B,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI,CAAC,KAAK,EAAE;AACrB,CAAC,KAAK,CAAC,WAAW,GAAG,EAAE,CAAC;AACxB;AACA,CAAC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;AAC/C,CAAC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AACvC,EAAE,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AAC5D,EAAE;AACF,CAAC;AACD;AACA,cAAc,GAAGC,MAAmB,CAAC,OAAO,CAAC,CAAC;AAC9C;AACA,MAAM,CAAC,UAAU,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC;AACpC;AACA;AACA;AACA;AACA;AACA,UAAU,CAAC,CAAC,GAAG,UAAU,CAAC,EAAE;AAC5B,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC;AAC1C,CAAC,OAAOD,wBAAI,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC;AACzC,GAAG,KAAK,CAAC,IAAI,CAAC;AACd,GAAG,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,EAAE,CAAC;AACzB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;AACb,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA,UAAU,CAAC,CAAC,GAAG,UAAU,CAAC,EAAE;AAC5B,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC;AAC1C,CAAC,OAAOA,wBAAI,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;AAC1C,CAAC;;;;ACtQD;AACA;AACA;AACA;AACA;AACA,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU,IAAI,OAAO,CAAC,OAAO,KAAK,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE;AACjH,CAAC,cAAc,GAAGH,OAAuB,CAAC;AAC1C,CAAC,MAAM;AACP,CAAC,cAAc,GAAGI,IAAoB,CAAC;AACvC;;;;ACRA,IAAI,eAAe,GAAG,CAACC,cAAI,IAAIA,cAAI,CAAC,eAAe,KAAK,UAAU,GAAG,EAAE;AACvE,IAAI,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;AAC9D,CAAC,CAAC;AACF,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AACnC;AAC3B,MAAM,OAAO,GAAG,eAAe,CAACL,KAAgB,CAAC,CAAC;AAClD,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC;AACpD,SAAS,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE;AAC1C,IAAI,GAAG,CAAC,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC,CAAC;AAC7B,IAAI,IAAI;AACR,QAAQ,MAAM,IAAI,GAAGM,wBAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AACzC,QAAQ,IAAI,IAAI,CAAC,MAAM,EAAE,IAAI,MAAM,EAAE;AACrC,YAAY,GAAG,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAAC;AAC/C,YAAY,OAAO,IAAI,CAAC;AACxB,SAAS;AACT,QAAQ,IAAI,IAAI,CAAC,WAAW,EAAE,IAAI,WAAW,EAAE;AAC/C,YAAY,GAAG,CAAC,CAAC,gCAAgC,CAAC,CAAC,CAAC;AACpD,YAAY,OAAO,IAAI,CAAC;AACxB,SAAS;AACT,QAAQ,GAAG,CAAC,CAAC,+DAA+D,CAAC,CAAC,CAAC;AAC/E,QAAQ,OAAO,KAAK,CAAC;AACrB,KAAK;AACL,IAAI,OAAO,CAAC,EAAE;AACd,QAAQ,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,EAAE;AACjC,YAAY,GAAG,CAAC,CAAC,iCAAiC,CAAC,EAAE,CAAC,CAAC,CAAC;AACxD,YAAY,OAAO,KAAK,CAAC;AACzB,SAAS;AACT,QAAQ,GAAG,CAAC,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC;AAC7B,QAAQ,MAAM,CAAC,CAAC;AAChB,KAAK;AACL,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,QAAQ,EAAE;AAC/C,IAAI,OAAO,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,IAAI,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC;AAC/E,CAAC;AACD,cAAc,GAAG,MAAM,CAAC;AACxB;AACA;AACA;AACA,YAAY,GAAG,CAAC,CAAC;AACjB;AACA;AACA;AACA,cAAc,GAAG,CAAC,CAAC;AACnB;AACA;AACA;AACA,gBAAgB,GAAG,OAAO,CAAC,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;AACjD;;;;ACrDA,SAAS,QAAQ,CAAC,CAAC,EAAE;AACrB,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACvE,CAAC;AACD,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,QAAQ,CAACN,KAAgB,CAAC,CAAC;AAC3B;;;;ACLA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,sBAAsB,GAAG,qBAAqB,GAAG,gBAAgB,GAAG,qBAAqB,GAAG,eAAe,GAAG,sBAAsB,GAAG,cAAc,GAAG,iBAAiB,GAAG,cAAc,GAAG,oBAAoB,GAAG,8BAA8B,GAAG,0BAA0B,GAAG,YAAY,GAAG,aAAa,GAAG,eAAe,GAAG,sBAAsB,GAAG,kBAAkB,GAAG,YAAY,GAAG,KAAK,CAAC,CAAC;AACjV;AACtD,MAAM,IAAI,GAAG,MAAM;AACnB,CAAC,CAAC;AACF,YAAY,GAAG,IAAI,CAAC;AACpB;AACA;AACA;AACA;AACA,SAAS,UAAU,CAAC,MAAM,EAAE;AAC5B,IAAI,OAAO,OAAO,MAAM,KAAK,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;AAChE,CAAC;AACD,kBAAkB,GAAG,UAAU,CAAC;AAChC;AACA;AACA;AACA;AACA,SAAS,cAAc,CAAC,MAAM,EAAE;AAChC,IAAI,QAAQ,OAAO,MAAM,KAAK,UAAU,IAAI,MAAM,KAAK,OAAO,CAAC,IAAI,EAAE;AACrE,CAAC;AACD,sBAAsB,GAAG,cAAc,CAAC;AACxC,SAAS,OAAO,CAAC,KAAK,EAAE,IAAI,EAAE;AAC9B,IAAI,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AACtC,IAAI,IAAI,KAAK,IAAI,CAAC,EAAE;AACpB,QAAQ,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;AAC3B,KAAK;AACL,IAAI,OAAO;AACX,QAAQ,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC;AAC9B,QAAQ,KAAK,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC;AAC/B,KAAK,CAAC;AACN,CAAC;AACD,eAAe,GAAG,OAAO,CAAC;AAC1B,SAAS,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,EAAE;AAClC,IAAI,OAAO,WAAW,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;AACnF,CAAC;AACD,aAAa,GAAG,KAAK,CAAC;AACtB,SAAS,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,EAAE;AACjC,IAAI,IAAI,WAAW,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,MAAM,EAAE;AACrD,QAAQ,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;AAChD,KAAK;AACL,CAAC;AACD,YAAY,GAAG,IAAI,CAAC;AACpB,SAAS,WAAW,CAAC,KAAK,EAAE;AAC5B,IAAI,OAAO,CAAC,EAAE,KAAK,IAAI,OAAO,KAAK,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC;AACzD,CAAC;AACD,SAAS,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,EAAE,SAAS,GAAG,IAAI,EAAE;AACrE,IAAI,OAAO,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC;AACjC,SAAS,MAAM,CAAC,CAAC,MAAM,EAAE,IAAI,KAAK;AAClC,QAAQ,MAAM,WAAW,GAAG,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC;AACzD,QAAQ,IAAI,WAAW,EAAE;AACzB,YAAY,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;AACrC,SAAS;AACT,QAAQ,OAAO,MAAM,CAAC;AACtB,KAAK,EAAE,EAAE,CAAC,CAAC;AACX,CAAC;AACD,0BAA0B,GAAG,kBAAkB,CAAC;AAChD,SAAS,sBAAsB,CAAC,KAAK,EAAE,QAAQ,EAAE;AACjD,IAAI,OAAO,kBAAkB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AACvE,CAAC;AACD,8BAA8B,GAAG,sBAAsB,CAAC;AACxD,SAAS,YAAY,CAAC,IAAI,EAAE;AAC5B,IAAI,OAAOO,MAAa,CAAC,MAAM,CAAC,IAAI,EAAEA,MAAa,CAAC,MAAM,CAAC,CAAC;AAC5D,CAAC;AACD,oBAAoB,GAAG,YAAY,CAAC;AACpC;AACA;AACA;AACA,SAAS,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE;AAC9B,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;AAC/B,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;AACpC,YAAY,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC9B,SAAS;AACT,KAAK;AACL,SAAS;AACT,QAAQ,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACzB,KAAK;AACL,IAAI,OAAO,IAAI,CAAC;AAChB,CAAC;AACD,cAAc,GAAG,MAAM,CAAC;AACxB;AACA;AACA;AACA,SAAS,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE;AACjC,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;AACzD,QAAQ,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,KAAK;AACL,IAAI,OAAO,MAAM,CAAC;AAClB,CAAC;AACD,iBAAiB,GAAG,SAAS,CAAC;AAC9B,SAAS,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE;AAC9B,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;AAC/B,QAAQ,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAC3C,QAAQ,IAAI,KAAK,IAAI,CAAC,EAAE;AACxB,YAAY,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;AACpC,SAAS;AACT,KAAK;AACL,SAAS;AACT,QAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAC5B,KAAK;AACL,IAAI,OAAO,IAAI,CAAC;AAChB,CAAC;AACD,cAAc,GAAG,MAAM,CAAC;AACxB,sBAAsB,GAAG,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;AACxF,SAAS,OAAO,CAAC,MAAM,EAAE;AACzB,IAAI,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,CAAC,MAAM,CAAC,CAAC;AACrD,CAAC;AACD,eAAe,GAAG,OAAO,CAAC;AAC1B,SAAS,aAAa,CAAC,MAAM,EAAE;AAC/B,IAAI,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AACvC,CAAC;AACD,qBAAqB,GAAG,aAAa,CAAC;AACtC,SAAS,QAAQ,CAAC,MAAM,EAAE,KAAK,GAAG,CAAC,EAAE;AACrC,IAAI,IAAI,MAAM,IAAI,IAAI,EAAE;AACxB,QAAQ,OAAO,KAAK,CAAC;AACrB,KAAK;AACL,IAAI,MAAM,GAAG,GAAG,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AACrC,IAAI,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,GAAG,GAAG,CAAC;AACpC,CAAC;AACD,gBAAgB,GAAG,QAAQ,CAAC;AAC5B,SAAS,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE;AACtC,IAAI,MAAM,MAAM,GAAG,EAAE,CAAC;AACtB,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;AACtD,QAAQ,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACtC,KAAK;AACL,IAAI,OAAO,MAAM,CAAC;AAClB,CAAC;AACD,qBAAqB,GAAG,aAAa,CAAC;AACtC,SAAS,cAAc,CAAC,KAAK,EAAE;AAC/B,IAAI,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;AACnF,CAAC;AACD,sBAAsB,GAAG,cAAc,CAAC;AACxC;;;;ACpIA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,uBAAuB,GAAG,sBAAsB,GAAG,yBAAyB,GAAG,iCAAiC,GAAG,yBAAyB,GAAG,oBAAoB,GAAG,wBAAwB,GAAG,mBAAmB,GAAG,kBAAkB,GAAG,KAAK,CAAC,CAAC;AAClN;AACjC,SAAS,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE;AACxC,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE;AACvB,QAAQ,OAAO,KAAK,CAAC;AACrB,KAAK;AACL,IAAI,OAAO,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,IAAI,GAAG,GAAG,SAAS,CAAC;AACpD,CAAC;AACD,kBAAkB,GAAG,UAAU,CAAC;AAChC,MAAM,WAAW,GAAG,CAAC,KAAK,KAAK;AAC/B,IAAI,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAChC,CAAC,CAAC;AACF,mBAAmB,GAAG,WAAW,CAAC;AAClC,SAAS,gBAAgB,CAAC,KAAK,EAAE,IAAI,EAAE;AACvC,IAAI,OAAO,uBAAuB,CAAC,IAAI,CAAC,OAAO,KAAK,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,KAAK,EAAE,CAAC,CAAC;AACnG,CAAC;AACD,wBAAwB,GAAG,gBAAgB,CAAC;AAC5C,MAAM,YAAY,GAAG,CAAC,KAAK,KAAK;AAChC,IAAI,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC;AACrC,CAAC,CAAC;AACF,oBAAoB,GAAG,YAAY,CAAC;AACpC,MAAM,iBAAiB,GAAG,CAAC,KAAK,KAAK;AACrC,IAAI,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;AACrE,CAAC,CAAC;AACF,yBAAyB,GAAG,iBAAiB,CAAC;AAC9C,MAAM,yBAAyB,GAAG,CAAC,KAAK,KAAK;AAC7C,IAAI,OAAO,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;AACtG,CAAC,CAAC;AACF,iCAAiC,GAAG,yBAAyB,CAAC;AAC9D,SAAS,iBAAiB,CAAC,KAAK,EAAE;AAClC,IAAI,OAAO,CAAC,CAAC,KAAK,IAAIC,IAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,iBAAiB,CAAC;AACzE,CAAC;AACD,yBAAyB,GAAG,iBAAiB,CAAC;AAC9C,SAAS,cAAc,CAAC,KAAK,EAAE;AAC/B,IAAI,OAAO,OAAO,KAAK,KAAK,UAAU,CAAC;AACvC,CAAC;AACD,sBAAsB,GAAG,cAAc,CAAC;AACxC,MAAM,eAAe,GAAG,CAAC,KAAK,KAAK;AACnC,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,yBAAyB,CAAC,QAAQ,CAAC,OAAO,KAAK,CAAC,EAAE;AAC3E,QAAQ,OAAO,KAAK,CAAC;AACrB,KAAK;AACL,IAAI,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,CAAC,MAAM,KAAK,QAAQ,CAAC;AACjG,CAAC,CAAC;AACF,uBAAuB,GAAG,eAAe,CAAC;AAC1C;;;;AC7CA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,iBAAiB,GAAG,KAAK,CAAC,CAAC;AAM3B,CAAC,UAAU,SAAS,EAAE;AACtB,IAAI,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC;AACpD,IAAI,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC;AAChD,IAAI,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC,GAAG,SAAS,CAAC;AACtD,CAAC,EAAc,OAAO,CAAC,SAAS,KAAK,iBAAiB,GAAG,EAAE,CAAC,CAAC,CAAC;AAC9D;;;;ACZA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,wBAAwB,GAAG,KAAK,CAAC,CAAC;AAClC,MAAM,gBAAgB,CAAC;AACvB,IAAI,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE;AAChC,QAAQ,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;AAC7B,QAAQ,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;AAC7B,KAAK;AACL,IAAI,SAAS,GAAG;AAChB,QAAQ,OAAO,IAAI,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;AAChG,KAAK;AACL,CAAC;AACD,wBAAwB,GAAG,gBAAgB,CAAC;AAC5C;;;;ACZA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,wBAAwB,GAAG,kBAAkB,GAAG,KAAK,CAAC,CAAC;AACvD,MAAM,UAAU,CAAC;AACjB,IAAI,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE;AACpC,QAAQ,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;AAC1B,QAAQ,IAAI,CAAC,KAAK,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK;AACvC,YAAY,IAAI,CAAC,YAAY,EAAE,CAAC;AAChC,YAAY,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;AAC7F,gBAAgB,OAAO,KAAK,CAAC;AAC7B,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC,KAAK,KAAK,CAAC;AAC5E,SAAS,CAAC;AACV,QAAQ,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,CAAC,MAAM,CAAC,CAAC;AACjE,QAAQ,IAAI,UAAU,EAAE;AACxB,YAAY,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;AACzC,SAAS;AACT,KAAK;AACL;AACA,IAAI,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE;AAC9B,QAAQ,MAAM,IAAI,KAAK,CAAC,CAAC,qCAAqC,CAAC,CAAC,CAAC;AACjE,KAAK;AACL,IAAI,YAAY,GAAG;AACnB,QAAQ,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;AAChC,KAAK;AACL,IAAI,cAAc,GAAG;AACrB,QAAQ,OAAO,IAAI,CAAC,OAAO,CAAC;AAC5B,KAAK;AACL,IAAI,QAAQ,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE;AAC/B,QAAQ,MAAM,OAAO,GAAG,IAAI,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC/C,QAAQ,IAAI,OAAO,EAAE;AACrB,YAAY,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AAC3C,SAAS;AACT,QAAQ,OAAO,CAAC,CAAC,OAAO,CAAC;AACzB,KAAK;AACL,IAAI,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE;AAC/B,QAAQ,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/C,KAAK;AACL,CAAC;AACD,kBAAkB,GAAG,UAAU,CAAC;AAChC,MAAM,gBAAgB,SAAS,UAAU,CAAC;AAC1C,IAAI,QAAQ,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE;AAC/B,QAAQ,OAAO,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;AACnF,KAAK;AACL,IAAI,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE;AAC9B,QAAQ,IAAI,KAAK,GAAG,CAAC,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;AAC7C,YAAY,KAAK,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AAC5C,SAAS;AACT,KAAK;AACL,CAAC;AACD,wBAAwB,GAAG,gBAAgB,CAAC;AAC5C;;;;AClDA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,4BAA4B,GAAG,KAAK,CAAC,CAAC;AACtC,MAAM,cAAc,GAAG;AACvB,IAAI,MAAM,EAAE,KAAK;AACjB,IAAI,sBAAsB,EAAE,CAAC;AAC7B,IAAI,MAAM,EAAE,EAAE;AACd,CAAC,CAAC;AACF,SAAS,oBAAoB,CAAC,GAAG,OAAO,EAAE;AAC1C,IAAI,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;AAClC,IAAI,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,EAAE,cAAc,CAAC,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AACnI,IAAI,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,OAAO,CAAC;AAC/C,IAAI,OAAO,MAAM,CAAC;AAClB,CAAC;AACD,4BAA4B,GAAG,oBAAoB,CAAC;AACpD;;;;ACdA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,gCAAgC,GAAG,+BAA+B,GAAG,0BAA0B,GAAG,yBAAyB,GAAG,KAAK,CAAC,CAAC;AAC5E;AACxB;AACjC,SAAS,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,EAAE,EAAE;AACnD,IAAI,IAAI,CAACC,eAAkB,CAAC,iBAAiB,CAAC,OAAO,CAAC,EAAE;AACxD,QAAQ,OAAO,QAAQ,CAAC;AACxB,KAAK;AACL,IAAI,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,GAAG,KAAK;AAC1D,QAAQ,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AACnC,QAAQ,IAAIA,eAAkB,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE;AACrE,YAAY,QAAQ,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,KAAK,CAAC,CAAC;AAC7C,SAAS;AACT,aAAa;AACb,YAAY,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC/B,SAAS;AACT,QAAQ,OAAO,QAAQ,CAAC;AACxB,KAAK,EAAE,QAAQ,CAAC,CAAC;AACjB,CAAC;AACD,yBAAyB,GAAG,iBAAiB,CAAC;AAC9C,SAAS,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,GAAG,CAAC,EAAE,UAAU,GAAG,KAAK,EAAE;AAC5E,IAAI,MAAM,OAAO,GAAG,EAAE,CAAC;AACvB,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,gBAAgB,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,gBAAgB,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;AAC/F,QAAQ,IAAI,eAAe,CAAC,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE;AACtD,YAAY,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1C,SAAS;AACT,KAAK;AACL,IAAI,iBAAiB,CAAC,uBAAuB,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;AAC9D,IAAI,IAAI,CAAC,UAAU,EAAE;AACrB,QAAQ,OAAO,CAAC,IAAI,CAAC,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC,CAAC;AACrD,KAAK;AACL,IAAI,OAAO,OAAO,CAAC;AACnB,CAAC;AACD,0BAA0B,GAAG,kBAAkB,CAAC;AAChD,SAAS,qBAAqB,CAAC,IAAI,EAAE;AACrC,IAAI,MAAM,mBAAmB,GAAG,OAAOD,IAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,UAAU,CAAC;AACxE,IAAI,OAAOC,eAAkB,CAAC,UAAU,CAACD,IAAM,CAAC,IAAI,CAAC,IAAI,EAAE,mBAAmB,GAAG,CAAC,GAAG,CAAC,CAAC,EAAEC,eAAkB,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;AAC7H,CAAC;AACD;AACA;AACA;AACA;AACA,SAAS,uBAAuB,CAAC,IAAI,EAAE;AACvC,IAAI,MAAM,mBAAmB,GAAGA,eAAkB,CAAC,cAAc,CAACD,IAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;AACrF,IAAI,OAAOC,eAAkB,CAAC,UAAU,CAACD,IAAM,CAAC,IAAI,CAAC,IAAI,EAAE,mBAAmB,GAAG,CAAC,GAAG,CAAC,CAAC,EAAEC,eAAkB,CAAC,iBAAiB,CAAC,CAAC;AAC/H,CAAC;AACD,+BAA+B,GAAG,uBAAuB,CAAC;AAC1D;AACA;AACA;AACA;AACA,SAAS,wBAAwB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,EAAE;AAC5D,IAAI,MAAM,QAAQ,GAAGD,IAAM,CAAC,UAAU,CAACA,IAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;AAC1D,IAAI,OAAO,WAAW,IAAIA,IAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG,QAAQ,GAAG,SAAS,CAAC;AACjF,CAAC;AACD,gCAAgC,GAAG,wBAAwB,CAAC;AAC5D;;;;ACxDA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,2BAA2B,GAAG,sBAAsB,GAAG,KAAK,CAAC,CAAC;AAC7B;AACjC,SAAS,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE;AACzC,IAAI,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;AAClD,CAAC;AACD,sBAAsB,GAAG,cAAc,CAAC;AACxC,SAAS,mBAAmB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK,EAAE;AACxD,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,IAAI;AAC1B,QAAQ,KAAK,IAAI,KAAK,GAAGA,IAAM,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;AACnG,YAAY,MAAM,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,KAAK;AACzC,gBAAgB,IAAI,CAAC,CAAC,GAAG,MAAM,KAAK,GAAG,EAAE;AACzC,oBAAoB,OAAO;AAC3B,iBAAiB;AACjB,gBAAgB,OAAO,KAAK,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC;AACzC,aAAa,CAAC;AACd,YAAY,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;AAC7D,SAAS;AACT,KAAK,CAAC,CAAC;AACP,IAAI,OAAO,MAAM,CAAC;AAClB,CAAC;AACD,2BAA2B,GAAG,mBAAmB,CAAC;AAClD;;;;ACtBA,IAAI,eAAe,GAAG,CAACH,cAAI,IAAIA,cAAI,CAAC,eAAe,MAAM,MAAM,CAAC,MAAM,IAAI,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE;AAChG,IAAI,IAAI,EAAE,KAAK,SAAS,EAAE,EAAE,GAAG,CAAC,CAAC;AACjC,IAAI,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AACzF,CAAC,KAAK,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE;AAC5B,IAAI,IAAI,EAAE,KAAK,SAAS,EAAE,EAAE,GAAG,CAAC,CAAC;AACjC,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACjB,CAAC,CAAC,CAAC,CAAC;AACJ,IAAI,YAAY,GAAG,CAACA,cAAI,IAAIA,cAAI,CAAC,YAAY,KAAK,SAAS,CAAC,EAAE,OAAO,EAAE;AACvE,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,eAAe,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAC9H,CAAC,CAAC;AACF,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,YAAY,CAACL,eAA6B,EAAE,OAAO,CAAC,CAAC;AACrD,YAAY,CAACI,SAAuB,EAAE,OAAO,CAAC,CAAC;AAC/C,YAAY,CAACM,gBAA+B,EAAE,OAAO,CAAC,CAAC;AACvD,YAAY,CAACC,UAAwB,EAAE,OAAO,CAAC,CAAC;AAChD,YAAY,CAACC,gBAA+B,EAAE,OAAO,CAAC,CAAC;AACvD,YAAY,CAACC,WAAyB,EAAE,OAAO,CAAC,CAAC;AACjD,YAAY,CAACC,UAAwB,EAAE,OAAO,CAAC,CAAC;AAChD,YAAY,CAACC,IAAiB,EAAE,OAAO,CAAC,CAAC;AACzC;;;;ACnBA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,2BAA2B,GAAG,2BAA2B,GAAG,uBAAuB,GAAG,wBAAwB,GAAG,KAAK,CAAC,CAAC;AACpF;AACpC,IAAI,gBAAgB,CAAC;AACrB,CAAC,UAAU,gBAAgB,EAAE;AAC7B,IAAI,gBAAgB,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;AACtC,IAAI,gBAAgB,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC;AACzC,IAAI,gBAAgB,CAAC,cAAc,CAAC,GAAG,MAAM,CAAC;AAC9C,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,KAAK,wBAAwB,GAAG,EAAE,CAAC,CAAC,CAAC;AACnF,MAAM,OAAO,GAAG,CAAC,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,KAAK;AACrD,IAAI,IAAI,QAAQ,KAAKC,KAAO,CAAC,SAAS,CAAC,OAAO,IAAI,gBAAgB,CAAC,KAAK,CAAC,EAAE;AAC3E,QAAQ,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAC1C,KAAK;AACL,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;AAChB,CAAC,CAAC;AACF,MAAM,MAAM,GAAG,CAAC,IAAI,KAAK;AACzB,IAAI,OAAO,IAAI,CAAC,IAAI,EAAE,KAAK,MAAM,CAAC;AAClC,CAAC,CAAC;AACF,SAAS,eAAe,CAAC,MAAM,EAAE;AACjC,IAAI,QAAQ,MAAM;AAClB,QAAQ,KAAK,gBAAgB,CAAC,IAAI;AAClC,YAAY,OAAO,mBAAmB,EAAE,CAAC;AACzC,QAAQ,KAAK,gBAAgB,CAAC,YAAY;AAC1C,YAAY,OAAO,mBAAmB,EAAE,CAAC;AACzC,KAAK;AACL,IAAI,MAAM,QAAQ,GAAG,CAAC,WAAW,EAAE,uBAAuB,CAAC,CAAC;AAC5D,IAAI,OAAO;AACX,QAAQ,QAAQ;AAChB,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,OAAO;AACf,QAAQ,MAAM;AACd,KAAK,CAAC;AACN,CAAC;AACD,uBAAuB,GAAG,eAAe,CAAC;AAC1C,SAAS,mBAAmB,GAAG;AAC/B,IAAI,MAAM,QAAQ,GAAG,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;AAChD,IAAI,OAAO;AACX,QAAQ,QAAQ;AAChB,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,OAAO;AACf,QAAQ,MAAM,CAAC,IAAI,EAAE;AACrB,YAAY,OAAO,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;AAClD,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,2BAA2B,GAAG,mBAAmB,CAAC;AAClD,SAAS,mBAAmB,GAAG;AAC/B,IAAI,MAAM,QAAQ,GAAG,CAAC,WAAW,EAAE,sBAAsB,CAAC,CAAC;AAC3D,IAAI,OAAO;AACX,QAAQ,QAAQ;AAChB,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,OAAO;AACf,QAAQ,MAAM;AACd,KAAK,CAAC;AACN,CAAC;AACD,2BAA2B,GAAG,mBAAmB,CAAC;AAClD,SAAS,gBAAgB,CAAC,KAAK,EAAE;AACjC,IAAI,OAAO,6CAA6C,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AAC7E,CAAC;AACD;;;;AC3DA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,0BAA0B,GAAG,qBAAqB,GAAG,KAAK,CAAC,CAAC;AACxB;AACpC,MAAM,aAAa,CAAC;AACpB,IAAI,WAAW,CAAC,MAAM,EAAE;AACxB,QAAQ,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;AAC7B,QAAQ,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;AACxB,QAAQ,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;AACxB,QAAQ,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;AAC1B,KAAK;AACL,CAAC;AACD,qBAAqB,GAAG,aAAa,CAAC;AACtC,MAAM,aAAa,GAAG,aAAa,CAAC;AACpC,MAAM,mBAAmB,GAAG,sBAAsB,CAAC;AACnD,MAAM,cAAc,GAAG,KAAK,CAAC;AAC7B,SAAS,kBAAkB,CAAC,MAAM,EAAE,IAAI,EAAE;AAC1C,IAAI,MAAM,OAAO,GAAG,IAAI,aAAa,CAAC,MAAM,CAAC,CAAC;AAC9C,IAAI,MAAM,MAAM,GAAG,MAAM,GAAG,mBAAmB,GAAG,aAAa,CAAC;AAChE,IAAIA,KAAO,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,IAAI;AACrD,QAAQ,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AACjD,QAAQ,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACpC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;AACvF,KAAK,CAAC,CAAC;AACP,IAAI,OAAO,OAAO,CAAC;AACnB,CAAC;AACD,0BAA0B,GAAG,kBAAkB,CAAC;AAChD;;;;AC1BA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,mBAAmB,GAAG,oBAAoB,GAAG,iCAAiC,GAAG,iCAAiC,GAAG,8BAA8B,GAAG,qBAAqB,GAAG,sBAAsB,GAAG,KAAK,CAAC,CAAC;AAC7H;AACjF,sBAAsB,GAAG,EAAE,CAAC;AAC5B,SAAS,aAAa,CAAC,MAAM,EAAE;AAC/B,IAAI,OAAO;AACX,QAAQ,QAAQ,EAAE,OAAO,CAAC,cAAc;AACxC,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM;AACd,KAAK,CAAC;AACN,CAAC;AACD,qBAAqB,GAAG,aAAa,CAAC;AACtC,SAAS,sBAAsB,CAAC,KAAK,EAAE;AACvC,IAAI,OAAO;AACX,QAAQ,QAAQ,EAAE,OAAO,CAAC,cAAc;AACxC,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,GAAG;AACjB,YAAY,MAAM,OAAO,KAAK,KAAK,QAAQ,GAAG,IAAIC,sBAA0B,CAAC,sBAAsB,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;AACnH,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,8BAA8B,GAAG,sBAAsB,CAAC;AACxD,SAAS,yBAAyB,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,EAAE;AAC9D,IAAI,OAAO;AACX,QAAQ,QAAQ;AAChB,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,CAAC,IAAI,EAAE;AACrB,YAAY,OAAO,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC;AACxD,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,iCAAiC,GAAG,yBAAyB,CAAC;AAC9D,SAAS,yBAAyB,CAAC,QAAQ,EAAE;AAC7C,IAAI,OAAO;AACX,QAAQ,QAAQ;AAChB,QAAQ,MAAM,EAAE,QAAQ;AACxB,QAAQ,MAAM,CAAC,MAAM,EAAE;AACvB,YAAY,OAAO,MAAM,CAAC;AAC1B,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,iCAAiC,GAAG,yBAAyB,CAAC;AAC9D,SAAS,YAAY,CAAC,IAAI,EAAE;AAC5B,IAAI,OAAO,IAAI,CAAC,MAAM,KAAK,QAAQ,CAAC;AACpC,CAAC;AACD,oBAAoB,GAAG,YAAY,CAAC;AACpC,SAAS,WAAW,CAAC,IAAI,EAAE;AAC3B,IAAI,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;AACjC,CAAC;AACD,mBAAmB,GAAG,WAAW,CAAC;AAClC;;;;AClDA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,2BAA2B,GAAG,iBAAiB,GAAG,4BAA4B,GAAG,oBAAoB,GAAG,mCAAmC,GAAG,kCAAkC,GAAG,qCAAqC,GAAG,KAAK,CAAC,CAAC;AACtK;AACxB;AACH;AACjC,qCAAqC,GAAG,6CAA6C,CAAC;AACtF,kCAAkC,GAAG,mDAAmD,CAAC;AACzF,mCAAmC,GAAG,qCAAqC,CAAC;AAC5E;AACA;AACA;AACA,IAAI,YAAY,CAAC;AACjB,CAAC,UAAU,YAAY,EAAE;AACzB,IAAI,YAAY,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC;AAClC,IAAI,YAAY,CAAC,OAAO,CAAC,GAAG,GAAG,CAAC;AAChC,IAAI,YAAY,CAAC,kBAAkB,CAAC,GAAG,GAAG,CAAC;AAC3C,IAAI,YAAY,CAAC,cAAc,CAAC,GAAG,GAAG,CAAC;AACvC,IAAI,YAAY,CAAC,WAAW,CAAC,GAAG,GAAG,CAAC;AACpC,IAAI,YAAY,CAAC,OAAO,CAAC,GAAG,GAAG,CAAC;AAChC,IAAI,YAAY,CAAC,WAAW,CAAC,GAAG,GAAG,CAAC;AACpC,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,KAAK,oBAAoB,GAAG,EAAE,CAAC,CAAC,CAAC;AACvE,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,GAAGD,KAAO,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AAChG,SAAS,oBAAoB,CAAC,IAAI,EAAE,UAAU,EAAE;AAChD,IAAI,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;AAChE,IAAI,IAAI,CAAC,SAAS,EAAE;AACpB,QAAQ,OAAOE,IAAM,CAAC,sBAAsB,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC;AACjF,KAAK;AACL,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE;AACxB,QAAQ,OAAOA,IAAM,CAAC,sBAAsB,CAAC,OAAO,CAAC,2BAA2B,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;AACzG,KAAK;AACL,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC;AAChC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE;AACzC,QAAQ,OAAOA,IAAM,CAAC,sBAAsB,CAAC,OAAO,CAAC,6BAA6B,CAAC,CAAC;AACpF,KAAK;AACL,IAAI,OAAO,SAAS,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;AACzC,CAAC;AACD,4BAA4B,GAAG,oBAAoB,CAAC;AACpD,SAAS,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE;AACrC,IAAI,MAAM,QAAQ,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC;AAC1D,IAAI,OAAO;AACX,QAAQ,QAAQ;AAChB,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,CAAC,IAAI,EAAE;AACrB,YAAY,OAAOC,YAAc,CAAC,kBAAkB,CAAC,IAAI,KAAK,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAC1F,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,iBAAiB,GAAG,SAAS,CAAC;AAC9B,SAAS,mBAAmB,CAAC,KAAK,EAAE;AACpC,IAAI,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,IAAI,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;AACpF,CAAC;AACD,2BAA2B,GAAG,mBAAmB,CAAC;AAClD,SAAS,eAAe,CAAC,KAAK,EAAE;AAChC,IAAI,IAAI,SAAS,CAAC;AAClB,IAAI,IAAI,OAAO,GAAG,EAAE,CAAC;AACrB,IAAI,IAAI,KAAK,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;AACpD,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,IAAI;AAC5D,QAAQ,IAAI,WAAW,CAAC,IAAI,CAAC,EAAE;AAC/B,YAAY,SAAS,GAAG,IAAI,CAAC;AAC7B,YAAY,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC;AACnC,SAAS;AACT,aAAa;AACb,YAAY,KAAK,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AACnG,SAAS;AACT,KAAK,CAAC,CAAC;AACP,IAAI,OAAO;AACX,QAAQ,SAAS;AACjB,QAAQ,OAAO;AACf,QAAQ,KAAK;AACb,KAAK,CAAC;AACN,CAAC;AACD,SAAS,WAAW,CAAC,SAAS,EAAE;AAChC,IAAI,OAAO,SAAS,KAAK,YAAY,CAAC,KAAK,IAAI,SAAS,KAAK,YAAY,CAAC,OAAO,CAAC;AAClF,CAAC;AACD,SAAS,aAAa,CAAC,MAAM,EAAE;AAC/B,IAAI,OAAO,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/E,CAAC;AACD,SAAS,iBAAiB,CAAC,MAAM,EAAE;AACnC,IAAI,IAAI,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;AAChC,QAAQ,OAAO,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACvC,KAAK;AACL,IAAI,OAAO,MAAM,KAAK,eAAe,CAAC;AACtC,CAAC;AACD;;;;ACnFA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,oBAAoB,GAAG,iBAAiB,GAAG,iBAAiB,GAAG,KAAK,CAAC,CAAC;AACrC;AACjC,IAAI,SAAS,CAAC;AACd,CAAC,UAAU,SAAS,EAAE;AACtB,IAAI,SAAS,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;AACjC,IAAI,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;AAC/B,IAAI,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;AAC/B,IAAI,SAAS,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;AACjC,IAAI,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;AAC/B,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,KAAK,iBAAiB,GAAG,EAAE,CAAC,CAAC,CAAC;AAC9D,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;AACxD,SAAS,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE;AACrC,IAAI,MAAM,QAAQ,GAAG,CAAC,OAAO,CAAC,CAAC;AAC/B,IAAI,IAAI,gBAAgB,CAAC,IAAI,CAAC,EAAE;AAChC,QAAQ,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;AACnC,KAAK;AACL,IAAI,QAAQ,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC;AACjC,IAAI,OAAOD,IAAM,CAAC,yBAAyB,CAAC,QAAQ,CAAC,CAAC;AACtD,CAAC;AACD,iBAAiB,GAAG,SAAS,CAAC;AAC9B,SAAS,YAAY,CAAC,IAAI,EAAE;AAC5B,IAAI,IAAI,gBAAgB,CAAC,IAAI,CAAC,EAAE;AAChC,QAAQ,OAAO,IAAI,CAAC;AACpB,KAAK;AACL,IAAI,QAAQ,OAAO,IAAI;AACvB,QAAQ,KAAK,QAAQ,CAAC;AACtB,QAAQ,KAAK,WAAW;AACxB,YAAY,OAAO,SAAS,CAAC,IAAI,CAAC;AAClC,KAAK;AACL,IAAI,OAAO;AACX,CAAC;AACD,oBAAoB,GAAG,YAAY,CAAC;AACpC,SAAS,gBAAgB,CAAC,IAAI,EAAE;AAChC,IAAI,OAAO,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AACrC,CAAC;AACD;;;;ACpCA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AACQ;AACpB;AACc;AACI;AACY;AACvB;AAChB;AACA;AACzC,MAAM,GAAG,GAAG;AACZ,IAAI,gBAAgB,EAAEE,WAAe,CAAC,gBAAgB;AACtD,IAAI,YAAY,EAAEC,KAAO,CAAC,YAAY;AACtC,IAAI,iBAAiB,EAAEC,iBAAqB,CAAC,iBAAiB;AAC9D,IAAI,QAAQ,EAAEvB,QAAW,CAAC,QAAQ;AAClC,IAAI,cAAc,EAAEwB,cAAkB,CAAC,cAAc;AACrD,IAAI,gBAAgB,EAAEC,gBAAoB,CAAC,gBAAgB;AAC3D,IAAI,SAAS,EAAEC,KAAO,CAAC,SAAS;AAChC,IAAI,sBAAsB,EAAER,sBAA0B,CAAC,sBAAsB;AAC7E,CAAC,CAAC;AACF,eAAe,GAAG,GAAG,CAAC;AACtB;;;;ACpBA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,oCAAoC,GAAG,KAAK,CAAC,CAAC;AACV;AACpC,SAAS,4BAA4B,CAAC,aAAa,EAAE;AACrD,IAAI,MAAM,MAAM,GAAGD,KAAO,CAAC,aAAa,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;AAC9D,IAAI,OAAO;AACX,QAAQ,IAAI,EAAE,YAAY;AAC1B,QAAQ,MAAM,CAAC,IAAI,EAAE;AACrB,YAAY,OAAO,CAAC,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC;AACxC,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,oCAAoC,GAAG,4BAA4B,CAAC;AACpE;;;;ACbA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,4BAA4B,GAAG,6BAA6B,GAAG,KAAK,CAAC,CAAC;AACnB;AACnD,SAAS,WAAW,CAAC,MAAM,EAAE;AAC7B,IAAI,OAAO,CAAC,EAAE,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AACvD,CAAC;AACD,SAAS,eAAe,CAAC,MAAM,EAAE;AACjC,IAAI,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;AAC/D,CAAC;AACD,SAAS,qBAAqB,CAAC,SAAS,GAAG,KAAK,EAAE,OAAO,GAAG,WAAW,EAAE,YAAY,GAAG,eAAe,EAAE;AACzG,IAAI,OAAO,CAAC,KAAK,EAAE,MAAM,KAAK;AAC9B,QAAQ,IAAI,CAAC,CAAC,SAAS,IAAI,KAAK,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;AACvD,YAAY,OAAO,KAAK,CAAC;AACzB,SAAS;AACT,QAAQ,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC;AACpC,KAAK,CAAC;AACN,CAAC;AACD,6BAA6B,GAAG,qBAAqB,CAAC;AACtD,SAAS,oBAAoB,CAAC,MAAM,EAAE;AACtC,IAAI,OAAO;AACX,QAAQ,IAAI,EAAE,YAAY;AAC1B,QAAQ,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE;AAC9B,YAAY,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE;AAC7C,gBAAgB,MAAM,EAAE,OAAO,CAAC,MAAM;AACtC,gBAAgB,MAAM,EAAE,OAAO,CAAC,MAAM;AACtC,gBAAgB,QAAQ,EAAE,OAAO,CAAC,QAAQ;AAC1C,aAAa,CAAC,CAAC;AACf,YAAY,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;AACxC,gBAAgB,OAAO,EAAE,KAAK,EAAE,IAAIjB,QAAW,CAAC,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;AAC/F,aAAa;AACb,YAAY,OAAO;AACnB,gBAAgB,KAAK;AACrB,aAAa,CAAC;AACd,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,4BAA4B,GAAG,oBAAoB,CAAC;AACpD;;;;ACrCA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,mBAAmB,GAAG,KAAK,CAAC,CAAC;AACO;AACpC,MAAM,WAAW,CAAC;AAClB,IAAI,WAAW,GAAG;AAClB,QAAQ,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,EAAE,CAAC;AACjC,KAAK;AACL,IAAI,GAAG,CAAC,MAAM,EAAE;AAChB,QAAQ,MAAM,OAAO,GAAG,EAAE,CAAC;AAC3B,QAAQiB,KAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,MAAM,IAAI,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAACA,KAAO,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;AAC/G,QAAQ,OAAO,MAAM;AACrB,YAAY,OAAO,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;AACnE,SAAS,CAAC;AACV,KAAK;AACL,IAAI,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE;AAC9B,QAAQ,IAAI,MAAM,GAAG,IAAI,CAAC;AAC1B,QAAQ,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;AACjE,QAAQ,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE;AAC3C,YAAY,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE;AACtC,gBAAgB,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAC3D,aAAa;AACb,SAAS;AACT,QAAQ,OAAO,MAAM,CAAC;AACtB,KAAK;AACL,CAAC;AACD,mBAAmB,GAAG,WAAW,CAAC;AAClC;;;;AC1BA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,6BAA6B,GAAG,KAAK,CAAC,CAAC;AACH;AACpC,SAAS,qBAAqB,CAAC,QAAQ,EAAE;AACzC,IAAI,MAAM,eAAe,GAAG,YAAY,CAAC;AACzC,IAAI,MAAM,eAAe,GAAG,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAC3E,IAAI,MAAM,UAAU,GAAG;AACvB,QAAQ,IAAI,EAAE,aAAa;AAC3B,QAAQ,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE;AAC/B,YAAY,IAAI,EAAE,CAAC;AACnB,YAAY,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,eAAe,CAAC,EAAE;AAC7D,gBAAgB,OAAO;AACvB,aAAa;AACb,YAAY,CAAC,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,MAAM,IAAI,IAAI,EAAE,KAAK,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,KAAK;AACxG,gBAAgB,MAAM,OAAO,GAAG,0CAA0C,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;AACxG,gBAAgB,IAAI,CAAC,OAAO,EAAE;AAC9B,oBAAoB,OAAO;AAC3B,iBAAiB;AACjB,gBAAgB,QAAQ,CAAC;AACzB,oBAAoB,MAAM,EAAE,OAAO,CAAC,MAAM;AAC1C,oBAAoB,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AACzD,oBAAoB,QAAQ,EAAEA,KAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AAC1D,oBAAoB,SAAS,EAAEA,KAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AAC3D,oBAAoB,KAAK,EAAEA,KAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AACvD,iBAAiB,CAAC,CAAC;AACnB,aAAa,CAAC,CAAC;AACf,SAAS;AACT,KAAK,CAAC;AACN,IAAI,MAAM,MAAM,GAAG;AACnB,QAAQ,IAAI,EAAE,YAAY;AAC1B,QAAQ,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE;AAC9B,YAAY,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;AAC3D,gBAAgB,OAAO,IAAI,CAAC;AAC5B,aAAa;AACb,YAAY,OAAOA,KAAO,CAAC,SAAS,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;AAC5D,SAAS;AACT,KAAK,CAAC;AACN,IAAI,OAAO,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAChC,CAAC;AACD,6BAA6B,GAAG,qBAAqB,CAAC;AACtD,SAAS,kBAAkB,CAAC,KAAK,EAAE;AACnC,IAAI,OAAO,MAAM,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC;AAClE,CAAC;AACD;;;;AC3CA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D;;;;ACDA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,qBAAqB,GAAG,KAAK,CAAC,CAAC;AACkC;AACjE,SAAS,aAAa,CAAC,EAAE,KAAK,EAAE,EAAE;AAClC,IAAI,IAAI,KAAK,GAAG,CAAC,EAAE;AACnB,QAAQ,OAAO;AACf,YAAY,IAAI,EAAE,aAAa;AAC/B,YAAY,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE;AACnC,gBAAgB,IAAI,EAAE,EAAE,EAAE,CAAC;AAC3B,gBAAgB,IAAI,OAAO,CAAC;AAC5B,gBAAgB,SAAS,IAAI,GAAG;AAChC,oBAAoB,OAAO,IAAI,YAAY,CAAC,OAAO,CAAC,CAAC;AACrD,oBAAoB,OAAO,GAAG,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AACtD,iBAAiB;AACjB,gBAAgB,SAAS,IAAI,GAAG;AAChC,oBAAoB,IAAI,EAAE,EAAE,EAAE,CAAC;AAC/B,oBAAoB,CAAC,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,MAAM,IAAI,IAAI,EAAE,KAAK,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAC5G,oBAAoB,CAAC,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,MAAM,IAAI,IAAI,EAAE,KAAK,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAC5G,oBAAoB,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AACtD,oBAAoB,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACvD,iBAAiB;AACjB,gBAAgB,SAAS,IAAI,GAAG;AAChC,oBAAoB,IAAI,EAAE,CAAC;AAC3B,oBAAoB,OAAO,CAAC,IAAI,CAAC,IAAIO,cAAkB,CAAC,cAAc,CAAC,SAAS,EAAE,SAAS,EAAE,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;AACvH,iBAAiB;AACjB,gBAAgB,CAAC,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,MAAM,IAAI,IAAI,EAAE,KAAK,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AACvG,gBAAgB,CAAC,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,MAAM,IAAI,IAAI,EAAE,KAAK,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AACvG,gBAAgB,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AACjD,gBAAgB,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAClD,gBAAgB,IAAI,EAAE,CAAC;AACvB,aAAa;AACb,SAAS,CAAC;AACV,KAAK;AACL,CAAC;AACD,qBAAqB,GAAG,aAAa,CAAC;AACtC;;;;ACnCA,IAAI,eAAe,GAAG,CAAClB,cAAI,IAAIA,cAAI,CAAC,eAAe,MAAM,MAAM,CAAC,MAAM,IAAI,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE;AAChG,IAAI,IAAI,EAAE,KAAK,SAAS,EAAE,EAAE,GAAG,CAAC,CAAC;AACjC,IAAI,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AACzF,CAAC,KAAK,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE;AAC5B,IAAI,IAAI,EAAE,KAAK,SAAS,EAAE,EAAE,GAAG,CAAC,CAAC;AACjC,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACjB,CAAC,CAAC,CAAC,CAAC;AACJ,IAAI,YAAY,GAAG,CAACA,cAAI,IAAIA,cAAI,CAAC,YAAY,KAAK,SAAS,CAAC,EAAE,OAAO,EAAE;AACvE,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,eAAe,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAC9H,CAAC,CAAC;AACF,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,YAAY,CAACL,8BAA4C,EAAE,OAAO,CAAC,CAAC;AACpE,YAAY,CAACI,qBAAmC,EAAE,OAAO,CAAC,CAAC;AAC3D,YAAY,CAACM,WAAyB,EAAE,OAAO,CAAC,CAAC;AACjD,YAAY,CAACC,uBAAoC,EAAE,OAAO,CAAC,CAAC;AAC5D,YAAY,CAACC,eAA8B,EAAE,OAAO,CAAC,CAAC;AACtD,YAAY,CAACC,YAA0B,EAAE,OAAO,CAAC,CAAC;AAClD;;;;ACjBA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,iBAAiB,GAAG,oBAAoB,GAAG,KAAK,CAAC,CAAC;AACjB;AACE;AACnCa,KAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,KAAK,KAAK,MAAM,CAACV,KAAO,CAAC,eAAe,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC;AACtGU,KAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,KAAK,KAAK;AAC1C,IAAI,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;AAChC,QAAQ,OAAO,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AACtC,KAAK;AACL,IAAI,OAAOV,KAAO,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;AACzC,CAAC,CAAC;AACF,SAAS,SAAS,GAAG;AACrB,IAAI,OAAOU,KAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;AACzC,CAAC;AACD,SAAS,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE;AAC7C,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE;AACvD,QAAQ,OAAO,CAAC,OAAO,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,IAAI,KAAK;AACrD,YAAY,EAAE,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;AACjC,YAAY,OAAO,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;AACtC,SAAS,CAAC;AACV,KAAK;AACL,IAAI,OAAO,CAAC,OAAO,EAAE,GAAG,IAAI,KAAK;AACjC,QAAQ,EAAE,CAAC,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC;AAC7C,QAAQ,IAAI,OAAO,EAAE;AACrB,YAAY,OAAO,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;AACtC,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,SAAS,eAAe,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,SAAS,EAAE,eAAe,EAAE,EAAE;AAC9E,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;AAClC,QAAQ,OAAO,IAAI,CAAC;AACpB,KAAK;AACL,IAAI,MAAM,cAAc,GAAG,aAAa,IAAI,aAAa,CAAC,SAAS,IAAI,EAAE,CAAC;AAC1E,IAAI,IAAI,cAAc,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE;AACpD,QAAQ,OAAO,cAAc,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACjE,KAAK;AACL,IAAI,OAAO,cAAc,IAAI,eAAe,CAAC;AAC7C,CAAC;AACD,SAAS,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,GAAG,SAAS,EAAE,EAAE;AAC/E,IAAI,MAAM,WAAW,GAAG,KAAK,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;AACpD,IAAI,MAAM,OAAO,GAAG,EAAE,CAAC;AACvB,IAAI,MAAM,aAAa,GAAG,CAAC,OAAO,OAAO,KAAK,QAAQ,IAAI,YAAY,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;AACjG,IAAI,MAAM,GAAG,GAAG,eAAe,CAACV,KAAO,CAAC,UAAU,CAAC,OAAO,EAAEA,KAAO,CAAC,YAAY,CAAC,EAAE,aAAa,EAAE,YAAY,CAAC,CAAC;AAChH,IAAI,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC;AAC7B,IAAI,SAAS,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE;AACpC,QAAQ,OAAOA,KAAO,CAAC,MAAM,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;AAChH,KAAK;AACL,IAAI,SAAS,IAAI,CAAC,KAAK,EAAE;AACzB,QAAQ,MAAM,UAAU,GAAG,KAAK,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;AACvD,QAAQ,MAAM,KAAK,GAAG,aAAa,IAAI,cAAc,CAAC,aAAa,EAAE,UAAU,CAAC,IAAIA,KAAO,CAAC,IAAI,CAAC;AACjG,QAAQ,MAAM,IAAI,GAAG,cAAc,CAAC,YAAY,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AACzF,QAAQ,OAAO,MAAM,CAAC,MAAM,CAAC,aAAa,GAAG,KAAK,GAAG,IAAI,EAAE;AAC3D,YAAY,KAAK;AACjB,YAAY,OAAO;AACnB,YAAY,IAAI;AAChB,YAAY,IAAI;AAChB,SAAS,CAAC,CAAC;AACX,KAAK;AACL,CAAC;AACD,oBAAoB,GAAG,YAAY,CAAC;AACpC;AACA;AACA;AACA;AACA,MAAM,SAAS,CAAC;AAChB,IAAI,WAAW,CAAC,IAAI,GAAG,SAAS,EAAE,EAAE;AACpC,QAAQ,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;AACzB,QAAQ,IAAI,CAAC,KAAK,GAAG,cAAc,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;AACrD,QAAQ,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AACnD,KAAK;AACL,IAAI,MAAM,CAAC,OAAO,GAAG,KAAK,EAAE;AAC5B,QAAQ,IAAI,OAAO,KAAK,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;AAC3C,YAAY,OAAO;AACnB,SAAS;AACT,QAAQ,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC;AACxC,QAAQ,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1E,QAAQ,MAAM,KAAK,GAAG,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;AAC9C,QAAQ,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;AACrD;AACA,QAAQ,IAAI,CAAC,OAAO,EAAE;AACtB,YAAY,IAAI,MAAM,EAAE;AACxB,gBAAgBA,KAAO,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;AACrD,aAAa;AACb,iBAAiB;AACjB,gBAAgB,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AACpC,aAAa;AACb,SAAS;AACT,aAAa;AACb,YAAY,IAAI,KAAK,EAAE;AACvB,gBAAgBA,KAAO,CAAC,MAAM,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;AAC/C,aAAa;AACb,iBAAiB;AACjB,gBAAgB,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;AAC1C,aAAa;AACb,SAAS;AACT,QAAQU,KAAO,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAC9C,KAAK;AACL,CAAC;AACD,iBAAiB,GAAG,SAAS,CAAC;AAC9B;;;;ACnGA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,yBAAyB,GAAG,KAAK,CAAC,CAAC;AACgB;AACL;AAC9C,MAAM,iBAAiB,CAAC;AACxB,IAAI,WAAW,CAAC,QAAQ,GAAG,aAAa,EAAE;AAC1C,QAAQ,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;AACjC,QAAQ,IAAI,CAAC,MAAM,GAAG,IAAI,GAAG,EAAE,CAAC;AAChC,KAAK;AACL,IAAI,YAAY,CAAC,IAAI,EAAE;AACvB,QAAQ,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACrC,KAAK;AACL,IAAI,cAAc,CAAC,IAAI,EAAE;AACzB,QAAQ,MAAM,IAAI,GAAG,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AACjE,QAAQ,MAAM,MAAM,GAAGC,SAAY,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;AACtE,QAAQ,OAAO;AACf,YAAY,IAAI;AAChB,YAAY,MAAM;AAClB,YAAY,IAAI;AAChB,SAAS,CAAC;AACV,KAAK;AACL,IAAI,IAAI,CAAC,IAAI,EAAE;AACf,QAAQ,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;AACnD,QAAQ,QAAQ,CAAC,MAAM,CAAC,yCAAyC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;AAClF,QAAQ,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AACxC,QAAQ,OAAO,QAAQ,CAAC;AACxB,KAAK;AACL,IAAI,KAAK,CAAC,GAAG,EAAE;AACf,QAAQ,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,EAAE;AAC5E,YAAY,IAAI,IAAI,KAAK,GAAG,CAAC,IAAI,EAAE;AACnC,gBAAgB,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,CAAC;AAC9C,gBAAgB,MAAM,CAAC,CAAC,4FAA4F,CAAC,CAAC,CAAC;AACvH,aAAa;AACb,iBAAiB;AACjB,gBAAgB,MAAM,CAAC,IAAI,CAAC,CAAC,4EAA4E,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;AACzH,aAAa;AACb,YAAY,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AAChC,SAAS;AACT,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,EAAE;AACpC,YAAY,MAAM,IAAI,KAAK,CAAC,CAAC,uCAAuC,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAC1F,SAAS;AACT,KAAK;AACL,IAAI,QAAQ,CAAC,IAAI,EAAE;AACnB,QAAQ,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;AACjD,QAAQ,IAAI,QAAQ,EAAE;AACtB,YAAY,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AACrC,SAAS;AACT,KAAK;AACL,IAAI,OAAO,CAAC,IAAI,EAAE;AAClB,QAAQ,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;AACjD,QAAQ,IAAI,CAAC,QAAQ,EAAE;AACvB,YAAY,MAAM,IAAI5B,QAAW,CAAC,QAAQ,CAAC,SAAS,EAAE,uDAAuD,CAAC,CAAC;AAC/G,SAAS;AACT,QAAQ,QAAQ,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;AACzC,QAAQ,OAAO,QAAQ,CAAC;AACxB,KAAK;AACL,IAAI,OAAO,OAAO,CAAC,IAAI,GAAG,OAAO,EAAE;AACnC,QAAQ,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,EAAE,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;AAC7D,KAAK;AACL,CAAC;AACD,yBAAyB,GAAG,iBAAiB,CAAC;AAC9C,iBAAiB,CAAC,OAAO,GAAG,CAAC,CAAC;AAC9B;;;;AC9DA,IAAI,SAAS,GAAG,CAACM,cAAI,IAAIA,cAAI,CAAC,SAAS,KAAK,UAAU,OAAO,EAAE,UAAU,EAAE,CAAC,EAAE,SAAS,EAAE;AACzF,IAAI,SAAS,KAAK,CAAC,KAAK,EAAE,EAAE,OAAO,KAAK,YAAY,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,CAAC,UAAU,OAAO,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;AAChH,IAAI,OAAO,KAAK,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,EAAE,UAAU,OAAO,EAAE,MAAM,EAAE;AAC/D,QAAQ,SAAS,SAAS,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE;AACnG,QAAQ,SAAS,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE;AACtG,QAAQ,SAAS,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,EAAE;AACtH,QAAQ,IAAI,CAAC,CAAC,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,UAAU,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9E,KAAK,CAAC,CAAC;AACP,CAAC,CAAC;AACF,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,wBAAwB,GAAG,KAAK,CAAC,CAAC;AACe;AACE;AACX;AACJ;AAC2B;AAC/D,MAAM,gBAAgB,CAAC;AACvB,IAAI,WAAW,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE;AACjD,QAAQ,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;AACnC,QAAQ,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;AACrC,QAAQ,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;AACjC,QAAQ,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;AACxC,QAAQ,IAAI,CAAC,MAAM,GAAG,IAAIuB,iBAAqB,CAAC,iBAAiB,EAAE,CAAC;AACpE,KAAK;AACL,IAAI,IAAI,MAAM,GAAG;AACjB,QAAQ,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;AACrC,KAAK;AACL,IAAI,IAAI,GAAG,GAAG;AACd,QAAQ,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC;AAClC,KAAK;AACL,IAAI,IAAI,GAAG,GAAG;AACd,QAAQ,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC;AAClC,KAAK;AACL,IAAI,IAAI,aAAa,GAAG;AACxB,QAAQ,OAAO,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC;AAC5C,KAAK;AACL,IAAI,KAAK,GAAG;AACZ,QAAQ,OAAO,IAAI,CAAC;AACpB,KAAK;AACL,IAAI,IAAI,CAAC,IAAI,EAAE;AACf,QAAQ,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC/B,QAAQ,OAAO,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;AAC5E,KAAK;AACL,IAAI,WAAW,CAACC,MAAI,EAAE;AACtB,QAAQ,OAAO,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,EAAE,aAAa;AAC5D,YAAY,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;AACpE,YAAY,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAACA,MAAI,CAAC,CAAC;AACrE,YAAY,IAAI;AAChB,gBAAgB,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAACA,MAAI,CAAC,CAAC;AAC7D,gBAAgB,OAAO,OAAOX,IAAM,CAAC,WAAW,CAACW,MAAI,CAAC;AACtD,sBAAsB,IAAI,CAAC,gBAAgB,CAACA,MAAI,EAAE,MAAM,CAAC;AACzD,sBAAsB,IAAI,CAAC,iBAAiB,CAACA,MAAI,EAAE,MAAM,CAAC,CAAC,CAAC;AAC5D,aAAa;AACb,YAAY,OAAO,CAAC,EAAE;AACtB,gBAAgB,MAAM,IAAI,CAAC,gBAAgB,CAACA,MAAI,EAAE,CAAC,CAAC,CAAC;AACrD,aAAa;AACb,oBAAoB;AACpB,gBAAgB,eAAe,EAAE,CAAC;AAClC,gBAAgB,kBAAkB,EAAE,CAAC;AACrC,aAAa;AACb,SAAS,CAAC,CAAC;AACX,KAAK;AACL,IAAI,gBAAgB,CAAC,IAAI,EAAE,CAAC,EAAE;AAC9B,QAAQ,MAAMC,UAAQ,GAAG,CAAC,CAAC,YAAY/B,QAAW,CAAC,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,IAAIA,QAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3I,QAAQ,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;AACxC,QAAQ,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC+B,UAAQ,CAAC,CAAC;AACpC,QAAQ,OAAOA,UAAQ,CAAC;AACxB,KAAK;AACL,IAAI,iBAAiB,CAACD,MAAI,EAAE,MAAM,EAAE;AACpC,QAAQ,OAAO,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,EAAE,aAAa;AAC5D,YAAY,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,GAAGA,MAAI,CAAC,QAAQ,CAAC,EAAE,aAAa,CAACA,MAAI,EAAEA,MAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;AAClH,YAAY,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,WAAW,CAACA,MAAI,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAClH,YAAY,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,cAAc,CAACA,MAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;AACpG,YAAY,MAAM,CAAC,CAAC,yCAAyC,CAAC,EAAEA,MAAI,CAAC,MAAM,CAAC,CAAC;AAC7E,YAAY,IAAIX,IAAM,CAAC,YAAY,CAACW,MAAI,CAAC,EAAE;AAC3C,gBAAgB,OAAOb,KAAO,CAAC,cAAc,CAACa,MAAI,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAC1E,aAAa;AACb,YAAY,OAAOb,KAAO,CAAC,cAAc,CAACa,MAAI,CAAC,MAAM,EAAE,aAAa,CAAC,SAAS,EAAE,CAAC,CAAC;AAClF,SAAS,CAAC,CAAC;AACX,KAAK;AACL,IAAI,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE;AACnC,QAAQ,OAAO,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,EAAE,aAAa;AAC5D,YAAY,MAAM,CAAC,CAAC,2DAA2D,CAAC,CAAC,CAAC;AAClF,YAAY,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;AACjC,SAAS,CAAC,CAAC;AACX,KAAK;AACL,IAAI,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;AAC/C,QAAQ,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;AAC/D,QAAQ,OAAO,IAAI,OAAO,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK;AAC3C,YAAY,MAAM,CAAC,CAAC,wDAAwD,CAAC,EAAE,QAAQ,CAAC,CAAC;AACzF,YAAY,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AAC1J,YAAY,IAAI,KAAK,IAAI,IAAI,CAAC,OAAO,EAAE;AACvC,gBAAgB,MAAM,CAAC,IAAI,CAAC,CAAC,8CAA8C,CAAC,CAAC,CAAC;AAC9E,gBAAgB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,SAAS,KAAK;AAClE,oBAAoB,MAAM,CAAC,IAAI,CAAC,CAAC,uCAAuC,CAAC,CAAC,CAAC;AAC3E,oBAAoB,MAAM,CAAC,CAAC,0BAA0B,CAAC,EAAEb,KAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC;AAC5F,oBAAoB,IAAI,CAAC,IAAIA,KAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAC/I,iBAAiB,EAAE,IAAI,CAAC,CAAC;AACzB,aAAa;AACb,YAAY,IAAI,KAAK,EAAE;AACvB,gBAAgB,MAAM,CAAC,IAAI,CAAC,CAAC,qDAAqD,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AACzH,gBAAgB,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;AACnC,aAAa;AACb,YAAY,MAAM,CAAC,IAAI,CAAC,CAAC,+BAA+B,CAAC,CAAC,CAAC;AAC3D,YAAY,IAAI,CAAC,IAAIA,KAAO,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAC7F,SAAS,CAAC,CAAC;AACX,KAAK;AACL,IAAI,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE;AAC5D,QAAQ,OAAO,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,EAAE,aAAa;AAC5D,YAAY,MAAM,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC1D,YAAY,MAAM,YAAY,GAAG;AACjC,gBAAgB,GAAG,EAAE,IAAI,CAAC,GAAG;AAC7B,gBAAgB,GAAG,EAAE,IAAI,CAAC,GAAG;AAC7B,gBAAgB,WAAW,EAAE,IAAI;AACjC,aAAa,CAAC;AACd,YAAY,OAAO,IAAI,OAAO,CAAC,CAAC,IAAI,KAAK;AACzC,gBAAgB,MAAM,MAAM,GAAG,EAAE,CAAC;AAClC,gBAAgB,MAAM,MAAM,GAAG,EAAE,CAAC;AAClC,gBAAgB,IAAI,SAAS,GAAG,KAAK,CAAC;AACtC,gBAAgB,IAAI,SAAS,CAAC;AAC9B,gBAAgB,SAAS,YAAY,CAAC,QAAQ,EAAE,KAAK,GAAG,OAAO,EAAE;AACjE;AACA,oBAAoB,IAAI,SAAS,IAAI,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE;AACrE,wBAAwB,MAAM,CAAC,IAAI,CAAC,CAAC,iCAAiC,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;AACrG,wBAAwB,IAAI,CAAC;AAC7B,4BAA4B,MAAM;AAClC,4BAA4B,MAAM;AAClC,4BAA4B,QAAQ;AACpC,4BAA4B,SAAS;AACrC,yBAAyB,CAAC,CAAC;AAC3B,wBAAwB,SAAS,GAAG,IAAI,CAAC;AACzC,qBAAqB;AACrB;AACA,oBAAoB,IAAI,CAAC,SAAS,EAAE;AACpC,wBAAwB,SAAS,GAAG,IAAI,CAAC;AACzC,wBAAwB,UAAU,CAAC,MAAM,YAAY,CAAC,QAAQ,EAAE,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC;AACjF,wBAAwB,MAAM,CAAC,mDAAmD,EAAE,KAAK,CAAC,CAAC;AAC3F,qBAAqB;AACrB,iBAAiB;AACjB,gBAAgB,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;AACpD,gBAAgB,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;AAC3C,gBAAgB,MAAM,OAAO,GAAGe,mCAAe,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;AACnF,gBAAgB,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AACjH,gBAAgB,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AACjH,gBAAgB,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AACrE,gBAAgB,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,IAAI,KAAK,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;AAC3E,gBAAgB,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,KAAK,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;AACzE,gBAAgB,IAAI,aAAa,EAAE;AACnC,oBAAoB,MAAM,CAAC,CAAC,2DAA2D,CAAC,CAAC,CAAC;AAC1F,oBAAoB,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;AACtF,iBAAiB;AACjB,gBAAgB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE;AACjJ,wBAAwB,IAAI,OAAO,CAAC,MAAM,EAAE;AAC5C,4BAA4B,OAAO;AACnC,yBAAyB;AACzB,wBAAwB,SAAS,GAAG,MAAM,CAAC;AAC3C,wBAAwB,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAC/C,qBAAqB,EAAE,CAAC,CAAC,CAAC;AAC1B,aAAa,CAAC,CAAC;AACf,SAAS,CAAC,CAAC;AACX,KAAK;AACL,CAAC;AACD,wBAAwB,GAAG,gBAAgB,CAAC;AAC5C,SAAS,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE;AACvC,IAAI,OAAO;AACX,QAAQ,MAAM,EAAEf,KAAO,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE;AAClD,QAAQ,QAAQ;AAChB,KAAK,CAAC;AACN,CAAC;AACD,SAAS,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE;AACzC,IAAI,OAAO,CAAC,GAAG,KAAK;AACpB,QAAQ,MAAM,CAAC,CAAC,kCAAkC,CAAC,EAAE,GAAG,CAAC,CAAC;AAC1D,QAAQ,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;AAC7D,KAAK,CAAC;AACN,CAAC;AACD,SAAS,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;AACtD,IAAI,OAAO,CAAC,MAAM,KAAK;AACvB,QAAQ,MAAM,CAAC,CAAC,oBAAoB,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AACrD,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;AAC7B,QAAQ,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC5B,KAAK,CAAC;AACN,CAAC;AACD;;;;ACtLA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,mBAAmB,GAAG,KAAK,CAAC,CAAC;AACgC;AAC7D,MAAM,WAAW,CAAC;AAClB,IAAI,WAAW,CAAC,MAAM,GAAG,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,QAAQ,EAAE;AAC3D,QAAQ,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;AAC7B,QAAQ,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;AACvB,QAAQ,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;AACrC,QAAQ,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;AACjC,QAAQ,IAAI,CAAC,MAAM,GAAG,IAAIgB,gBAAoB,CAAC,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;AACtG,KAAK;AACL,IAAI,KAAK,GAAG;AACZ,QAAQ,OAAO,IAAIA,gBAAoB,CAAC,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;AAC/F,KAAK;AACL,IAAI,IAAI,CAAC,IAAI,EAAE;AACf,QAAQ,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACtC,KAAK;AACL,CAAC;AACD,mBAAmB,GAAG,WAAW,CAAC;AAClC;;;;ACnBA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,oBAAoB,GAAG,KAAK,CAAC,CAAC;AACsC;AACjC;AACnC,SAAS,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,GAAGhB,KAAO,CAAC,IAAI,EAAE;AAC/D,IAAI,MAAM,SAAS,GAAG,CAAC,IAAI,KAAK;AAChC,QAAQ,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAC7B,KAAK,CAAC;AACN,IAAI,MAAM,OAAO,GAAG,CAAC,GAAG,KAAK;AAC7B,QAAQ,IAAI,CAAC,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG,GAAG,CAAC,IAAI,MAAM,IAAI,EAAE;AAC3E,YAAY,IAAI,GAAG,YAAYQ,gBAAoB,CAAC,gBAAgB,EAAE;AACtE,gBAAgB,OAAO,QAAQ,CAAC,2BAA2B,CAAC,GAAG,CAAC,CAAC,CAAC;AAClE,aAAa;AACb,YAAY,QAAQ,CAAC,GAAG,CAAC,CAAC;AAC1B,SAAS;AACT,KAAK,CAAC;AACN,IAAI,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;AACtC,CAAC;AACD,oBAAoB,GAAG,YAAY,CAAC;AACpC,SAAS,2BAA2B,CAAC,GAAG,EAAE;AAC1C,IAAI,IAAI,GAAG,GAAG,CAAC,IAAI,KAAK;AACxB,QAAQ,OAAO,CAAC,IAAI,CAAC,CAAC,0DAA0D,EAAE,IAAI,CAAC,gCAAgC,EAAE,IAAI,CAAC,+CAA+C,CAAC,CAAC,CAAC;AAChL,QAAQ,GAAG,GAAGR,KAAO,CAAC,IAAI,CAAC;AAC3B,KAAK,CAAC;AACN,IAAI,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,mBAAmB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,iBAAiB,EAAE,EAAE,CAAC,CAAC,CAAC;AACjG,IAAI,SAAS,iBAAiB,CAAC,GAAG,EAAE,IAAI,EAAE;AAC1C,QAAQ,IAAI,IAAI,IAAI,GAAG,EAAE;AACzB,YAAY,OAAO,GAAG,CAAC;AACvB,SAAS;AACT,QAAQ,GAAG,CAAC,IAAI,CAAC,GAAG;AACpB,YAAY,UAAU,EAAE,KAAK;AAC7B,YAAY,YAAY,EAAE,KAAK;AAC/B,YAAY,GAAG,GAAG;AAClB,gBAAgB,GAAG,CAAC,IAAI,CAAC,CAAC;AAC1B,gBAAgB,OAAO,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACrC,aAAa;AACb,SAAS,CAAC;AACV,QAAQ,OAAO,GAAG,CAAC;AACnB,KAAK;AACL,CAAC;AACD;;;;ACxCA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,mCAAmC,GAAG,KAAK,CAAC,CAAC;AACT;AACpC,SAAS,uBAAuB,CAAC,cAAc,EAAE;AACjD,IAAI,QAAQ,cAAc,CAAC,OAAO,GAAG,cAAc,CAAC,OAAO,IAAI;AAC/D,QAAQ,WAAW,EAAE,CAAC;AACtB,QAAQ,QAAQ,EAAE,CAAC;AACnB,QAAQ,WAAW,EAAE,CAAC;AACtB,QAAQ,UAAU,EAAE,CAAC;AACrB,QAAQ,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE;AACtC,QAAQ,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE;AACrC,KAAK,EAAE;AACP,CAAC;AACD,SAAS,aAAa,CAAC,MAAM,EAAE;AAC/B,IAAI,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC3C,IAAI,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC9C,IAAI,OAAO;AACX,QAAQ,KAAK,EAAEA,KAAO,CAAC,QAAQ,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC;AACzD,QAAQ,KAAK,EAAEA,KAAO,CAAC,QAAQ,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC;AACzD,KAAK,CAAC;AACN,CAAC;AACD,mCAAmC,GAAG;AACtC,IAAI,IAAIA,KAAO,CAAC,gBAAgB,CAAC,gEAAgE,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK;AAChI,QAAQ,MAAM,GAAG,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC;AACzC,QAAQ,MAAM,WAAW,GAAG,uBAAuB,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;AAC3E,QAAQ,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,EAAE,CAAC,GAAG,GAAGA,KAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;AACvE,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,gBAAgB,CAAC,8EAA8E,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK;AAC9I,QAAQ,MAAM,GAAG,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC;AACzC,QAAQ,MAAM,WAAW,GAAG,uBAAuB,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;AAC3E,QAAQ,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,EAAE,CAAC,GAAG,GAAGA,KAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;AACvE,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,gBAAgB,CAAC,mDAAmD,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,KAAK;AAC/H,QAAQ,MAAM,OAAO,GAAG,uBAAuB,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;AACvE,QAAQ,OAAO,CAAC,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;AAC7C,QAAQ,OAAO,CAAC,MAAM,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;AAC/C,QAAQ,OAAO,CAAC,UAAU,GAAGA,KAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AAC1D,KAAK,CAAC;AACN,CAAC,CAAC;AACF;;;;ACvCA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,4BAA4B,GAAG,2BAA2B,GAAG,KAAK,CAAC,CAAC;AAChC;AAC6B;AACjE,MAAM,OAAO,GAAG;AAChB,IAAI,IAAIA,KAAO,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,KAAK;AACzE,QAAQ,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;AACpD,QAAQ,OAAO,KAAK,CAAC;AACrB,KAAK,CAAC;AACN,IAAI,GAAGiB,kBAAsB,CAAC,2BAA2B;AACzD,IAAI,IAAIjB,KAAO,CAAC,gBAAgB,CAAC,CAAC,kCAAkC,EAAE,qBAAqB,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,cAAc,CAAC,KAAK;AAC5H,QAAQ,MAAM,CAAC,cAAc,CAAC,cAAc,GAAG,cAAc,CAAC;AAC9D,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,gBAAgB,CAAC,CAAC,2CAA2C,EAAE,qBAAqB,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,KAAK;AAC1I,QAAQ,MAAM,CAAC,cAAc,CAAC,eAAe,GAAG;AAChD,YAAY,KAAK,EAAEA,KAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;AAC1C,YAAY,OAAO;AACnB,YAAY,GAAG;AACf,SAAS,CAAC;AACV,KAAK,CAAC;AACN,CAAC,CAAC;AACF,SAAS,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE;AAC9C,IAAI,OAAOA,KAAO,CAAC,mBAAmB,CAAC,EAAE,cAAc,EAAE,IAAI,oBAAoB,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AACxG,CAAC;AACD,2BAA2B,GAAG,mBAAmB,CAAC;AAClD,MAAM,oBAAoB,CAAC;AAC3B,IAAI,WAAW,GAAG;AAClB,QAAQ,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC;AACtB,KAAK;AACL,CAAC;AACD,4BAA4B,GAAG,oBAAoB,CAAC;AACpD;;;;AC/BA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,uBAAuB,GAAG,uBAAuB,GAAG,KAAK,CAAC,CAAC;AACvB;AAC+B;AACnE,SAAS,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE;AACrD,IAAI,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;AAC/C,IAAI,MAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACpE,IAAI,MAAM,cAAc,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AACnD,IAAI,OAAO;AACX,QAAQ,OAAO;AACf,QAAQ,GAAG;AACX,QAAQ,MAAM,EAAE,CAAC,GAAG;AACpB,QAAQ,GAAG,EAAE,CAAC,cAAc;AAC5B,QAAQ,cAAc;AACtB,QAAQ,KAAK;AACb,QAAQ,MAAM;AACd,KAAK,CAAC;AACN,CAAC;AACD,MAAM,OAAO,GAAG;AAChB,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,mBAAmB,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,KAAK;AACpE,QAAQ,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC;AAC3B,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,qCAAqC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,KAAK;AACvF,QAAQ,MAAM,CAAC,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;AACrF,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,mCAAmC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK;AACnG,QAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;AACtE,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,0EAA0E,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,KAAK;AAChJ,QAAQ,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,MAAM,IAAI,EAAE,EAAE,EAAE,EAAE,KAAK;AACvF,YAAY,MAAM;AAClB,YAAY,UAAU,EAAE,CAAC,CAAC;AAC1B,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,8CAA8C,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,KAAK;AAClH,QAAQ,MAAM,CAAC,MAAM,GAAG;AACxB,YAAY,IAAI,EAAE;AAClB,gBAAgB,KAAK;AACrB,gBAAgB,MAAM;AACtB,aAAa;AACb,YAAY,IAAI,EAAE;AAClB,gBAAgB,IAAI;AACpB,gBAAgB,EAAE;AAClB,aAAa;AACb,SAAS,CAAC;AACV,KAAK,CAAC;AACN,CAAC,CAAC;AACF,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK;AAC5C,IAAI,MAAM,UAAU,GAAG,OAAO,CAAC,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAC/D,IAAI,MAAM,cAAc,GAAGkB,qBAAuB,CAAC,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AACvF,IAAI,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,UAAU,CAAC,EAAE,cAAc,CAAC,CAAC;AACxE,CAAC,CAAC;AACF,uBAAuB,GAAG,eAAe,CAAC;AAC1C,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK;AAC5C,IAAI,OAAOlB,KAAO,CAAC,mBAAmB,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAChF,CAAC,CAAC;AACF,uBAAuB,GAAG,eAAe,CAAC;AAC1C;;;;ACxDA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,gBAAgB,GAAG,oBAAoB,GAAG,KAAK,CAAC,CAAC;AACK;AAClB;AACpC,SAAS,YAAY,CAAC,GAAG,GAAG,EAAE,EAAE,UAAU,EAAE;AAC5C,IAAIA,KAAO,CAAC,MAAM,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;AACzC,IAAI,OAAO,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;AACrC,CAAC;AACD,oBAAoB,GAAG,YAAY,CAAC;AACpC,SAAS,QAAQ,CAAC,GAAG,GAAG,EAAE,EAAE,UAAU,EAAE;AACxC,IAAI,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,CAAC;AAC7C,IAAI,IAAI,GAAG,CAAC,MAAM,EAAE;AACpB,QAAQ,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;AAC1C,KAAK;AACL,IAAI,IAAI,GAAG,CAAC,MAAM,EAAE;AACpB,QAAQ,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;AAC1C,KAAK;AACL,IAAIA,KAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;AACnC,IAAIA,KAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;AAC1C,IAAIA,KAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;AAC5C,IAAI,OAAO;AACX,QAAQ,QAAQ;AAChB,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,EAAEmB,SAAY,CAAC,eAAe;AAC5C,KAAK,CAAC;AACN,CAAC;AACD,gBAAgB,GAAG,QAAQ,CAAC;AAC5B;;;;AC3BA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,oBAAoB,GAAG,KAAK,CAAC,CAAC;AACqB;AACZ;AACA;AACJ;AACnC,MAAM,YAAY,CAAC;AACnB,IAAI,WAAW,CAAC,SAAS,EAAE;AAC3B,QAAQ,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;AACnC,KAAK;AACL,IAAI,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE;AACzB,QAAQ,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;AAC7C,QAAQ,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACzC,QAAQ,IAAI,IAAI,EAAE;AAClB,YAAYC,cAAe,CAAC,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;AAC9D,SAAS;AACT,QAAQ,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE;AACnC,YAAY,IAAI,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;AACvD,YAAY,KAAK,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;AACzD,YAAY,SAAS,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;AACvC,SAAS,CAAC,CAAC;AACX,KAAK;AACL,IAAI,GAAG,CAAC,KAAK,EAAE;AACf,QAAQ,OAAO,IAAI,CAAC,QAAQ,CAAClB,IAAM,CAAC,yBAAyB,CAAC,CAAC,KAAK,EAAE,GAAGF,KAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAEA,KAAO,CAAC,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC;AAChJ,KAAK;AACL,IAAI,IAAI,GAAG;AACX,QAAQ,MAAM,IAAI,GAAGqB,IAAM,CAAC,QAAQ,CAAC;AACrC,YAAY,MAAM,EAAErB,KAAO,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,EAAEA,KAAO,CAAC,YAAY,CAAC;AAC1E,YAAY,MAAM,EAAEA,KAAO,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,EAAEA,KAAO,CAAC,YAAY,CAAC;AAC1E,SAAS,EAAEA,KAAO,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;AAClD,QAAQ,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAEA,KAAO,CAAC,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC;AAChF,KAAK;AACL,CAAC;AACD,oBAAoB,GAAG,YAAY,CAAC;AACpC;;;;AClCA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,sBAAsB,GAAG,gBAAgB,GAAG,KAAK,CAAC,CAAC;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,QAAQ,GAAG;AACpB,IAAI,IAAI,IAAI,CAAC;AACb,IAAI,IAAI,IAAI,CAAC;AACb,IAAI,IAAI,MAAM,GAAG,SAAS,CAAC;AAC3B,IAAI,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK;AAClD,QAAQ,IAAI,GAAG,KAAK,CAAC;AACrB,QAAQ,IAAI,GAAG,KAAK,CAAC;AACrB,KAAK,CAAC,CAAC;AACP,IAAI,OAAO;AACX,QAAQ,OAAO;AACf,QAAQ,IAAI,CAAC,MAAM,EAAE;AACrB,YAAY,IAAI,MAAM,KAAK,SAAS,EAAE;AACtC,gBAAgB,MAAM,GAAG,UAAU,CAAC;AACpC,gBAAgB,IAAI,CAAC,MAAM,CAAC,CAAC;AAC7B,aAAa;AACb,SAAS;AACT,QAAQ,IAAI,CAAC,KAAK,EAAE;AACpB,YAAY,IAAI,MAAM,KAAK,SAAS,EAAE;AACtC,gBAAgB,MAAM,GAAG,UAAU,CAAC;AACpC,gBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC;AAC5B,aAAa;AACb,SAAS;AACT,QAAQ,IAAI,SAAS,GAAG;AACxB,YAAY,OAAO,MAAM,KAAK,SAAS,CAAC;AACxC,SAAS;AACT,QAAQ,IAAI,MAAM,GAAG;AACrB,YAAY,OAAO,MAAM,CAAC;AAC1B,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,gBAAgB,GAAG,QAAQ,CAAC;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,GAAG,QAAQ,CAAC;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,GAAG,QAAQ,CAAC;AAC3B;;;;ACzDA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,iBAAiB,GAAG,KAAK,CAAC,CAAC;AACS;AAC4B;AAClB;AAC9C,MAAM,mBAAmB,GAAG,CAAC,MAAM;AACnC,IAAI,IAAI,EAAE,GAAG,CAAC,CAAC;AACf,IAAI,OAAO,MAAM;AACjB,QAAQ,EAAE,EAAE,CAAC;AACb,QAAQ,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,GAAGsB,IAAkB,CAAC,cAAc,EAAE,CAAC;AACtE,QAAQ,OAAO;AACf,YAAY,OAAO;AACnB,YAAY,IAAI;AAChB,YAAY,EAAE;AACd,SAAS,CAAC;AACV,KAAK,CAAC;AACN,CAAC,GAAG,CAAC;AACL,MAAM,SAAS,CAAC;AAChB,IAAI,WAAW,CAAC,WAAW,GAAG,CAAC,EAAE;AACjC,QAAQ,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;AACvC,QAAQ,IAAI,CAAC,MAAM,GAAGX,SAAY,CAAC,YAAY,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;AACjE,QAAQ,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;AAC1B,QAAQ,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;AAC1B,QAAQ,IAAI,CAAC,MAAM,CAAC,CAAC,2BAA2B,CAAC,EAAE,WAAW,CAAC,CAAC;AAChE,KAAK;AACL,IAAI,QAAQ,GAAG;AACf,QAAQ,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,WAAW,EAAE;AAC7E,YAAY,IAAI,CAAC,MAAM,CAAC,CAAC,8DAA8D,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;AACtJ,YAAY,OAAO;AACnB,SAAS;AACT,QAAQ,MAAM,IAAI,GAAGX,KAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;AACxE,QAAQ,IAAI,CAAC,MAAM,CAAC,CAAC,gBAAgB,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;AACjD,QAAQ,IAAI,CAAC,IAAI,CAAC,MAAM;AACxB,YAAY,IAAI,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;AACnD,YAAYA,KAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAC/C,YAAY,IAAI,CAAC,QAAQ,EAAE,CAAC;AAC5B,SAAS,CAAC,CAAC;AACX,KAAK;AACL,IAAI,IAAI,GAAG;AACX,QAAQ,MAAM,EAAE,OAAO,EAAE,EAAE,EAAE,GAAGA,KAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,mBAAmB,EAAE,CAAC,CAAC;AACpF,QAAQ,IAAI,CAAC,MAAM,CAAC,CAAC,gBAAgB,CAAC,EAAE,EAAE,CAAC,CAAC;AAC5C,QAAQ,IAAI,CAAC,QAAQ,EAAE,CAAC;AACxB,QAAQ,OAAO,OAAO,CAAC;AACvB,KAAK;AACL,CAAC;AACD,iBAAiB,GAAG,SAAS,CAAC;AAC9B;;;;AC9CA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,sBAAsB,GAAG,KAAK,CAAC,CAAC;AACC;AACjC,SAAS,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE;AAC7C,IAAI,OAAOE,IAAM,CAAC,yBAAyB,CAAC,CAAC,OAAO,EAAE,GAAG,UAAU,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC;AAClF,CAAC;AACD,sBAAsB,GAAG,cAAc,CAAC;AACxC;;;;ACPA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,mCAAmC,GAAG,6BAA6B,GAAG,6BAA6B,GAAG,2BAA2B,GAAG,KAAK,CAAC,CAAC;AAC3I,MAAM,mBAAmB,CAAC;AAC1B,IAAI,WAAW,GAAG;AAClB,QAAQ,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC;AACtB,QAAQ,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;AAC3B,QAAQ,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;AACzB,KAAK;AACL,IAAI,IAAI,OAAO,GAAG;AAClB,QAAQ,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;AACnC,KAAK;AACL,CAAC;AACD,2BAA2B,GAAG,mBAAmB,CAAC;AAClD,SAAS,qBAAqB,CAAC,MAAM,EAAE,IAAI,EAAE;AAC7C,IAAI,OAAO;AACX,QAAQ,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI;AACnC,KAAK,CAAC;AACN,CAAC;AACD,6BAA6B,GAAG,qBAAqB,CAAC;AACtD,SAAS,qBAAqB,CAAC,MAAM,EAAE;AACvC,IAAI,OAAO;AACX,QAAQ,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK;AAC1C,KAAK,CAAC;AACN,CAAC;AACD,6BAA6B,GAAG,qBAAqB,CAAC;AACtD,SAAS,2BAA2B,CAAC,IAAI,EAAE;AAC3C,IAAI,OAAO,IAAI,CAAC,OAAO,CAAC;AACxB,CAAC;AACD,mCAAmC,GAAG,2BAA2B,CAAC;AAClE;;;;AC7BA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,8BAA8B,GAAG,4BAA4B,GAAG,KAAK,CAAC,CAAC;AACG;AACtC;AACpC,MAAM,kBAAkB,GAAG,0BAA0B,CAAC;AACtD,MAAM,gBAAgB,GAAG,uBAAuB,CAAC;AACjD,MAAM,OAAO,GAAG;AAChB,IAAI,IAAIF,KAAO,CAAC,UAAU,CAAC,kBAAkB,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK;AAC3E,QAAQ,MAAM,QAAQ,GAAGuB,mBAAqB,CAAC,qBAAqB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AACnF,QAAQ,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAClC,QAAQ,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC;AAC3C,KAAK,CAAC;AACN,IAAI,IAAIvB,KAAO,CAAC,UAAU,CAAC,gBAAgB,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,KAAK;AACnE,QAAQ,MAAM,QAAQ,GAAGuB,mBAAqB,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;AAC7E,QAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AACrC,QAAQ,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAClC,QAAQ,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC;AAC3C,KAAK,CAAC;AACN,CAAC,CAAC;AACF,MAAM,oBAAoB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK;AACjD,IAAI,OAAOvB,KAAO,CAAC,mBAAmB,CAAC,IAAIuB,mBAAqB,CAAC,mBAAmB,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AACjH,CAAC,CAAC;AACF,4BAA4B,GAAG,oBAAoB,CAAC;AACpD,SAAS,sBAAsB,CAAC,IAAI,EAAE,eAAe,EAAE;AACvD,IAAI,OAAO,eAAe,KAAKvB,KAAO,CAAC,SAAS,CAAC,KAAK,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACtF,CAAC;AACD,8BAA8B,GAAG,sBAAsB,CAAC;AACxD;;;;AC3BA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,2BAA2B,GAAG,KAAK,CAAC,CAAC;AACrC,MAAM,mBAAmB,CAAC;AAC1B,IAAI,WAAW,GAAG;AAClB,QAAQ,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC;AACtB,QAAQ,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;AAC3B,QAAQ,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;AAC1B,QAAQ,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;AAC9B,KAAK;AACL,IAAI,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE;AACjD,QAAQ,IAAI,OAAO,EAAE;AACrB,YAAY,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;AACrC,YAAY,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;AAChC,SAAS;AACT,QAAQ,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC5B,QAAQ,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG;AAC9B,YAAY,OAAO,EAAE,OAAO;AAC5B,YAAY,IAAI,EAAE,IAAI;AACtB,YAAY,MAAM,EAAE,MAAM;AAC1B,YAAY,KAAK,EAAE,KAAK;AACxB,SAAS,CAAC;AACV,KAAK;AACL,CAAC;AACD,2BAA2B,GAAG,mBAAmB,CAAC;AAClD;;;;ACxBA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,0BAA0B,GAAG,KAAK,CAAC,CAAC;AAC0B;AAC1B;AACpC,MAAM,OAAO,GAAG;AAChB,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,uEAAuE,EAAE,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,KAAK;AAChJ,QAAQ,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;AAC1D,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,qCAAqC,EAAE,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,KAAK;AAC9G,QAAQ,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;AAC3D,KAAK,CAAC;AACN,CAAC,CAAC;AACF,SAAS,kBAAkB,CAAC,MAAM,EAAE;AACpC,IAAI,OAAOA,KAAO,CAAC,mBAAmB,CAAC,IAAIwB,aAAe,CAAC,mBAAmB,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AACnG,CAAC;AACD,0BAA0B,GAAG,kBAAkB,CAAC;AAChD;;;;AChBA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,wBAAwB,GAAG,0BAA0B,GAAG,uBAAuB,GAAG,kBAAkB,GAAG,mCAAmC,GAAG,KAAK,CAAC,CAAC;AAC/E;AACG;AACd;AACtB;AACpC,SAAS,2BAA2B,CAAC,QAAQ,EAAE;AAC/C,IAAI,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;AACpD,IAAI,OAAO,QAAQ,CAAC,IAAI,CAAC,OAAO,IAAI,cAAc,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;AACtE,CAAC;AACD,mCAAmC,GAAG,2BAA2B,CAAC;AAClE,SAAS,UAAU,CAAC,UAAU,EAAE;AAChC,IAAI,MAAM,QAAQ,GAAG,2BAA2B,CAAC,UAAU,CAAC,CAAC;AAC7D,IAAI,MAAM,QAAQ,GAAG,CAAC,QAAQ,EAAE,GAAG,UAAU,CAAC,CAAC;AAC/C,IAAI,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;AAC/B,QAAQ,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC5B,KAAK;AACL,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;AAClC,QAAQ,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;AACpC,KAAK;AACL,IAAI,OAAO;AACX,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,QAAQ;AAChB,QAAQ,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE;AAC/B,YAAY,IAAI,QAAQ,EAAE;AAC1B,gBAAgB,OAAOC,iBAAqB,CAAC,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AACzF,aAAa;AACb,YAAY,OAAOC,WAAc,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;AAC7D,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,kBAAkB,GAAG,UAAU,CAAC;AAChC,SAAS,eAAe,GAAG;AAC3B,IAAI,MAAM,MAAM,GAAGA,WAAc,CAAC,kBAAkB,CAAC;AACrD,IAAI,OAAO;AACX,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,QAAQ,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC;AAClC,QAAQ,MAAM;AACd,KAAK,CAAC;AACN,CAAC;AACD,uBAAuB,GAAG,eAAe,CAAC;AAC1C,SAAS,kBAAkB,CAAC,QAAQ,EAAE,WAAW,GAAG,KAAK,EAAE;AAC3D,IAAI,OAAO;AACX,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,QAAQ,EAAE,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI,EAAE,GAAG,QAAQ,CAAC;AAC1E,QAAQ,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE;AAC/B,YAAY,OAAOD,iBAAqB,CAAC,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAC9E,SAAS;AACT,QAAQ,OAAO,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE;AACzD,YAAY,IAAI,CAACA,iBAAqB,CAAC,sBAAsB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,EAAE;AACxF,gBAAgB,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;AACnC,aAAa;AACb,YAAY,IAAI,CAAC,MAAM,CAAC,CAAC;AACzB,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,0BAA0B,GAAG,kBAAkB,CAAC;AAChD,SAAS,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,KAAK,EAAE;AACvD,IAAI,MAAM,IAAI,GAAG;AACjB,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,QAAQ,EAAE,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI,EAAE,MAAM,CAAC;AACrE,QAAQ,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE;AAC/B,YAAY,OAAOA,iBAAqB,CAAC,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AAC/F,SAAS;AACT,QAAQ,OAAO,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE;AAC9D,YAAY,IAAI,CAACA,iBAAqB,CAAC,sBAAsB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,EAAE;AACxF,gBAAgB,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;AACnC,aAAa;AACb,YAAY,MAAM,IAAIjB,gBAAoB,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAACR,KAAO,CAAC,cAAc,CAAC,MAAM,CAAC,EAAEA,KAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AACxJ,SAAS;AACT,KAAK,CAAC;AACN,IAAI,OAAO,IAAI,CAAC;AAChB,CAAC;AACD,wBAAwB,GAAG,gBAAgB,CAAC;AAC5C;;;;AC1EA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,wBAAwB,GAAG,KAAK,CAAC,CAAC;AAClC;AACA;AACA;AACA,MAAM,gBAAgB,GAAG,CAAC,IAAI,KAAK;AACnC,IAAI,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;AAC5B,SAAS,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;AACjC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC,CAAC;AACF,wBAAwB,GAAG,gBAAgB,CAAC;AAC5C;;;;ACXA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,uBAAuB,GAAG,KAAK,CAAC,CAAC;AACyB;AAC1D,SAAS,eAAe,CAAC,KAAK,EAAE;AAChC,IAAI,OAAO;AACX,QAAQ,QAAQ,EAAE,CAAC,cAAc,EAAE,GAAG,KAAK,CAAC;AAC5C,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,EAAE2B,WAAa,CAAC,gBAAgB;AAC9C,KAAK,CAAC;AACN,CAAC;AACD,uBAAuB,GAAG,eAAe,CAAC;AAC1C;;;;ACXA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,uBAAuB,GAAG,iBAAiB,GAAG,KAAK,CAAC,CAAC;AACpB;AACG;AACpC,SAAS,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE;AAChD,IAAI,MAAM,QAAQ,GAAG,CAAC,OAAO,EAAE,GAAG,UAAU,CAAC,CAAC;AAC9C,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;AAClC,QAAQ,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC5B,KAAK;AACL,IAAI,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE;AACvC,QAAQ,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AACjC,KAAK;AACL,IAAI,OAAOzB,IAAM,CAAC,yBAAyB,CAAC,QAAQ,CAAC,CAAC;AACtD,CAAC;AACD,iBAAiB,GAAG,SAAS,CAAC;AAC9B,SAAS,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE;AACtD,IAAIF,KAAO,CAAC,MAAM,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;AAC3C,IAAI,OAAO,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;AAClD,CAAC;AACD,uBAAuB,GAAG,eAAe,CAAC;AAC1C;;;;ACpBA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,wBAAwB,GAAG,kBAAkB,GAAG,KAAK,CAAC,CAAC;AACnB;AACpC,MAAM,UAAU,CAAC;AACjB,IAAI,WAAW,GAAG;AAClB,QAAQ,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;AACxB,QAAQ,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAC1C,KAAK;AACL,IAAI,IAAI,GAAG,GAAG;AACd,QAAQ,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;AACxB,YAAY,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,KAAK;AACzD,gBAAgB,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAC7D,aAAa,EAAE,EAAE,CAAC,CAAC;AACnB,SAAS;AACT,QAAQ,OAAO,IAAI,CAAC,IAAI,CAAC;AACzB,KAAK;AACL,IAAI,OAAO,CAAC,IAAI,EAAE;AAClB,QAAQ,IAAI,EAAE,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,EAAE;AACpC,YAAY,MAAM,MAAM,GAAGA,KAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACpD,YAAY,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC;AACjF,YAAY,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAClC,SAAS;AACT,QAAQ,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AACjC,KAAK;AACL,IAAI,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE;AAC/B,QAAQ,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAC1C,QAAQ,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;AACzC,YAAY,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAChC,SAAS;AACT,aAAa,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE;AAC7C,YAAY,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACpC,SAAS;AACT,aAAa;AACb,YAAY,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;AAC/C,SAAS;AACT,QAAQ,IAAI,CAAC,IAAI,GAAG,SAAS,CAAC;AAC9B,KAAK;AACL,CAAC;AACD,kBAAkB,GAAG,UAAU,CAAC;AAChC,SAAS,gBAAgB,CAAC,IAAI,EAAE;AAChC,IAAI,MAAM,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;AACpC,IAAI,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AACnC,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,GAAG;AACtD,QAAQ,MAAM,IAAI,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAChD,QAAQ,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,GAAGA,KAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;AAC/D,QAAQ,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAC1C,KAAK;AACL,IAAI,OAAO,MAAM,CAAC;AAClB,CAAC;AACD,wBAAwB,GAAG,gBAAgB,CAAC;AAC5C,SAAS,cAAc,CAAC,QAAQ,EAAE;AAClC,IAAI,OAAO,QAAQ,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;AAC5C,CAAC;AACD;;;;ACrDA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,sBAAsB,GAAG,qBAAqB,GAAG,KAAK,CAAC,CAAC;AACA;AACxD,SAAS,aAAa,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE;AACnD,IAAI,MAAM,QAAQ,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AAC3C,IAAI,IAAI,MAAM,EAAE;AAChB,QAAQ,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC/B,KAAK;AACL,IAAI,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;AAC9B,IAAI,OAAO;AACX,QAAQ,QAAQ;AAChB,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,CAAC,IAAI,EAAE;AACrB,YAAY,OAAO,IAAI,CAAC;AACxB,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,qBAAqB,GAAG,aAAa,CAAC;AACtC,SAAS,cAAc,GAAG;AAC1B,IAAI,OAAO;AACX,QAAQ,QAAQ,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,QAAQ,CAAC;AACjE,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,CAAC,IAAI,EAAE;AACrB,YAAY,OAAO,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;AACvD,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,sBAAsB,GAAG,cAAc,CAAC;AACxC;;;;AC5BA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,yBAAyB,GAAG,KAAK,CAAC,CAAC;AACC;AACpC,MAAM,OAAO,GAAG;AAChB,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,kCAAkC,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK;AACnG,QAAQ,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;AAC/B,QAAQ,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;AAC/B,QAAQ,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC;AAC7B,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,mBAAmB,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,KAAK;AACtE,QAAQ,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AACxC,QAAQ,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC;AAClC,QAAQ,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;AAC5C,YAAY,OAAO;AACnB,SAAS;AACT,QAAQ,MAAM,CAAC,MAAM,GAAG;AACxB,YAAY,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;AACpD,YAAY,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE;AACxC,SAAS,CAAC;AACV,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,4CAA4C,EAAE,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,CAAC,KAAK;AACvH,QAAQ,MAAM,CAAC,OAAO,CAAC,OAAO,GAAG,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;AAC5D,QAAQ,MAAM,CAAC,OAAO,CAAC,UAAU,GAAG,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;AAClE,QAAQ,MAAM,CAAC,OAAO,CAAC,SAAS,GAAG,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;AAChE,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,wCAAwC,EAAE,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK;AAC9G,QAAQ,MAAM,CAAC,OAAO,CAAC,OAAO,GAAG,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;AAC5D,QAAQ,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;AAC/C,QAAQ,IAAI,SAAS,KAAK,GAAG,EAAE;AAC/B,YAAY,MAAM,CAAC,OAAO,CAAC,SAAS,GAAG,KAAK,CAAC;AAC7C,SAAS;AACT,aAAa,IAAI,SAAS,KAAK,GAAG,EAAE;AACpC,YAAY,MAAM,CAAC,OAAO,CAAC,UAAU,GAAG,KAAK,CAAC;AAC9C,SAAS;AACT,KAAK,CAAC;AACN,CAAC,CAAC;AACF,SAAS,iBAAiB,CAAC,MAAM,EAAE;AACnC,IAAI,MAAM,MAAM,GAAG;AACnB,QAAQ,MAAM,EAAE,IAAI;AACpB,QAAQ,MAAM,EAAE,EAAE;AAClB,QAAQ,MAAM,EAAE,EAAE;AAClB,QAAQ,IAAI,EAAE,KAAK;AACnB,QAAQ,OAAO,EAAE;AACjB,YAAY,OAAO,EAAE,CAAC;AACtB,YAAY,UAAU,EAAE,CAAC;AACzB,YAAY,SAAS,EAAE,CAAC;AACxB,SAAS;AACT,KAAK,CAAC;AACN,IAAI,OAAOA,KAAO,CAAC,mBAAmB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AAChE,CAAC;AACD,yBAAyB,GAAG,iBAAiB,CAAC;AAC9C;;;;ACnDA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,kBAAkB,GAAG,KAAK,CAAC,CAAC;AAC8B;AAC1D,SAAS,UAAU,CAAC,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE;AAChD,IAAI,MAAM,QAAQ,GAAG,CAAC,QAAQ,CAAC,CAAC;AAChC,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;AACnD,IAAI,QAAQ,CAAC,IAAI,CAAC,GAAG,KAAK,EAAE,GAAG,UAAU,CAAC,CAAC;AAC3C,IAAI,OAAO;AACX,QAAQ,QAAQ;AAChB,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,EAAE4B,WAAc,CAAC,iBAAiB;AAChD,KAAK,CAAC;AACN,CAAC;AACD,kBAAkB,GAAG,UAAU,CAAC;AAChC;;;;ACdA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,mBAAmB,GAAG,KAAK,CAAC,CAAC;AAC7B;AACA;AACA;AACA,MAAM,WAAW,CAAC;AAClB,IAAI,WAAW,GAAG;AAClB,QAAQ,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;AACzB,QAAQ,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;AAC3B,QAAQ,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;AAC5B,QAAQ,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;AACxB,KAAK;AACL,CAAC;AACD,mBAAmB,GAAG,WAAW,CAAC;AAClC;;;;ACdA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,uBAAuB,GAAG,KAAK,CAAC,CAAC;AACyB;AAC1D,SAAS,eAAe,CAAC,MAAM,EAAE;AACjC,IAAI,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AAC5C,IAAI,MAAM,MAAM,GAAG,IAAI,aAAa,CAAC,WAAW,EAAE,CAAC;AACnD,IAAI,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC;AACzC,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;AACtD,QAAQ,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAC9B,QAAQ,cAAc,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AACvE,KAAK;AACL,IAAI,OAAO,MAAM,CAAC;AAClB,CAAC;AACD,uBAAuB,GAAG,eAAe,CAAC;AAC1C,SAAS,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE;AAC1C,IAAI,CAAC,OAAO,IAAI,EAAE;AAClB,SAAS,IAAI,EAAE;AACf,SAAS,KAAK,CAAC,IAAI,CAAC;AACpB,SAAS,OAAO,CAAC,UAAU,IAAI,EAAE;AACjC,QAAQ,MAAM,OAAO,GAAG,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACrD,QAAQ,IAAI,CAAC,OAAO,EAAE;AACtB,YAAY,OAAO;AACnB,SAAS;AACT,QAAQ,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;AAClE,KAAK,CAAC,CAAC;AACP,CAAC;AACD,SAAS,WAAW,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE;AACzC,IAAI,MAAM,KAAK,IAAI,eAAe,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAC9C,IAAI,IAAI,CAAC,KAAK,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE;AAC3C,QAAQ,OAAO;AACf,KAAK;AACL,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAC1C,CAAC;AACD,MAAM,YAAY,GAAG;AACrB,IAAI,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE;AACxB,QAAQ,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC;AAC/B,KAAK;AACL,IAAI,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE;AAC5B,QAAQ,MAAM,CAAC,SAAS,GAAG,KAAK,CAAC;AACjC,KAAK;AACL,IAAI,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE;AAC7B,QAAQ,MAAM,CAAC,UAAU,GAAG,KAAK,CAAC;AAClC,KAAK;AACL,CAAC,CAAC;AACF,SAAS,cAAc,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE;AAC1C,IAAI,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,iCAAiC,CAAC,CAAC;AACvE,IAAI,IAAI,IAAI,EAAE;AACd,QAAQ,IAAI,WAAW,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC;AACjD,QAAQ,KAAK,CAAC,IAAI,CAAC;AACnB,YAAY,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;AAChC,YAAY,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;AAC1C,YAAY,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,MAAM;AAC5D,YAAY,SAAS,EAAE,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,MAAM;AAC5D,YAAY,MAAM,EAAE,KAAK;AACzB,SAAS,CAAC,CAAC;AACX,QAAQ,OAAO,IAAI,CAAC;AACpB,KAAK;AACL,IAAI,OAAO,KAAK,CAAC;AACjB,CAAC;AACD,SAAS,gBAAgB,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE;AAC5C,IAAI,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,iDAAiD,CAAC,CAAC;AAChF,IAAI,IAAI,IAAI,EAAE;AACd,QAAQ,KAAK,CAAC,IAAI,CAAC;AACnB,YAAY,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;AAChC,YAAY,MAAM,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;AAC5B,YAAY,KAAK,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;AAC3B,YAAY,MAAM,EAAE,IAAI;AACxB,SAAS,CAAC,CAAC;AACX,QAAQ,OAAO,IAAI,CAAC;AACpB,KAAK;AACL,IAAI,OAAO,KAAK,CAAC;AACjB,CAAC;AACD;;;;ACxEA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,uBAAuB,GAAG,KAAK,CAAC,CAAC;AACqC;AACtE,SAAS,eAAe,CAAC,UAAU,EAAE;AACrC,IAAI,OAAO;AACX,QAAQ,QAAQ,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,UAAU,CAAC;AACxD,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,CAAC,MAAM,EAAE;AACvB,YAAY,OAAOC,gBAAoB,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;AAChE,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,uBAAuB,GAAG,eAAe,CAAC;AAC1C;;;;ACbA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,wBAAwB,GAAG,KAAK,CAAC,CAAC;AACE;AACpC,MAAM,OAAO,GAAG;AAChB,IAAI,IAAI7B,KAAO,CAAC,UAAU,CAAC,YAAY,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,KAAK;AAC/D,QAAQ,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;AAC/B,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,qCAAqC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,KAAK;AAChG,QAAQ,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC;AAC7B,YAAY,IAAI;AAChB,YAAY,QAAQ;AACpB,SAAS,CAAC,CAAC;AACX,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,kCAAkC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,KAAK;AAC7F,QAAQ,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;AACzB,YAAY,IAAI;AAChB,YAAY,QAAQ;AACpB,SAAS,CAAC,CAAC;AACX,KAAK,CAAC;AACN,CAAC,CAAC;AACF,SAAS,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE;AAC1C,IAAI,MAAM,MAAM,GAAG;AACnB,QAAQ,GAAG,EAAE,MAAM;AACnB,QAAQ,MAAM,EAAE,IAAI;AACpB,QAAQ,QAAQ,EAAE,EAAE;AACpB,QAAQ,IAAI,EAAE,EAAE;AAChB,KAAK,CAAC;AACN,IAAI,OAAOA,KAAO,CAAC,mBAAmB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AACxE,CAAC;AACD,wBAAwB,GAAG,gBAAgB,CAAC;AAC5C;;;;AC9BA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,iBAAiB,GAAG,KAAK,CAAC,CAAC;AAC6B;AACxD,SAAS,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE;AAC/C,IAAI,MAAM,QAAQ,GAAG,CAAC,OAAO,EAAE,GAAG,UAAU,CAAC,CAAC;AAC9C,IAAI,IAAI,MAAM,IAAI,MAAM,EAAE;AAC1B,QAAQ,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AACtC,KAAK;AACL,IAAI,OAAO;AACX,QAAQ,QAAQ;AAChB,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,EAAE8B,UAAa,CAAC,gBAAgB;AAC9C,KAAK,CAAC;AACN,CAAC;AACD,iBAAiB,GAAG,SAAS,CAAC;AAC9B;;;;ACfA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,sBAAsB,GAAG,KAAK,CAAC,CAAC;AACC;AACjC;AACA;AACA;AACA,SAAS,cAAc,CAAC,QAAQ,EAAE,KAAK,EAAE;AACzC,IAAI,MAAM,QAAQ,GAAG,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;AAC/C,IAAI,IAAI,KAAK,EAAE;AACf,QAAQ,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC5B,KAAK;AACL,IAAI,OAAO5B,IAAM,CAAC,yBAAyB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;AAC5D,CAAC;AACD,sBAAsB,GAAG,cAAc,CAAC;AACxC;;;;ACdA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,iBAAiB,GAAG,mBAAmB,GAAG,KAAK,CAAC,CAAC;AACjD,MAAM,WAAW,CAAC;AAClB,IAAI,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE;AAC9C,QAAQ,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;AACzB,QAAQ,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;AACzB,QAAQ,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;AACjC,QAAQ,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;AAC7B,KAAK;AACL,CAAC;AACD,mBAAmB,GAAG,WAAW,CAAC;AAClC,MAAM,iBAAiB,GAAG,6BAA6B,CAAC;AACxD,MAAM,mBAAmB,GAAG,kBAAkB,CAAC;AAC/C,SAAS,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE;AACrC,IAAI,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;AACzC,IAAI,IAAI,MAAM,CAAC;AACf,IAAI,KAAK,MAAM,GAAG,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG;AACrD,QAAQ,OAAO,IAAI,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAC7D,KAAK;AACL,IAAI,KAAK,MAAM,GAAG,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG;AACvD,QAAQ,OAAO,IAAI,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAC5D,KAAK;AACL,IAAI,IAAI,MAAM,GAAG,EAAE,CAAC;AACpB,IAAI,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AACvC,IAAI,OAAO,MAAM,CAAC,MAAM,EAAE;AAC1B,QAAQ,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC;AACrC,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE;AAC5B,YAAY,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACtC,YAAY,MAAM;AAClB,SAAS;AACT,KAAK;AACL,IAAI,OAAO,IAAI,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAC;AACtE,CAAC;AACD,iBAAiB,GAAG,SAAS,CAAC;AAC9B;;;;AClCA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,gBAAgB,GAAG,KAAK,CAAC,CAAC;AACgC;AAC1D,MAAM,WAAW,GAAG,QAAQ,CAAC;AAC7B,SAAS,cAAc,CAAC,OAAO,EAAE;AACjC,IAAI,OAAO,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AACzC,CAAC;AACD,SAAS,QAAQ,CAAC,IAAI,GAAG,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE;AAClD,IAAI,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,CAAC;AAC7C,IAAI,IAAI,IAAI,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE;AAC3C,QAAQ,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC;AAC3C,KAAK;AACL,IAAI,OAAO;AACX,QAAQ,QAAQ;AAChB,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,CAAC,IAAI,EAAE;AACrB,YAAY,OAAO,aAAa,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AACpF,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,gBAAgB,GAAG,QAAQ,CAAC;AAC5B;;;;ACrBA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,kCAAkC,GAAG,gBAAgB,GAAG,uBAAuB,GAAG,sBAAsB,GAAG,KAAK,CAAC,CAAC;AAC9E;AACyB;AAC7D,sBAAsB,GAAG,SAAS,CAAC;AACnC,uBAAuB,GAAG,KAAK,CAAC;AAChC,gBAAgB,GAAG,KAAK,CAAC;AACzB,MAAM,iBAAiB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc,CAAC,CAAC;AAC7F,SAAS,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE;AACrC,IAAI,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,KAAK;AACjD,QAAQ,IAAI,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;AAC1C,QAAQ,OAAO,IAAI,CAAC;AACpB,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;AACtC,CAAC;AACD,SAAS,0BAA0B,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,EAAE;AAC7F,IAAI,OAAO,UAAU,MAAM,EAAE;AAC7B,QAAQ,MAAM,GAAG,GAAGF,KAAO,CAAC,kBAAkB,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,cAAc,CAAC;AACpF,aAAa,GAAG,CAAC,UAAU,IAAI,EAAE;AACjC,YAAY,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;AAC1E,YAAY,MAAM,WAAW,GAAG,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAC;AAC1F,YAAY,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE;AACjE,gBAAgB,WAAW,CAAC,IAAI,GAAG6B,gBAAoB,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AACvF,aAAa;AACb,YAAY,OAAO,WAAW,CAAC;AAC/B,SAAS,CAAC,CAAC;AACX,QAAQ,OAAO;AACf,YAAY,GAAG;AACf,YAAY,MAAM,EAAE,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,IAAI;AAChD,YAAY,KAAK,EAAE,GAAG,CAAC,MAAM;AAC7B,SAAS,CAAC;AACV,KAAK,CAAC;AACN,CAAC;AACD,kCAAkC,GAAG,0BAA0B,CAAC;AAChE;;;;ACjCA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,eAAe,GAAG,uBAAuB,GAAG,KAAK,CAAC,CAAC;AAC2B;AAC1C;AACpC,IAAI,cAAc,CAAC;AACnB,CAAC,UAAU,cAAc,EAAE;AAC3B,IAAI,cAAc,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC;AAChE,IAAI,cAAc,CAAC,cAAc,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,WAAW,CAAC;AAClE,IAAI,cAAc,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC;AAChE,IAAI,cAAc,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC;AAClD,IAAI,cAAc,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC;AACxD,IAAI,cAAc,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC;AAC5D,IAAI,cAAc,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC;AACxD,IAAI,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;AACpD,IAAI,cAAc,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC;AAChE,IAAI,cAAc,CAAC,cAAc,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,WAAW,CAAC;AAClE,IAAI,cAAc,CAAC,cAAc,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC,GAAG,WAAW,CAAC;AACnE,IAAI,cAAc,CAAC,cAAc,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,GAAG,YAAY,CAAC;AACrE,CAAC,EAAE,cAAc,KAAK,cAAc,GAAG,EAAE,CAAC,CAAC,CAAC;AAC5C,SAAS,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE;AACxC,IAAI,MAAM,MAAM,GAAG,EAAE,CAAC;AACtB,IAAI,MAAM,SAAS,GAAG,EAAE,CAAC;AACzB,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,KAAK,KAAK;AAC3C,QAAQ,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC3B,QAAQ,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAC9C,KAAK,CAAC,CAAC;AACP,IAAI,OAAO;AACX,QAAQ,MAAM,EAAE,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC;AACxC,KAAK,CAAC;AACN,CAAC;AACD,SAAS,WAAW,CAAC,KAAK,EAAE;AAC5B,IAAI,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;AAC5C,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,GAAG,IAAI;AACtC,QAAQ,IAAI,GAAG,IAAI,cAAc,EAAE;AACnC,YAAY,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;AAC/B,SAAS;AACT,KAAK,CAAC,CAAC;AACP,IAAI,OAAO,MAAM,CAAC;AAClB,CAAC;AACD,SAAS,eAAe,CAAC,GAAG,GAAG,EAAE,EAAE,UAAU,GAAG,EAAE,EAAE;AACpD,IAAI,MAAM,QAAQ,GAAG,GAAG,CAAC,QAAQ,IAAIE,mBAAwB,CAAC,QAAQ,CAAC;AACvE,IAAI,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,IAAI;AACjC,QAAQ,IAAI,EAAE,IAAI;AAClB,QAAQ,IAAI,EAAE,GAAG,CAAC,UAAU,KAAK,KAAK,GAAG,KAAK,GAAG,KAAK;AACtD,QAAQ,OAAO,EAAE,IAAI;AACrB,QAAQ,IAAI,EAAE,IAAI;AAClB,QAAQ,IAAI,EAAE,GAAG,CAAC,SAAS,GAAG,IAAI,GAAG,IAAI;AACzC,QAAQ,WAAW,EAAE,KAAK;AAC1B,QAAQ,YAAY,EAAE,KAAK;AAC3B,KAAK,CAAC;AACN,IAAI,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AAC/D,IAAI,MAAM,MAAM,GAAG,EAAE,CAAC;AACtB,IAAI,MAAM,OAAO,GAAG;AACpB,QAAQ,CAAC,gBAAgB,EAAEA,mBAAwB,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC,EAAEA,mBAAwB,CAAC,eAAe,CAAC,CAAC;AAC3H,QAAQ,GAAG,UAAU;AACrB,KAAK,CAAC;AACN,IAAI,MAAM,QAAQ,GAAG,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC,WAAW,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC;AAC/D,IAAI,IAAI,QAAQ,EAAE;AAClB,QAAQ,OAAO,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;AAChD,KAAK;AACL,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,EAAE,EAAE;AAC5B,QAAQ,MAAM,aAAa,GAAG,CAAC,GAAG,CAAC,SAAS,KAAK,KAAK,IAAI,KAAK,GAAG,IAAI,CAAC;AACvE,QAAQ,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC5D,KAAK;AACL,IAAI,IAAI,GAAG,CAAC,IAAI,EAAE;AAClB,QAAQ,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;AAC1C,KAAK;AACL,IAAI/B,KAAO,CAAC,iBAAiB,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;AACzD,IAAI,OAAO;AACX,QAAQ,MAAM;AACd,QAAQ,QAAQ;AAChB,QAAQ,QAAQ,EAAE;AAClB,YAAY,GAAG,OAAO;AACtB,YAAY,GAAG,MAAM;AACrB,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,uBAAuB,GAAG,eAAe,CAAC;AAC1C,SAAS,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE;AAC/C,IAAI,OAAO;AACX,QAAQ,QAAQ,EAAE,CAAC,KAAK,EAAE,GAAG,UAAU,CAAC;AACxC,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,EAAE+B,mBAAwB,CAAC,0BAA0B,CAAC,QAAQ,EAAE,MAAM,CAAC;AACrF,KAAK,CAAC;AACN,CAAC;AACD,eAAe,GAAG,OAAO,CAAC;AAC1B;;;;ACtFA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,0BAA0B,GAAG,4BAA4B,GAAG,KAAK,CAAC,CAAC;AACnE,MAAM,oBAAoB,CAAC;AAC3B,IAAI,WAAW,CAAC,MAAM,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,EAAE;AAC3C,QAAQ,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;AAC7B,QAAQ,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;AACzB,QAAQ,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;AACzB,KAAK;AACL,IAAI,QAAQ,GAAG;AACf,QAAQ,OAAO,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;AAC7C,KAAK;AACL,CAAC;AACD,4BAA4B,GAAG,oBAAoB,CAAC;AACpD,MAAM,kBAAkB,CAAC;AACzB,IAAI,WAAW,GAAG;AAClB,QAAQ,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;AAC5B,QAAQ,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;AACzB,QAAQ,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;AAChC,KAAK;AACL,IAAI,IAAI,MAAM,GAAG;AACjB,QAAQ,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;AACzC,KAAK;AACL,IAAI,IAAI,MAAM,GAAG;AACjB,QAAQ,OAAO,IAAI,CAAC,MAAM,CAAC;AAC3B,KAAK;AACL,IAAI,QAAQ,GAAG;AACf,QAAQ,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;AACnC,YAAY,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAC7D,SAAS;AACT,QAAQ,OAAO,IAAI,CAAC;AACpB,KAAK;AACL,CAAC;AACD,0BAA0B,GAAG,kBAAkB,CAAC;AAChD;;;;ACjCA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,mBAAmB,GAAG,KAAK,CAAC,CAAC;AAC7B,MAAM,WAAW,CAAC;AAClB,IAAI,WAAW,GAAG;AAClB,QAAQ,IAAI,CAAC,cAAc,GAAG;AAC9B,YAAY,GAAG,EAAE,EAAE;AACnB,SAAS,CAAC;AACV,QAAQ,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;AAC1B,QAAQ,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;AAC1B,QAAQ,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;AACxB,QAAQ,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;AAC5B,QAAQ,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;AAC7B,QAAQ,IAAI,CAAC,OAAO,GAAG;AACvB,YAAY,OAAO,EAAE,CAAC;AACtB,YAAY,SAAS,EAAE,CAAC;AACxB,YAAY,UAAU,EAAE,CAAC;AACzB,SAAS,CAAC;AACV,KAAK;AACL,CAAC;AACD,mBAAmB,GAAG,WAAW,CAAC;AAClC;;;;ACpBA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,uBAAuB,GAAG,uBAAuB,GAAG,KAAK,CAAC,CAAC;AACD;AACtB;AAC+B;AACnE,MAAM,iBAAiB,GAAG,kCAAkC,CAAC;AAC7D,MAAM,aAAa,GAAG,8CAA8C,CAAC;AACrE,MAAM,YAAY,GAAG,gCAAgC,CAAC;AACtD,MAAM,OAAO,GAAG;AAChB,IAAI,IAAI/B,KAAO,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,CAAC,KAAK;AACzF,QAAQ,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAChC,QAAQ,IAAI,UAAU,EAAE;AACxB,YAAY,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC;AACxD,SAAS;AACT,QAAQ,IAAI,SAAS,EAAE;AACvB,YAAY,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC;AACtD,SAAS;AACT,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC,MAAM,EAAE,CAAC,OAAO,IAAI,UAAU,IAAI,SAAS,CAAC,KAAK;AAC5F,QAAQ,IAAI,UAAU,KAAK,SAAS,IAAI,SAAS,KAAK,SAAS,EAAE;AACjE,YAAY,MAAM,CAAC,OAAO,CAAC,OAAO,GAAG,CAAC,OAAO,IAAI,CAAC,CAAC;AACnD,YAAY,MAAM,CAAC,OAAO,CAAC,UAAU,GAAG,CAAC,UAAU,IAAI,CAAC,CAAC;AACzD,YAAY,MAAM,CAAC,OAAO,CAAC,SAAS,GAAG,CAAC,SAAS,IAAI,CAAC,CAAC;AACvD,YAAY,OAAO,IAAI,CAAC;AACxB,SAAS;AACT,QAAQ,OAAO,KAAK,CAAC;AACrB,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,YAAY,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK;AACrE,QAAQA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AAC3C,QAAQA,KAAO,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACtF,KAAK,CAAC;AACN,CAAC,CAAC;AACF,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK;AAC5C,IAAI,OAAOA,KAAO,CAAC,mBAAmB,CAAC,IAAI,aAAa,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AACjG,CAAC,CAAC;AACF,uBAAuB,GAAG,eAAe,CAAC;AAC1C,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK;AAC5C,IAAI,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,aAAa,CAAC,WAAW,EAAE,EAAE,OAAO,CAAC,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,EAAEkB,qBAAuB,CAAC,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAChK,CAAC,CAAC;AACF,uBAAuB,GAAG,eAAe,CAAC;AAC1C;;;;ACxCA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,wBAAwB,GAAG,wBAAwB,GAAG,KAAK,CAAC,CAAC;AACD;AACxB;AACS;AAC7C,MAAM,OAAO,GAAG;AAChB,IAAI,IAAIlB,KAAO,CAAC,UAAU,CAAC,uBAAuB,EAAE,CAAC,OAAO,EAAE,CAAC,SAAS,CAAC,KAAK;AAC9E,QAAQ,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AACvC,KAAK,CAAC;AACN,IAAI,IAAIA,KAAO,CAAC,UAAU,CAAC,+CAA+C,EAAE,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK;AACzG,QAAQ,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,IAAIgC,YAAc,CAAC,oBAAoB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;AACtF,KAAK,CAAC;AACN,IAAI,IAAIhC,KAAO,CAAC,UAAU,CAAC,wDAAwD,EAAE,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,KAAK;AAC7H,QAAQ,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,IAAIgC,YAAc,CAAC,oBAAoB,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;AACrG,KAAK,CAAC;AACN,IAAI,IAAIhC,KAAO,CAAC,UAAU,CAAC,uBAAuB,EAAE,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,KAAK;AAC3E,QAAQ,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,IAAIgC,YAAc,CAAC,oBAAoB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;AACtF,KAAK,CAAC;AACN,IAAI,IAAIhC,KAAO,CAAC,UAAU,CAAC,kCAAkC,EAAE,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,KAAK;AACtF,QAAQ,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC;AAChC,KAAK,CAAC;AACN,CAAC,CAAC;AACF;AACA;AACA;AACA,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK;AAC7C,IAAI,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,EAAEiC,SAAY,CAAC,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AACjH,CAAC,CAAC;AACF,wBAAwB,GAAG,gBAAgB,CAAC;AAC5C;AACA;AACA;AACA;AACA,MAAM,gBAAgB,GAAG,CAAC,MAAM,KAAK;AACrC,IAAI,OAAOjC,KAAO,CAAC,mBAAmB,CAAC,IAAIgC,YAAc,CAAC,kBAAkB,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AACjG,CAAC,CAAC;AACF,wBAAwB,GAAG,gBAAgB,CAAC;AAC5C;;;;ACrCA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,iBAAiB,GAAG,KAAK,CAAC,CAAC;AAC0C;AACb;AACvB;AACjC,SAAS,SAAS,CAAC,UAAU,EAAE;AAC/B,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE;AAC5B,QAAQ,OAAO9B,IAAM,CAAC,sBAAsB,CAAC,wCAAwC,CAAC,CAAC;AACvF,KAAK;AACL,IAAI,OAAO;AACX,QAAQ,QAAQ,EAAE,CAAC,OAAO,EAAE,GAAG,UAAU,CAAC;AAC1C,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE;AAC/B,YAAY,MAAM,KAAK,GAAGgC,UAAa,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AACzE,YAAY,IAAI,KAAK,CAAC,MAAM,EAAE;AAC9B,gBAAgB,MAAM,IAAI1B,gBAAoB,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;AACvE,aAAa;AACb,YAAY,OAAO,KAAK,CAAC;AACzB,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,iBAAiB,GAAG,SAAS,CAAC;AAC9B;;;;ACtBA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,uBAAuB,GAAG,KAAK,CAAC,CAAC;AACG;AACpC,MAAM,OAAO,GAAG;AAChB,IAAI,IAAIR,KAAO,CAAC,UAAU,CAAC,yBAAyB,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK;AAC9E,QAAQ,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;AACxC,KAAK,CAAC;AACN,CAAC,CAAC;AACF,SAAS,eAAe,CAAC,MAAM,EAAE;AACjC,IAAI,OAAOA,KAAO,CAAC,mBAAmB,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AACvE,CAAC;AACD,uBAAuB,GAAG,eAAe,CAAC;AAC1C;;;;ACZA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,gBAAgB,GAAG,KAAK,CAAC,CAAC;AAC4B;AAClB;AACpC,SAAS,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE;AAC5B,IAAI,OAAO;AACX,QAAQ,QAAQ,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAGA,KAAO,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;AAC5D,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,EAAEmC,SAAY,CAAC,eAAe;AAC5C,KAAK,CAAC;AACN,CAAC;AACD,gBAAgB,GAAG,QAAQ,CAAC;AAC5B;;;;ACZA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,gBAAgB,GAAG,KAAK,CAAC,CAAC;AAC4B;AACtD,SAAS,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE;AAC9C,IAAI,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,CAAC;AAC7C,IAAI,IAAI,MAAM,IAAI,MAAM,EAAE;AAC1B,QAAQ,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAC9C,KAAK;AACL,IAAI,OAAO;AACX,QAAQ,QAAQ;AAChB,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE;AAC/B,YAAY,OAAOF,SAAY,CAAC,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAChE,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,gBAAgB,GAAG,QAAQ,CAAC;AAC5B;;;;ACjBA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,8BAA8B,GAAG,uBAAuB,GAAG,KAAK,CAAC,CAAC;AAC9B;AACpC,SAAS,eAAe,CAAC,IAAI,EAAE;AAC/B,IAAI,MAAM,OAAO,GAAG,EAAE,CAAC;AACvB,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;AACxD,IAAI,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AAClC,CAAC;AACD,uBAAuB,GAAG,eAAe,CAAC;AAC1C,SAAS,sBAAsB,CAAC,IAAI,EAAE;AACtC,IAAI,MAAM,OAAO,GAAG,EAAE,CAAC;AACvB,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,KAAK;AAC5C,QAAQ,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE;AAC3C,YAAY,OAAO,CAAC,IAAI,CAAC,GAAG;AAC5B,gBAAgB,IAAI,EAAE,IAAI;AAC1B,gBAAgB,IAAI,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;AAC7C,aAAa,CAAC;AACd,SAAS;AACT,QAAQ,IAAI,OAAO,IAAI,GAAG,EAAE;AAC5B,YAAY,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC;AACrE,SAAS;AACT,KAAK,CAAC,CAAC;AACP,IAAI,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AAClC,CAAC;AACD,8BAA8B,GAAG,sBAAsB,CAAC;AACxD,SAAS,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE;AAChC,IAAIjC,KAAO,CAAC,sBAAsB,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAC/E,CAAC;AACD;;;;AC5BA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,wBAAwB,GAAG,kBAAkB,GAAG,uBAAuB,GAAG,sBAAsB,GAAG,qBAAqB,GAAG,KAAK,CAAC,CAAC;AAC9D;AACnC;AACjC,SAAS,aAAa,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,GAAG,EAAE,EAAE;AAChE,IAAI,OAAOE,IAAM,CAAC,yBAAyB,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;AACtG,CAAC;AACD,qBAAqB,GAAG,aAAa,CAAC;AACtC,SAAS,cAAc,CAAC,OAAO,EAAE;AACjC,IAAI,MAAM,QAAQ,GAAG,CAAC,QAAQ,CAAC,CAAC;AAChC,IAAI,IAAI,OAAO,EAAE;AACjB,QAAQ,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC5B,KAAK;AACL,IAAI,OAAO;AACX,QAAQ,QAAQ;AAChB,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM,EAAE,OAAO,GAAGkC,gBAAkB,CAAC,sBAAsB,GAAGA,gBAAkB,CAAC,eAAe;AACxG,KAAK,CAAC;AACN,CAAC;AACD,sBAAsB,GAAG,cAAc,CAAC;AACxC,SAAS,eAAe,CAAC,UAAU,GAAG,EAAE,EAAE;AAC1C,IAAI,MAAM,QAAQ,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC;AACrC,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,WAAW,EAAE;AACrC,QAAQ,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;AACtC,KAAK;AACL,IAAI,OAAOlC,IAAM,CAAC,yBAAyB,CAAC,QAAQ,CAAC,CAAC;AACtD,CAAC;AACD,uBAAuB,GAAG,eAAe,CAAC;AAC1C,SAAS,UAAU,CAAC,UAAU,GAAG,EAAE,EAAE;AACrC,IAAI,MAAM,QAAQ,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC;AACrC,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE;AAClC,QAAQ,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACnC,KAAK;AACL,IAAI,OAAOA,IAAM,CAAC,yBAAyB,CAAC,QAAQ,CAAC,CAAC;AACtD,CAAC;AACD,kBAAkB,GAAG,UAAU,CAAC;AAChC,SAAS,gBAAgB,CAAC,UAAU,EAAE;AACtC,IAAI,OAAOA,IAAM,CAAC,yBAAyB,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC;AAC9E,CAAC;AACD,wBAAwB,GAAG,gBAAgB,CAAC;AAC5C;;;;ACxCA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,qBAAqB,GAAG,KAAK,CAAC,CAAC;AAC+C;AAC/C;AAC/B,SAAS,aAAa,CAAC,GAAG,GAAG,EAAE,EAAE,UAAU,EAAE;AAC7C,IAAI,MAAM,OAAO,GAAGmC,GAAK,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;AAC/C,IAAI,MAAM,MAAM,GAAGN,mBAAwB,CAAC,0BAA0B,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;AACzG,IAAI,OAAO;AACX,QAAQ,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,GAAG,UAAU,CAAC;AACvE,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,MAAM;AACd,KAAK,CAAC;AACN,CAAC;AACD,qBAAqB,GAAG,aAAa,CAAC;AACtC;;;;ACdA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,yBAAyB,GAAG,qBAAqB,GAAG,KAAK,CAAC,CAAC;AAC3D,qBAAqB,GAAG,gBAAgB,CAAC;AACzC,MAAM,iBAAiB,CAAC;AACxB,IAAI,WAAW,CAAC,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE;AAC1C,QAAQ,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;AACzB,QAAQ,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;AAC3B,QAAQ,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;AACvC,QAAQ,IAAI,GAAG,MAAM,KAAK,GAAG,WAAW,CAAC,EAAE;AAC3C,YAAY,MAAM,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAClF,YAAY,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;AACxC,YAAY,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;AACxC,SAAS;AACT,KAAK;AACL,CAAC;AACD,yBAAyB,GAAG,iBAAiB,CAAC;AAC9C;;;;AChBA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,0BAA0B,GAAG,qBAAqB,GAAG,KAAK,CAAC,CAAC;AACxB;AACuB;AAC3D;AACA;AACA;AACA,MAAM,aAAa,CAAC;AACpB,IAAI,WAAW,GAAG;AAClB,QAAQ,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;AAC5B,QAAQ,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;AAC7B,QAAQ,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;AAC1B,QAAQ,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;AAC1B,QAAQ,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;AAC3B,QAAQ,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;AAC1B;AACA;AACA;AACA;AACA,QAAQ,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;AACxB,QAAQ,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;AACzB;AACA;AACA;AACA,QAAQ,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;AACvB;AACA;AACA;AACA,QAAQ,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;AACxB;AACA;AACA;AACA,QAAQ,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;AAC5B;AACA;AACA;AACA,QAAQ,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;AAC7B,KAAK;AACL;AACA;AACA;AACA,IAAI,OAAO,GAAG;AACd,QAAQ,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;AAClC,KAAK;AACL,CAAC;AACD,qBAAqB,GAAG,aAAa,CAAC;AACtC,IAAI,mBAAmB,CAAC;AACxB,CAAC,UAAU,mBAAmB,EAAE;AAChC,IAAI,mBAAmB,CAAC,OAAO,CAAC,GAAG,GAAG,CAAC;AACvC,IAAI,mBAAmB,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC;AACzC,IAAI,mBAAmB,CAAC,UAAU,CAAC,GAAG,GAAG,CAAC;AAC1C,IAAI,mBAAmB,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC;AACzC,IAAI,mBAAmB,CAAC,QAAQ,CAAC,GAAG,GAAG,CAAC;AACxC,IAAI,mBAAmB,CAAC,UAAU,CAAC,GAAG,GAAG,CAAC;AAC1C,IAAI,mBAAmB,CAAC,WAAW,CAAC,GAAG,GAAG,CAAC;AAC3C,IAAI,mBAAmB,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC;AACzC,IAAI,mBAAmB,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC;AACtC,CAAC,EAAE,mBAAmB,KAAK,mBAAmB,GAAG,EAAE,CAAC,CAAC,CAAC;AACtD,SAAS,WAAW,CAAC,IAAI,EAAE;AAC3B,IAAI,MAAM,MAAM,GAAG,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC/C,IAAI,IAAI,CAAC,MAAM,EAAE;AACjB,QAAQ,OAAO;AACf,YAAY,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI;AAChC,SAAS,CAAC;AACV,KAAK;AACL,IAAI,OAAO;AACX,QAAQ,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAC/B,QAAQ,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAC7B,KAAK,CAAC;AACN,CAAC;AACD,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE;AACzC,IAAI,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;AAC3C,CAAC;AACD,SAAS,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE;AACtC,IAAI,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,KAAK/B,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;AACzG,CAAC;AACD,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC;AACxB,IAAI,MAAM,CAAC,mBAAmB,CAAC,IAAI,EAAE,mBAAmB,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,IAAI,KAAKA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACvH,IAAI,MAAM,CAAC,mBAAmB,CAAC,IAAI,EAAE,mBAAmB,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,IAAI,KAAKA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACzH,IAAI,MAAM,CAAC,mBAAmB,CAAC,IAAI,EAAE,mBAAmB,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,IAAI,KAAKA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;AAC3H,IAAI,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,mBAAmB,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,IAAI,KAAKA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,IAAIA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAC9J,IAAI,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,mBAAmB,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,IAAI,KAAKA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,IAAIA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,IAAIA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;AAC3M,IAAI,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,mBAAmB,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,IAAI,KAAKA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,IAAIA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAChK,IAAI,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,mBAAmB,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,IAAI,KAAKA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAIA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAClK,IAAI,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,mBAAmB,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,IAAI,KAAKA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAIA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AACtK,IAAI,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,mBAAmB,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,IAAI,KAAK;AACpF,QAAQA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;AAC1D,KAAK,CAAC;AACN,IAAI,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,mBAAmB,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,IAAI,KAAK;AACxF,QAAQ,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;AAC1C,QAAQA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AAChD,QAAQA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;AACpD,KAAK,CAAC;AACN,IAAI,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,mBAAmB,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,IAAI,KAAKA,KAAO,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AAClI,IAAI,GAAG,SAAS,CAAC,mBAAmB,CAAC,KAAK,EAAE,mBAAmB,CAAC,KAAK,EAAE,mBAAmB,CAAC,QAAQ,CAAC;AACpG,IAAI,GAAG,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,mBAAmB,CAAC,QAAQ,CAAC;AACxG,IAAI,GAAG,SAAS,CAAC,mBAAmB,CAAC,QAAQ,EAAE,mBAAmB,CAAC,KAAK,EAAE,mBAAmB,CAAC,OAAO,EAAE,mBAAmB,CAAC,QAAQ,CAAC;AACpI,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,IAAI,KAAK;AAC7B,YAAY,MAAM,QAAQ,GAAG,aAAa,CAAC;AAC3C,YAAY,MAAM,SAAS,GAAG,cAAc,CAAC;AAC7C,YAAY,MAAM,UAAU,GAAG,0BAA0B,CAAC;AAC1D,YAAY,MAAM,WAAW,GAAG,YAAY,CAAC;AAC7C,YAAY,MAAM,gBAAgB,GAAG,gBAAgB,CAAC;AACtD,YAAY,IAAI,WAAW,CAAC;AAC5B,YAAY,WAAW,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC9C,YAAY,MAAM,CAAC,KAAK,GAAG,WAAW,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAC/D,YAAY,WAAW,GAAG,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC/C,YAAY,MAAM,CAAC,MAAM,GAAG,WAAW,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAChE,YAAY,WAAW,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAChD,YAAY,MAAM,CAAC,OAAO,GAAG,WAAW,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;AAC3D,YAAY,WAAW,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACjD,YAAY,MAAM,CAAC,QAAQ,GAAG,WAAW,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;AAC5D,YAAY,WAAW,GAAG,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACtD,YAAY,MAAM,CAAC,OAAO,GAAG,WAAW,IAAI,WAAW,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC;AAC7E,SAAS,CAAC;AACV,CAAC,CAAC,CAAC;AACH,MAAM,kBAAkB,GAAG,UAAU,IAAI,EAAE;AAC3C,IAAI,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AAC1C,IAAI,MAAM,MAAM,GAAG,IAAI,aAAa,EAAE,CAAC;AACvC,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;AAClD,QAAQ,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACpC,KAAK;AACL,IAAI,OAAO,MAAM,CAAC;AAClB,CAAC,CAAC;AACF,0BAA0B,GAAG,kBAAkB,CAAC;AAChD,SAAS,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE;AACpC,IAAI,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;AACnC,IAAI,QAAQ,GAAG;AACf,QAAQ,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;AAC9B,YAAY,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AACjF,QAAQ,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;AAC9B,YAAY,OAAO,IAAI,CAAC,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AACxF,QAAQ;AACR,YAAY,OAAO;AACnB,KAAK;AACL,IAAI,SAAS,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE;AAC3C,QAAQ,MAAM,GAAG,GAAG,CAAC,EAAE,KAAK,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC;AAC5C,QAAQ,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACzC,QAAQ,IAAI,OAAO,EAAE;AACrB,YAAY,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAClC,SAAS;AACT,QAAQ,IAAI,GAAG,KAAK,IAAI,EAAE;AAC1B,YAAY,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,mBAAmB,CAAC,iBAAiB,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC;AAClG,SAAS;AACT,KAAK;AACL,CAAC;AACD;;;;AClJA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,kBAAkB,GAAG,KAAK,CAAC,CAAC;AACkC;AAC9D,SAAS,UAAU,CAAC,UAAU,EAAE;AAChC,IAAI,OAAO;AACX,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,QAAQ,EAAE,CAAC,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC;AACtE,QAAQ,MAAM,CAAC,IAAI,EAAE;AACrB,YAAY,OAAO,eAAe,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;AAC5D,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,kBAAkB,GAAG,UAAU,CAAC;AAChC;;;;ACbA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,2BAA2B,GAAG,qBAAqB,GAAG,yBAAyB,GAAG,wBAAwB,GAAG,KAAK,CAAC,CAAC;AACnF;AACjC,SAAS,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE;AACtC,IAAI,OAAO,aAAa,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AAC9C,CAAC;AACD,wBAAwB,GAAG,gBAAgB,CAAC;AAC5C,SAAS,iBAAiB,CAAC,UAAU,EAAE;AACvC,IAAI,OAAO,aAAa,CAAC,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC;AAClD,CAAC;AACD,yBAAyB,GAAG,iBAAiB,CAAC;AAC9C,SAAS,aAAa,CAAC,UAAU,EAAE;AACnC,IAAI,MAAM,QAAQ,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC;AACrC,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,WAAW,EAAE;AACrC,QAAQ,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;AACtC,KAAK;AACL,IAAI,OAAOE,IAAM,CAAC,yBAAyB,CAAC,QAAQ,CAAC,CAAC;AACtD,CAAC;AACD,qBAAqB,GAAG,aAAa,CAAC;AACtC,SAAS,mBAAmB,CAAC,UAAU,EAAE;AACzC,IAAI,OAAO,aAAa,CAAC,CAAC,QAAQ,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC;AACpD,CAAC;AACD,2BAA2B,GAAG,mBAAmB,CAAC;AAClD;;;;ACvBA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,oBAAoB,GAAG,eAAe,GAAG,KAAK,CAAC,CAAC;AAChD,MAAM,OAAO,CAAC;AACd,IAAI,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE;AAC7B,QAAQ,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;AACvB,QAAQ,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;AAC7B,KAAK;AACL,CAAC;AACD,eAAe,GAAG,OAAO,CAAC;AAC1B,MAAM,YAAY,GAAG,UAAU,IAAI,EAAE,UAAU,GAAG,KAAK,EAAE;AACzD,IAAI,MAAM,IAAI,GAAG,IAAI;AACrB,SAAS,KAAK,CAAC,IAAI,CAAC;AACpB,SAAS,GAAG,CAAC,OAAO,CAAC;AACrB,SAAS,MAAM,CAAC,OAAO,CAAC,CAAC;AACzB,IAAI,IAAI,CAAC,UAAU,EAAE;AACrB,QAAQ,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,EAAE,IAAI,EAAE;AACxC,YAAY,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAC3C,YAAY,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAC3C,YAAY,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;AAC5D,gBAAgB,OAAO,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9E,aAAa;AACb,YAAY,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;AACpF,gBAAgB,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9E,gBAAgB,IAAI,IAAI,EAAE;AAC1B,oBAAoB,OAAO,IAAI,CAAC;AAChC,iBAAiB;AACjB,aAAa;AACb,YAAY,OAAO,CAAC,CAAC;AACrB,SAAS,CAAC,CAAC;AACX,KAAK;AACL,IAAI,MAAM,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;AACnG,IAAI,OAAO,IAAI,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AACrC,CAAC,CAAC;AACF,oBAAoB,GAAG,YAAY,CAAC;AACpC,SAAS,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE;AAC5B,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAC5B,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAC5B,IAAI,IAAI,MAAM,KAAK,MAAM,EAAE;AAC3B,QAAQ,OAAO,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;AAC/B,KAAK;AACL,IAAI,OAAO,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;AACrC,CAAC;AACD,SAAS,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE;AACtB,IAAI,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;AACxC,CAAC;AACD,SAAS,OAAO,CAAC,KAAK,EAAE;AACxB,IAAI,OAAO,KAAK,CAAC,IAAI,EAAE,CAAC;AACxB,CAAC;AACD,SAAS,QAAQ,CAAC,KAAK,EAAE;AACzB,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;AACnC,QAAQ,OAAO,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;AAC7D,KAAK;AACL,IAAI,OAAO,CAAC,CAAC;AACb,CAAC;AACD;;;;ACtDA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,2BAA2B,GAAG,kBAAkB,GAAG,mBAAmB,GAAG,KAAK,CAAC,CAAC;AAC9B;AAClD;AACA;AACA;AACA,SAAS,WAAW,CAAC,UAAU,GAAG,EAAE,EAAE;AACtC,IAAI,MAAM,aAAa,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;AAC/E,IAAI,OAAO;AACX,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC;AAC9C,QAAQ,MAAM,CAAC,IAAI,EAAE;AACrB,YAAY,OAAO,SAAS,CAAC,YAAY,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;AAC/D,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,mBAAmB,GAAG,WAAW,CAAC;AAClC;AACA;AACA;AACA,SAAS,UAAU,CAAC,IAAI,EAAE;AAC1B,IAAI,OAAO;AACX,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC;AAC/B,QAAQ,MAAM,GAAG;AACjB,YAAY,OAAO,EAAE,IAAI,EAAE,CAAC;AAC5B,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,kBAAkB,GAAG,UAAU,CAAC;AAChC;AACA;AACA;AACA,SAAS,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE;AAC/C,IAAI,OAAO;AACX,QAAQ,MAAM,EAAE,OAAO;AACvB,QAAQ,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC;AACvD,QAAQ,MAAM,GAAG;AACjB,YAAY,OAAO,EAAE,IAAI,EAAE,CAAC;AAC5B,SAAS;AACT,KAAK,CAAC;AACN,CAAC;AACD,2BAA2B,GAAG,mBAAmB,CAAC;AAClD;;;AC5CA,MAAM,CAAC,WAAW,CAAC,GAAGlB,WAAqC,CAAC;AAC5D,MAAM,CAAC,YAAY,CAAC,GAAGI,YAA+B,CAAC;AACvD;AACA,MAAM,CAAC,SAAS,CAAC,GAAGM,SAAkC,CAAC;AACvD,MAAM,CAAC,SAAS,CAAC,GAAGC,SAA2B,CAAC;AAChD,MAAM,CAAC,aAAa,EAAE,sBAAsB,CAAC,GAAGC,IAA2B,CAAC;AAC5E,MAAM;AACN,GAAG,IAAI;AACP,GAAG,OAAO;AACV,GAAG,WAAW;AACd,GAAG,gBAAgB;AACnB,GAAG,YAAY;AACf,GAAG,yBAAyB;AAC5B,GAAG,UAAU;AACb,GAAG,YAAY;AACf,GAAG,kBAAkB;AACrB,GAAG,wBAAwB;AAC3B,GAAG,uBAAuB;AAC1B,CAAC,GAAGC,KAAsB,CAAC;AAC3B,MAAM,CAAC,cAAc,CAAC,GAAGC,WAAkC;AAC3D,MAAM,CAAC,UAAU,EAAE,eAAe,EAAE,kBAAkB,EAAE,gBAAgB,CAAC,GAAGC,MAA6B,CAAC;AAC1G,MAAM,CAAC,eAAe,CAAC,GAAGuC,WAAmC,CAAC;AAC9D,MAAM,CAAC,eAAe,CAAC,GAAGC,WAAoC,CAAC;AAC/D,MAAM,CAAC,SAAS,EAAE,eAAe,CAAC,GAAGC,KAA4B,CAAC;AAClE,MAAM,CAAC,aAAa,EAAE,cAAc,CAAC,GAAGC,MAA6B,CAAC;AACtE,MAAM,CAAC,oBAAoB,EAAE,mBAAmB,CAAC,GAAGC,KAA4B,CAAC;AACjF,MAAM,CAAC,UAAU,CAAC,GAAGC,MAA6B,CAAC;AACnD,MAAM,CAAC,eAAe,CAAC,GAAGC,IAA2B,CAAC;AACtD,MAAM,CAAC,SAAS,CAAC,GAAGC,KAA4B,CAAC;AACjD,MAAM,CAAC,cAAc,CAAC,GAAGC,UAAkC,CAAC;AAC5D,MAAM,CAAC,QAAQ,CAAC,GAAGC,IAA2B,CAAC;AAC/C,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC,GAAGC,GAA0B,CAAC;AAC9D,MAAM,CAAC,SAAS,CAAC,GAAGC,KAA4B,CAAC;AACjD,MAAM,CAAC,QAAQ,CAAC,GAAGC,IAA2B,CAAC;AAC/C,MAAM,CAAC,QAAQ,CAAC,GAAGC,IAA2B,CAAC;AAC/C,MAAM,CAAC,YAAY,CAAC,GAAGC,IAA2B,CAAC;AACnD,MAAM,CAAC,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,UAAU,EAAE,gBAAgB,CAAC,GAAGC,MAA6B,CAAC;AACrH,MAAM,CAAC,YAAY,EAAE,SAAS,CAAC,GAAGC,KAA4B,CAAC;AAC/D,MAAM,CAAC,aAAa,CAAC,GAAGC,SAAiC,CAAC;AAC1D,MAAM,CAAC,UAAU,CAAC,GAAGC,MAA6B,CAAC;AACnD,MAAM,CAAC,gBAAgB,EAAE,iBAAiB,EAAE,aAAa,EAAE,mBAAmB,CAAC,GAAGC,SAAiC,CAAC;AACpH,MAAM,CAAC,mBAAmB,EAAE,UAAU,EAAE,WAAW,CAAC,GAAGC,GAA0B,CAAC;AAClF,MAAM,CAAC,yBAAyB,EAAE,yBAAyB,CAAC,GAAG9D,IAA2B,CAAC;AAC3F;AACA,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE;AAChC,GAAG,IAAI,CAAC,SAAS,GAAG,IAAI,WAAW;AACnC,MAAM,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO;AACrC,MAAM,IAAI,SAAS,CAAC,OAAO,CAAC,sBAAsB,CAAC,EAAE,OAAO;AAC5D,IAAI,CAAC;AACL,GAAG,IAAI,CAAC,OAAO,GAAG,IAAI,SAAS,EAAE,CAAC;AAClC,CAAC;AACD;AACA,CAAC,GAAG,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,EAAE,WAAW,GAAG,GAAG,CAAC;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,YAAY,GAAG,UAAU,OAAO,EAAE;AAChD,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC;AACnC,GAAG,OAAO,IAAI,CAAC;AACf,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,GAAG,GAAG,UAAU,IAAI,EAAE,KAAK,EAAE;AAC3C,GAAG,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;AAC3D,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,GAAG,IAAI,CAAC;AAChC,IAAI,MAAM;AACV,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,EAAE,IAAI,CAAC,GAAG,KAAK,CAAC;AACpE,IAAI;AACJ;AACA,GAAG,OAAO,IAAI,CAAC;AACf,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,GAAG,GAAG,UAAU,gBAAgB,EAAE;AAChD,GAAG,MAAM,IAAI,GAAG,CAAC,OAAO,gBAAgB,KAAK,QAAQ;AACrD,QAAQ,sBAAsB,CAAC,wDAAwD,CAAC;AACxF,QAAQ,aAAa,CAAC,MAAM;AAC5B,SAAS,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,EAAE;AAC9C,YAAY,MAAM,IAAI,KAAK,CAAC,CAAC,yCAAyC,GAAG,gBAAgB,EAAE,CAAC,CAAC,CAAC,CAAC;AAC/F,UAAU;AACV;AACA,SAAS,QAAQ,IAAI,CAAC,SAAS,CAAC,GAAG,GAAG,gBAAgB,EAAE;AACxD,OAAO,CAAC,CAAC;AACT;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,CAAC;AAC3E,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,aAAa,GAAG,UAAU,aAAa,EAAE;AACvD,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,GAAG,aAAa,CAAC;AAChD,GAAG,OAAO,IAAI,CAAC;AACf,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,IAAI,GAAG,UAAU,IAAI,EAAE,IAAI,EAAE;AAC3C,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,QAAQ,CAAC,IAAI,KAAK,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;AAChF,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,MAAM,GAAG,YAAY;AACnC,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,UAAU,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;AAC/C,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,SAAS,GAAG,UAAU,OAAO,EAAE;AAC7C,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,aAAa;AACnB,SAAS,uBAAuB,CAAC,SAAS,CAAC,IAAI,EAAE;AACjD,SAAS,WAAW,CAAC,OAAO,CAAC,IAAI,OAAO,IAAI,EAAE;AAC9C,OAAO;AACP,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,KAAK,GAAG,UAAU,OAAO,EAAE,IAAI,EAAE;AAC/C,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,yBAAyB,CAAC,CAAC,OAAO,EAAE,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;AAC5E,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA,SAAS,eAAe,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE;AAC1D,GAAG,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE;AACrC,MAAM,OAAO,sBAAsB,CAAC,CAAC,IAAI,GAAG,GAAG,EAAE,+BAA+B,CAAC,CAAC,CAAC;AACnF,IAAI;AACJ;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,SAAS,EAAE,YAAY,CAAC,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;AAC7F,CAAC;AACD;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,KAAK,GAAG,YAAY;AAClC,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,eAAe,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,SAAS,CAAC;AACvD,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,MAAM,GAAG,YAAY;AACnC,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,eAAe,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,SAAS,CAAC;AAC9D,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,EAAE,GAAG,UAAU,IAAI,EAAE,EAAE,EAAE;AACvC,GAAG,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC;AACjF,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,iBAAiB,GAAG,UAAU,IAAI,EAAE;AAClD,GAAG,IAAI,GAAG,GAAG,IAAI,CAAC;AAClB,GAAG,OAAO,IAAI,CAAC,IAAI,CAAC,YAAY;AAChC,MAAM,GAAG,CAAC,IAAI,CAAC,UAAU,GAAG,EAAE,IAAI,EAAE;AACpC,SAAS,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AACzC,OAAO,CAAC,CAAC;AACT,IAAI,CAAC,CAAC;AACN,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,MAAM,GAAG,UAAU,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE;AAChE,GAAG,MAAM,IAAI,GAAG,wBAAwB,CAAC,SAAS,CAAC,CAAC;AACpD,GAAG,MAAM,QAAQ,GAAG,EAAE,CAAC;AACvB;AACA,GAAG,IAAI,yBAAyB,CAAC,OAAO,CAAC,EAAE;AAC3C,MAAM,QAAQ,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;AACzC,IAAI,MAAM;AACV,MAAM,OAAO,CAAC,IAAI,CAAC,gJAAgJ,CAAC,CAAC;AACrK,IAAI;AACJ;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,UAAU;AAChB,SAAS,QAAQ;AACjB,SAAS,OAAO,CAAC,UAAU,CAAC,KAAK,EAAE,yBAAyB,EAAE,EAAE,CAAC,CAAC;AAClE,SAAS,CAAC,GAAG,UAAU,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,CAAC,EAAE,GAAG,kBAAkB,CAAC,SAAS,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;AAC7F,OAAO;AACP,MAAM,IAAI;AACV,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,IAAI,GAAG,UAAU,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE;AAC9D,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,UAAU,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;AACjH,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,KAAK,GAAG,UAAU,MAAM,EAAE,MAAM,EAAE;AAChD,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,SAAS,CAAC,UAAU,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,UAAU,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;AAClH,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,MAAM,GAAG,UAAU,OAAO,EAAE;AAC1C,GAAG,OAAO,CAAC,IAAI,CAAC,sKAAsK,CAAC,CAAC;AACxL,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;AAClC,GAAG,OAAO,IAAI,CAAC;AACf,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,IAAI,GAAG,UAAU,OAAO,EAAE,IAAI,EAAE;AAC9C,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,WAAW,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;AAChD,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,MAAM,GAAG,YAAY;AACnC,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,yBAAyB,CAAC,CAAC,QAAQ,EAAE,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;AAC7E,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,KAAK,GAAG,UAAU,IAAI,EAAE;AACtC,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;AAClE,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,MAAM,GAAG,UAAU,MAAM,EAAE;AACzC,GAAG,MAAM,IAAI,GAAG,wBAAwB,CAAC,SAAS,CAAC,CAAC;AACpD;AACA,GAAG,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;AACnC,MAAM,OAAO,IAAI,CAAC,QAAQ;AAC1B,SAAS,sBAAsB,CAAC,yBAAyB,CAAC;AAC1D,SAAS,IAAI;AACb,OAAO,CAAC;AACR,IAAI;AACJ;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,yBAAyB,CAAC,CAAC,QAAQ,EAAE,GAAG,kBAAkB,CAAC,SAAS,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,CAAC;AAC9F,MAAM,IAAI;AACV,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,MAAM,GAAG,UAAU,IAAI,EAAE;AACvC,GAAG,MAAM,IAAI,GAAG,CAAC,OAAO,IAAI,KAAK,QAAQ;AACzC,QAAQ,UAAU,CAAC,IAAI,CAAC;AACxB,QAAQ,sBAAsB,CAAC,gCAAgC,CAAC,CAAC;AACjE;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC;AACnE,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,eAAe,GAAG,UAAU,OAAO,EAAE,UAAU,EAAE;AAC/D,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,mBAAmB,CAAC,OAAO,EAAE,UAAU,CAAC;AAC9C,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,QAAQ,GAAG,YAAY;AACrC,GAAG,MAAM,QAAQ,GAAG,CAAC,UAAU,EAAE,GAAG,kBAAkB,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC;AACzE,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,yBAAyB,CAAC,QAAQ,CAAC;AACzC,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,cAAc,GAAG,UAAU,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE;AACvE,GAAG,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,CAAC,EAAE,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC;AAC7F,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,mBAAmB,GAAG,UAAU,UAAU,EAAE,IAAI,EAAE;AAChE,GAAG,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,EAAE,UAAU,CAAC,EAAE,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC;AACjF,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,iBAAiB,GAAG,UAAU,UAAU,EAAE,WAAW,EAAE,IAAI,EAAE;AAC3E,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,gBAAgB,CAAC,UAAU,EAAE,OAAO,WAAW,KAAK,SAAS,GAAG,WAAW,GAAG,KAAK,CAAC;AAC1F,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,mBAAmB,GAAG,UAAU,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE;AAC9E,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,kBAAkB,CAAC,WAAW,EAAE,OAAO,WAAW,KAAK,SAAS,GAAG,WAAW,GAAG,KAAK,CAAC;AAC7F,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,MAAM,GAAG,UAAU,OAAO,EAAE,IAAI,EAAE;AAChD,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,UAAU,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;AAC/C,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,WAAW,GAAG,UAAU,IAAI,EAAE;AAC5C,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,eAAe,EAAE;AACvB,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,SAAS,GAAG,UAAU,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE;AAC9D,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,aAAa,CAAC,GAAG,EAAE,KAAK,EAAE,OAAO,MAAM,KAAK,SAAS,GAAG,MAAM,GAAG,KAAK,CAAC;AAC7E,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA,GAAG,CAAC,SAAS,CAAC,UAAU,GAAG,YAAY;AACvC,GAAG,OAAO,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,EAAE,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC;AAC/E,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,GAAG,GAAG,UAAU,QAAQ,EAAE;AACxC,GAAG,MAAM,kBAAkB,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACvD,GAAG,MAAM,OAAO,GAAG,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,kBAAkB,GAAG,SAAS,GAAG,QAAQ,EAAE,CAAC,CAAC,CAAC;AAC/E;AACA,GAAG,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,IAAI,kBAAkB,EAAE,CAAC,EAAE,EAAE;AAClE,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE;AACzC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AAC/C,SAAS,MAAM;AACf,OAAO;AACP,IAAI;AACJ;AACA,GAAG,OAAO,CAAC,IAAI;AACf,MAAM,GAAG,kBAAkB,CAAC,SAAS,EAAE,CAAC,EAAE,IAAI,CAAC;AAC/C,IAAI,CAAC;AACL;AACA,GAAG,IAAI,IAAI,GAAG,wBAAwB,CAAC,SAAS,CAAC,CAAC;AAClD;AACA,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;AACxB,MAAM,OAAO,IAAI,CAAC,QAAQ;AAC1B,SAAS,sBAAsB,CAAC,iDAAiD,CAAC;AAClF,SAAS,IAAI;AACb,OAAO,CAAC;AACR,IAAI;AACJ;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ,CAAC,yBAAyB,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC;AAClE,CAAC,CAAC;AACF;AACA,GAAG,CAAC,SAAS,CAAC,YAAY,GAAG,UAAU,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE;AACzD,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC;AAClC,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA,GAAG,CAAC,SAAS,CAAC,eAAe,GAAG,UAAU,IAAI,EAAE,IAAI,EAAE;AACtD,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,mBAAmB,CAAC,kBAAkB,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AAC9D,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA,GAAG,CAAC,SAAS,CAAC,aAAa,GAAG,UAAU,IAAI,EAAE,IAAI,EAAE;AACpD,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,iBAAiB,CAAC,kBAAkB,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AAC5D,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA,GAAG,CAAC,SAAS,CAAC,SAAS,GAAG,UAAU,OAAO,EAAE,IAAI,EAAE;AACnD,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,aAAa,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;AAClD,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA,GAAG,CAAC,SAAS,CAAC,UAAU,GAAG,YAAY;AACvC,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,eAAe,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;AACpD,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,SAAS,GAAG,UAAU,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE;AAClE,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,aAAa,CAAC,UAAU,EAAE,UAAU,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;AAC1E,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,YAAY,GAAG,UAAU,UAAU,EAAE,IAAI,EAAE;AACzD,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,gBAAgB,CAAC,UAAU,CAAC;AAClC,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,UAAU,GAAG,UAAU,OAAO,EAAE,IAAI,EAAE;AACpD,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,cAAc,CAAC,OAAO,KAAK,IAAI,CAAC;AACtC,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,UAAU,GAAG,UAAU,IAAI,EAAE,KAAK,EAAE;AAClD,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,cAAc,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,CAAC;AAC1C,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,MAAM,GAAG,UAAU,OAAO,EAAE,IAAI,EAAE;AAChD,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,UAAU,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;AAC/C,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,WAAW,GAAG,UAAU,IAAI,EAAE,EAAE,EAAE;AAChD,GAAG,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC,IAAI,YAAY,CAAC,EAAE,CAAC,CAAC,EAAE;AAClD,MAAM,OAAO,IAAI,CAAC,QAAQ,CAAC,sBAAsB;AACjD,SAAS,CAAC,mFAAmF,CAAC;AAC9F,OAAO,CAAC,CAAC;AACT,IAAI;AACJ;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;AAC7D,MAAM,wBAAwB,CAAC,SAAS,EAAE,KAAK,CAAC;AAChD,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,KAAK,GAAG,YAAY;AAClC,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,SAAS,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;AAC9C,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,GAAG,GAAG,UAAU,OAAO,EAAE,IAAI,EAAE;AAC7C,GAAG,MAAM,OAAO,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC;AACjD;AACA,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,KAAK,EAAE;AAC7B,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC7B,IAAI;AACJ;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,yBAAyB,CAAC,OAAO,CAAC;AACxC,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,gBAAgB,GAAG,UAAU,IAAI,EAAE;AACjD,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,yBAAyB,CAAC,CAAC,oBAAoB,CAAC,CAAC;AACvD,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,QAAQ,GAAG,UAAU,MAAM,EAAE,IAAI,EAAE;AACjD,GAAG,MAAM,IAAI,GAAG,YAAY,CAAC,CAAC,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;AACxG;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC;AACnE,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,EAAE,GAAG,UAAU,KAAK,EAAE;AACpC,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,yBAAyB,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;AAChE,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,WAAW,GAAG,UAAU,KAAK,EAAE;AAC7C,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,yBAAyB,CAAC,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;AACtE,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,OAAO,GAAG,UAAU,OAAO,EAAE,IAAI,EAAE;AACjD,GAAG,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;AAC5C,CAAC,CAAC;AACF;AACA,GAAG,CAAC,SAAS,CAAC,aAAa,GAAG,YAAY;AAC1C,GAAG,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AAC7C,CAAC,CAAC;AACF;AACA,GAAG,CAAC,SAAS,CAAC,QAAQ,GAAG,UAAU,MAAM,EAAE,IAAI,EAAE;AACjD,GAAG,IAAI,OAAO,GAAG,wBAAwB,CAAC,IAAI,CAAC,CAAC;AAChD,GAAG,IAAI,OAAO,GAAG,CAAC,UAAU,CAAC,CAAC;AAC9B,GAAG,IAAI,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;AACzB;AACA,GAAG,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;AACpC,MAAM,OAAO,IAAI,CAAC,QAAQ;AAC1B,SAAS,sBAAsB,CAAC,8DAA8D,CAAC;AAC/F,SAAS,OAAO;AAChB,OAAO,CAAC;AACR,IAAI;AACJ;AACA,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;AAC/B,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AAC3C,IAAI;AACJ;AACA,GAAG,MAAM,IAAI,GAAG,MAAM,KAAK,QAAQ;AACnC,QAAQ,yBAAyB,CAAC,OAAO,CAAC;AAC1C,QAAQ,yBAAyB,CAAC,OAAO,CAAC,CAAC;AAC3C;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACvC,CAAC,CAAC;AACF;AACA,GAAG,CAAC,SAAS,CAAC,IAAI,GAAG,UAAU,OAAO,EAAE,IAAI,EAAE;AAC9C,GAAG,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;AAC9D;AACA,GAAG,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;AACpC,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;AACpC,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,iGAAiG,CAAC,CAAC;AAC3H,IAAI;AACJ;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,yBAAyB,CAAC,OAAO,CAAC;AACxC,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA,GAAG,CAAC,SAAS,CAAC,WAAW,GAAG,YAAY;AACxC,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,eAAe,CAAC,kBAAkB,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;AACvD,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA,GAAG,CAAC,SAAS,CAAC,UAAU,GAAG,UAAU,OAAO,EAAE;AAC9C,GAAG,MAAM,IAAI,GAAG,CAAC,yBAAyB,CAAC,OAAO,CAAC;AACnD,QAAQ,sBAAsB,CAAC,CAAC,wEAAwE,CAAC,CAAC;AAC1G,QAAQ,cAAc,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,kBAAkB,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1F;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,IAAI;AACV,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,EAAC;AACD;AACA,GAAG,CAAC,SAAS,CAAC,QAAQ,GAAG,YAAY;AACrC,GAAG,MAAM,QAAQ,GAAG,CAAC,WAAW,EAAE,GAAG,kBAAkB,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC;AAC1E,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,yBAAyB,CAAC,QAAQ,EAAE,IAAI,CAAC;AAC/C,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,IAAI,GAAG,UAAU,OAAO,EAAE,IAAI,EAAE;AAC9C,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,yBAAyB,CAAC,CAAC,MAAM,EAAE,GAAG,kBAAkB,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;AAC9E,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,KAAK,GAAG,UAAU,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE;AACrD,GAAG,MAAM,sBAAsB,GAAG,mBAAmB,CAAC,IAAI,CAAC,CAAC;AAC5D,GAAG,MAAM,SAAS,GAAG,sBAAsB,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,UAAU,CAAC,IAAI,EAAE,YAAY,CAAC,IAAI,EAAE,CAAC;AACrG,GAAG,MAAM,UAAU,GAAG,kBAAkB,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,EAAE,sBAAsB,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AACnG;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,oBAAoB,CAAC,SAAS,EAAE,UAAU,CAAC;AACjD,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,IAAI,GAAG,UAAU,IAAI,EAAE;AACrC,GAAG,MAAM,IAAI,GAAG;AAChB,MAAM,QAAQ,EAAE,EAAE;AAClB,MAAM,MAAM,EAAE,OAAO;AACrB,MAAM,MAAM,CAAC,GAAG;AAChB,SAAS,IAAI,OAAO,IAAI,KAAK,UAAU,EAAE;AACzC,YAAY,IAAI,EAAE,CAAC;AACnB,UAAU;AACV,OAAO;AACP,IAAI,CAAC;AACL;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AAC9B,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,GAAG,GAAG,UAAU,OAAO,EAAE;AACvC,GAAG,MAAM,IAAI,GAAG,wBAAwB,CAAC,SAAS,CAAC,CAAC;AACpD;AACA,GAAG,IAAI,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE;AACjE,MAAM,OAAO,IAAI,CAAC,QAAQ;AAC1B,SAAS,sBAAsB,CAAC,CAAC,qFAAqF,CAAC,CAAC;AACxH,SAAS,IAAI;AACb,OAAO,CAAC;AACR,IAAI;AACJ;AACA,GAAG,MAAM,aAAa,GAAG,eAAe;AACxC,MAAM,uBAAuB,CAAC,SAAS,CAAC,IAAI,EAAE;AAC9C,MAAM,WAAW,CAAC,OAAO,CAAC,IAAI,OAAO,IAAI,EAAE;AAC3C,IAAI,CAAC;AACL;AACA,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,OAAO,CAAC,aAAa,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC;AACnF,MAAM,IAAI;AACV,IAAI;AACJ,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,UAAU,GAAG,YAAY;AACvC;AACA;AACA,GAAG,OAAO,IAAI,CAAC;AACf,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,CAAC,SAAS,CAAC,WAAW,GAAG,UAAU,SAAS,EAAE,IAAI,EAAE;AACvD,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,eAAe,CAAC,OAAO,EAAE,UAAU,CAAC,SAAS,EAAE,yBAAyB,EAAE,EAAE,CAAC,EAAE,CAAC;AACtF,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA,GAAG,CAAC,SAAS,CAAC,WAAW,GAAG,UAAU,SAAS,EAAE,IAAI,EAAE;AACvD,GAAG,OAAO,IAAI,CAAC,QAAQ;AACvB,MAAM,eAAe,CAAC,UAAU,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;AAC1D,MAAM,wBAAwB,CAAC,SAAS,CAAC;AACzC,IAAI,CAAC;AACL,CAAC,CAAC;AACF;AACA,OAAc,GAAG,GAAG;;;ACx3BpB,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,0BAA0B,GAAG,wBAAwB,GAAG,uBAAuB,GAAG,KAAK,CAAC,CAAC;AAC1D;AACQ;AACJ;AACL;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,eAAe,CAAC,aAAa,EAAE;AACxC,IAAI,OAAO,MAAM,CAAC,gBAAgB,CAAC,aAAa,EAAE;AAClD,QAAQ,UAAU,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;AACnC,QAAQ,OAAO,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE;AACzC,KAAK,CAAC,CAAC;AACP,CAAC;AACD,uBAAuB,GAAG,eAAe,CAAC;AAC1C,SAAS,gBAAgB,CAAC,OAAO,EAAE,KAAK,EAAE;AAC1C,IAAI,OAAO,MAAM,CAAC,MAAM,CAAC,UAAU,GAAG,IAAI,EAAE;AAC5C,QAAQ,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AACzC,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;AACnC,CAAC;AACD,wBAAwB,GAAG,gBAAgB,CAAC;AAC5C,SAAS,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE;AAC9C,IAAI,MAAM+D,SAAO,GAAG,IAAIC,OAAS,CAAC,WAAW,EAAE,CAAC;AAChD,IAAI,MAAM,MAAM,GAAG5D,KAAO,CAAC,oBAAoB,CAAC,OAAO,KAAK,OAAO,OAAO,KAAK,QAAQ,GAAG,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,EAAE,OAAO,CAAC,CAAC;AACjI,IAAI,IAAI,CAACA,KAAO,CAAC,YAAY,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;AAC/C,QAAQ,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC,wDAAwD,CAAC,CAAC,CAAC;AACtH,KAAK;AACL,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;AACtC,QAAQ2D,SAAO,CAAC,GAAG,CAACC,OAAS,CAAC,4BAA4B,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;AAC3E,KAAK;AACL,IAAI,MAAM,CAAC,QAAQ,IAAID,SAAO,CAAC,GAAG,CAACC,OAAS,CAAC,qBAAqB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;AACrF,IAAI,MAAM,CAAC,OAAO,IAAID,SAAO,CAAC,GAAG,CAACC,OAAS,CAAC,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;AAC3E,IAAID,SAAO,CAAC,GAAG,CAACC,OAAS,CAAC,oBAAoB,CAACA,OAAS,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACvF,IAAI,MAAM,CAAC,MAAM,IAAID,SAAO,CAAC,GAAG,CAACC,OAAS,CAAC,oBAAoB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;AAChF,IAAI,OAAO,IAAIC,GAAG,CAAC,MAAM,EAAEF,SAAO,CAAC,CAAC;AACpC,CAAC;AACD,0BAA0B,GAAG,kBAAkB,CAAC;AAChD;;;;ACzCA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,YAAY,GAAG,KAAK,CAAC,CAAC;AAC+C;AACrB;AAChD,MAAM,uBAAuB,GAAG;AAChC,IAAI,cAAc,EAAE,KAAK,EAAE,eAAe,EAAE,QAAQ;AACpD,CAAC,CAAC;AACF,MAAM,uBAAuB,GAAG;AAChC,IAAI,KAAK;AACT,IAAI,iBAAiB;AACrB,IAAI,WAAW;AACf,IAAI,WAAW;AACf,IAAI,QAAQ;AACZ,IAAI,YAAY;AAChB,IAAI,eAAe;AACnB,IAAI,QAAQ;AACZ,IAAI,aAAa;AACjB,IAAI,SAAS;AACb,IAAI,aAAa;AACjB,IAAI,aAAa;AACjB,IAAI,UAAU;AACd,IAAI,gBAAgB;AACpB,IAAI,mBAAmB;AACvB,IAAI,qBAAqB;AACzB,IAAI,OAAO;AACX,IAAI,OAAO;AACX,IAAI,QAAQ;AACZ,IAAI,KAAK;AACT,IAAI,mBAAmB;AACvB,IAAI,qBAAqB;AACzB,IAAI,MAAM;AACV,IAAI,aAAa;AACjB,IAAI,MAAM;AACV,IAAI,OAAO;AACX,IAAI,YAAY;AAChB,IAAI,MAAM;AACV,IAAI,YAAY;AAChB,IAAI,YAAY;AAChB,IAAI,KAAK;AACT,IAAI,OAAO;AACX,IAAI,aAAa;AACjB,IAAI,QAAQ;AACZ,IAAI,IAAI;AACR,IAAI,MAAM;AACV,IAAI,MAAM;AACV,IAAI,UAAU;AACd,IAAI,KAAK;AACT,IAAI,QAAQ;AACZ,IAAI,QAAQ;AACZ,IAAI,cAAc;AAClB,IAAI,OAAO;AACX,IAAI,QAAQ;AACZ,IAAI,UAAU;AACd,IAAI,IAAI;AACR,IAAI,aAAa;AACjB,IAAI,MAAM;AACV,IAAI,OAAO;AACX,IAAI,WAAW;AACf,IAAI,QAAQ;AACZ,IAAI,WAAW;AACf,IAAI,cAAc;AAClB,IAAI,eAAe;AACnB,IAAI,iBAAiB;AACrB,IAAI,KAAK;AACT,IAAI,MAAM;AACV,IAAI,kBAAkB;AACtB,CAAC,CAAC;AACF,SAAS,IAAI,CAAC,GAAG,IAAI,EAAE;AACvB,IAAI,IAAI,GAAG,CAAC;AACZ,IAAI,IAAI,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;AAClC,IAAI,IAAI;AACR,QAAQ,GAAG,GAAGG,UAAa,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC,CAAC;AACxD,KAAK;AACL,IAAI,OAAO,CAAC,EAAE;AACd,QAAQ,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAClC,KAAK;AACL,IAAI,SAAS,aAAa,GAAG;AAC7B,QAAQ,OAAO,UAAU,CAAC;AAC1B,KAAK;AACL,IAAI,SAAS,WAAW,GAAG;AAC3B,QAAQ,OAAO,KAAK,CAAC;AACrB,KAAK;AACL,IAAI,MAAM,UAAU,GAAG,CAAC,GAAG,uBAAuB,EAAE,GAAG,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,KAAK;AACtG,QAAQ,MAAM,OAAO,GAAG,uBAAuB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AAC/D,QAAQ,MAAM,KAAK,GAAG,OAAO,GAAG,YAAY,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,WAAW,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AACtF,QAAQ,MAAM,WAAW,GAAG,OAAO,GAAG,WAAW,GAAG,aAAa,CAAC;AAClE,QAAQ,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,IAAI,EAAE;AACzC,YAAY,UAAU,EAAE,KAAK;AAC7B,YAAY,YAAY,EAAE,KAAK;AAC/B,YAAY,KAAK,EAAE,GAAG,GAAG,KAAK,GAAG,WAAW;AAC5C,SAAS,CAAC,CAAC;AACX,QAAQ,OAAO,GAAG,CAAC;AACnB,KAAK,EAAE,EAAE,CAAC,CAAC;AACX,IAAI,OAAO,UAAU,CAAC;AACtB,IAAI,SAAS,YAAY,CAAC,EAAE,EAAE,GAAG,EAAE;AACnC,QAAQ,OAAO,UAAU,GAAG,IAAI,EAAE;AAClC,YAAY,IAAI,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,UAAU,EAAE;AACzD,gBAAgB,MAAM,IAAI,SAAS,CAAC,oEAAoE;AACxG,oBAAoB,2CAA2C,GAAG,EAAE,CAAC,CAAC;AACtE,aAAa;AACb,YAAY,OAAO,KAAK,CAAC,IAAI,CAAC,YAAY;AAC1C,gBAAgB,OAAO,IAAI,OAAO,CAAC,UAAU,OAAO,EAAE,MAAM,EAAE;AAC9D,oBAAoB,MAAM,QAAQ,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK;AACtD,wBAAwB,IAAI,GAAG,EAAE;AACjC,4BAA4B,OAAO,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;AACxD,yBAAyB;AACzB,wBAAwB,OAAO,CAAC,MAAM,CAAC,CAAC;AACxC,qBAAqB,CAAC;AACtB,oBAAoB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AACxC,oBAAoB,GAAG,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AAC7C,iBAAiB,CAAC,CAAC;AACnB,aAAa,CAAC,CAAC;AACf,SAAS,CAAC;AACV,KAAK;AACL,IAAI,SAAS,WAAW,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE;AACvC,QAAQ,OAAO,CAAC,GAAG,IAAI,KAAK;AAC5B,YAAY,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;AAC7B,YAAY,OAAO,GAAG,CAAC;AACvB,SAAS,CAAC;AACV,KAAK;AACL,CAAC;AACD,YAAY,GAAG,IAAI,CAAC;AACpB,SAAS,OAAO,CAAC,KAAK,EAAE;AACxB,IAAI,IAAI,KAAK,YAAY,KAAK,EAAE;AAChC,QAAQ,OAAO,KAAK,CAAC;AACrB,KAAK;AACL,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;AACnC,QAAQ,OAAO,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC;AAChC,KAAK;AACL,IAAI,OAAO,IAAItD,gBAAoB,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;AAC5D,CAAC;AACD;;;ACnIA,MAAM,CAAC,IAAI,CAAC,GAAGxB,cAAwC,CAAC;AACxD,MAAM,CAAC,eAAe,EAAE,kBAAkB,EAAE,gBAAgB,CAAC,GAAGI,UAA4B,CAAC;AAC7F;AACA,OAAc,GAAG,eAAe;AAChC,GAAG,gBAAgB,CAAC,kBAAkB,EAAE,CAAC,IAAI,CAAC,CAAC;AAC/C,CAAC;;ACFD,IAAK,WAQJ;AARD,WAAK,WAAW;IACZ,6CAAI,CAAA;IACJ,iDAAM,CAAA;IACN,6CAAI,CAAA;IACJ,2CAAG,CAAA;IACH,iDAAM,CAAA;IACN,6CAAI,CAAA;IACJ,yDAAU,CAAA;AACd,CAAC,EARI,WAAW,KAAX,WAAW,QAQf;AAeD,IAAM,gBAAgB,GAAwB;IAC1C,aAAa,EAAE,wBAAwB;IACvC,gBAAgB,EAAE,qBAAqB;IACvC,gBAAgB,EAAE,CAAC;IACnB,gBAAgB,EAAE,CAAC;IACnB,cAAc,EAAE,KAAK;IACrB,WAAW,EAAE,KAAK;IAClB,cAAc,EAAE,IAAI;IACpB,aAAa,EAAE,KAAK;IACpB,6BAA6B,EAAE,KAAK;IACpC,aAAa,EAAE,IAAI;IACnB,cAAc,EAAE,EAAE;IAClB,YAAY,EAAE,EAAE;CACnB,CAAC;;IAEuC,+BAAM;IAA/C;QAAA,qEAwZC;QAhZG,cAAQ,GAAG,KAAK,CAAC;QACjB,kBAAY,GAAiB,IAAI,YAAY,EAAE,CAAC;QAChD,wBAAkB,GAAG,gCAAgC,CAAC;;;KA8YzD;IA5YG,8BAAQ,GAAR,UAAS,KAAkB;;QACvB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,MAAA,IAAI,CAAC,SAAS,0CAAE,OAAO,EAAE,CAAC;KAC7B;IAEK,4BAAM,GAAZ;;;;;;;wBACI,OAAO,CAAC,GAAG,CAAC,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,GAAG,SAAS,CAAC,CAAC;wBACzD,qBAAM,IAAI,CAAC,YAAY,EAAE,EAAA;;wBAAzB,SAAyB,CAAC;wBAE1B,IAAI,CAAC,aAAa,CAAC,IAAI,sBAAsB,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;wBAE/D,IAAI,CAAC,UAAU,CAAC;4BACZ,EAAE,EAAE,MAAM;4BACV,IAAI,EAAE,6BAA6B;4BACnC,QAAQ,EAAE,cAAM,OAAA,KAAI,CAAC,YAAY,CAAC,OAAO,CAAC,cAAM,OAAA,KAAI,CAAC,qBAAqB,EAAE,GAAA,CAAC,GAAA;yBAChF,CAAC,CAAC;wBAEH,IAAI,CAAC,UAAU,CAAC;4BACZ,EAAE,EAAE,MAAM;4BACV,IAAI,EAAE,oDAAoD;4BAC1D,QAAQ,EAAE,cAAM,OAAA,KAAI,CAAC,YAAY,CAAC,OAAO,CAAC,cAAM,OAAA,KAAI,CAAC,YAAY,CAAC,KAAK,CAAC,GAAA,CAAC,GAAA;yBAC5E,CAAC,CAAC;wBAEH,IAAI,CAAC,UAAU,CAAC;4BACZ,EAAE,EAAE,+BAA+B;4BACnC,IAAI,EAAE,oDAAoD;4BAC1D,QAAQ,EAAE,cAAM,OAAA,IAAI,kBAAkB,CAAC,KAAI,CAAC,CAAC,IAAI,EAAE,GAAA;yBACtD,CAAC,CAAC;wBAEH,IAAI,CAAC,UAAU,CAAC;4BACZ,EAAE,EAAE,oBAAoB;4BACxB,IAAI,EAAE,oBAAoB;4BAC1B,QAAQ,EAAE;;;;gDACS,qBAAM,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAA;;4CAAhC,MAAM,GAAG,SAAuB;4CACtC,IAAI,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC;;;;iCACpD;yBACJ,CAAC,CAAC;wBACH,IAAI,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE;4BAEzB,WAAW,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;4BAC1C,IAAI,CAAC,SAAS,GAAG,IAAI,SAAS,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;4BAClD,IAAI,CAAC,gBAAgB,CACjB,MAAM,CAAC,WAAW,CAAC,cAAM,OAAA,KAAI,CAAC,SAAS,CAAC,OAAO,EAAE,GAAA,EAAE,IAAI,CAAC,CAC3D,CAAC;yBACL;wBAED,IAAI,CAAC,IAAI,EAAE,CAAC;;;;;KACf;IAEK,8BAAQ,GAAd;;;gBACI,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;gBAC1C,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;gBACxC,OAAO,CAAC,GAAG,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,GAAG,SAAS,CAAC,CAAC;;;;KAC9D;IACK,kCAAY,GAAlB;;;;;;wBACI,KAAA,IAAI,CAAA;wBAAY,KAAA,CAAA,KAAA,MAAM,EAAC,MAAM,CAAA;8BAAC,EAAE,EAAE,gBAAgB;wBAAE,qBAAM,IAAI,CAAC,QAAQ,EAAE,EAAA;;wBAAzE,GAAK,QAAQ,GAAG,wBAAoC,SAAqB,GAAC,CAAC;;;;;KAC9E;IACK,kCAAY,GAAlB;;;;4BACI,qBAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAA;;wBAAlC,SAAkC,CAAC;;;;;KACtC;IAEK,0BAAI,GAAV;;;;;;;wBACI,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE;4BACxB,IAAI,CAAC,YAAY,CAAC,wBAAwB,CAAC,CAAC;4BAC5C,sBAAO;yBACV;;;;wBAES,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,OAA4B,CAAC;wBACtD,IAAI,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;wBAEnC,IAAI,CAAC,GAAG,GAAG2E,GAAS,CAAC,IAAI,CAAC,CAAC;wBAEP,qBAAM,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,EAAA;;wBAA1C,WAAW,GAAG,SAA4B;wBAEhD,IAAI,CAAC,WAAW,EAAE;4BACd,IAAI,CAAC,YAAY,CAAC,iCAAiC,CAAC,CAAC;yBACxD;6BAAM;4BACH,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;4BACrB,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;4BAEhC,IAAI,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE;gCAC9B,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,cAAM,OAAA,KAAI,CAAC,qBAAqB,EAAE,GAAA,CAAC,CAAC;6BACjE;4BAED,IAAI,IAAI,CAAC,QAAQ,CAAC,gBAAgB,GAAG,CAAC,EAAE;gCAC9B,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;gCACjB,IAAI,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;gCAE9C,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,gBAAgB,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC;gCAC3G,IAAI,CAAC,eAAe,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;6BAC9C;4BACD,IAAI,IAAI,CAAC,QAAQ,CAAC,gBAAgB,GAAG,CAAC,EAAE;gCAC9B,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;gCACjB,IAAI,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;gCAE5C,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,gBAAgB,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC;gCAC3G,IAAI,CAAC,aAAa,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;6BAC5C;yBACJ;;;;wBAGD,IAAI,CAAC,YAAY,CAAC,OAAK,CAAC,CAAC;wBACzB,OAAO,CAAC,KAAK,CAAC,OAAK,CAAC,CAAC;;;;;;KAE5B;IAEK,2CAAqB,GAA3B;;;;;;6BAEQ,CAAC,IAAI,CAAC,QAAQ,EAAd,wBAAc;wBACd,qBAAM,IAAI,CAAC,IAAI,EAAE,EAAA;;wBAAjB,SAAiB,CAAC;;;wBAGtB,IAAI,CAAC,IAAI,CAAC,QAAQ;4BAAE,sBAAO;wBAEN,qBAAM,IAAI,CAAC,IAAI,EAAE,EAAA;;wBAAhC,YAAY,GAAG,SAAiB;wBACtC,IAAI,YAAY,GAAG,CAAC,EAAE;4BAClB,IAAI,CAAC,cAAc,CAAC,yBAAuB,YAAY,mBAAgB,CAAC,CAAC;yBAC5E;6BAAM;4BACH,IAAI,CAAC,cAAc,CAAC,0BAA0B,CAAC,CAAC;yBACnD;wBAEc,qBAAM,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAA;;wBAAhC,MAAM,GAAG,SAAuB;wBACtC,IAAI,MAAM,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE;4BAC9B,IAAI,CAAC,YAAY,CAAC,cAAY,MAAM,CAAC,UAAU,CAAC,MAAM,oBAAiB,CAAC,CAAC;yBAC5E;wBAED,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;wBAC7B,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;;;;;KACnC;IAEK,kCAAY,GAAlB,UAAmB,cAAuB,EAAE,aAAsB;;;;;;6BAC1D,CAAC,IAAI,CAAC,QAAQ,EAAd,wBAAc;wBACd,qBAAM,IAAI,CAAC,IAAI,EAAE,EAAA;;wBAAjB,SAAiB,CAAC;;;wBAEtB,IAAI,CAAC,IAAI,CAAC,QAAQ;4BAAE,sBAAO;wBAE3B,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;wBACrB,qBAAM,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAA;;wBAAhC,MAAM,GAAG,SAAuB;6BAGhC,CAAC,cAAc,EAAf,wBAAe;wBACT,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,qBAAqB,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;wBAC3E,qBAAM,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAA;;wBAAjC,SAAiC,CAAC;;;;wBAItC,IAAI,cAAc,IAAI,MAAM,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE;4BAChD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;4BAChC,IAAI,CAAC,YAAY,CAAC,sCAAoC,MAAM,CAAC,UAAU,CAAC,MAAM,iEAA8D,CAAC,CAAC;4BAC9I,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;4BACvC,sBAAO;yBACV;wBAEqB,qBAAM,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAA;;wBAAvC,YAAY,GAAG,CAAC,SAAuB,EAAE,KAAK;8BAEhD,YAAY,CAAC,MAAM,KAAK,CAAC,CAAA,EAAzB,yBAAyB;wBACzB,qBAAM,IAAI,CAAC,GAAG,EAAE,EAAA;;wBAAhB,SAAgB,CAAC;wBACR,qBAAM,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAA;;wBAAhC,MAAM,GAAG,SAAuB,CAAC;wBACjC,qBAAM,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,EAAA;;wBAAhC,SAAgC,CAAC;wBAEjC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;wBAC7B,IAAI,CAAC,cAAc,CAAC,eAAa,MAAM,CAAC,MAAM,CAAC,MAAM,WAAQ,CAAC,CAAC;;;wBAE/D,IAAI,CAAC,cAAc,CAAC,sBAAsB,CAAC,CAAC;;;6BAG5C,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,EAA1B,yBAA0B;wBACpB,cAAc,GAAG,MAAM,CAAC,QAAQ,CAAC;wBACjC,aAAa,GAAG,MAAM,CAAC,OAAO,CAAC;wBAErC,IAAI,CAAC,cAAc,EAAE;4BACjB,IAAI,CAAC,YAAY,CAAC,sEAAsE,EAAE,KAAK,CAAC,CAAC;4BACjG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;4BAChC,sBAAO;yBACV;wBAE2B,qBAAM,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC,EAAA;;wBAAjF,kBAAkB,GAAG,CAAC,SAA2D,EAAE,OAAO;8BAG5F,kBAAkB,GAAG,CAAC,CAAA,EAAtB,yBAAsB;6BAClB,IAAI,CAAC,QAAQ,CAAC,cAAc,EAA5B,yBAA4B;wBACF,qBAAM,IAAI,CAAC,IAAI,EAAE,EAAA;;wBAArC,iBAAiB,GAAG,SAAiB;wBAC3C,IAAI,iBAAiB,GAAG,CAAC,EAAE;4BACvB,IAAI,CAAC,cAAc,CAAC,YAAU,iBAAiB,uBAAoB,CAAC,CAAC;yBACxE;;6BAII,qBAAM,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAA;;;wBAAhC,MAAM,GAAG,SAAuB,CAAC;8BAE7B,MAAM,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAA,EAA5B,yBAA4B;wBAC5B,IAAI,CAAC,YAAY,CAAC,2BAAyB,MAAM,CAAC,UAAU,CAAC,MAAM,oBAAiB,CAAC,CAAC;wBACtF,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;wBACvC,sBAAO;6BAEqB,qBAAM,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC,EAAA;;wBAAjF,uBAAqB,CAAC,SAA2D,EAAE,OAAO;wBAEhG,qBAAM,IAAI,CAAC,IAAI,EAAE,EAAA;;wBAAjB,SAAiB,CAAC;wBAClB,IAAI,CAAC,cAAc,CAAC,YAAU,oBAAkB,qBAAkB,CAAC,CAAC;;;;wBAGxE,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,CAAC;;;wBAGlD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;;;;;KACnC;;IAKD,oCAAc,GAAd;;QAEI,IAAM,OAAO,GAAGC,yBAAS,CAAC,KAAK,EAAE,CAAC,WAAW,CAAC,EAAE;YAC5C,KAAK,EAAE,QAAQ;SAClB,CAAC,CAAC;QAEH,IAAI,OAAO,CAAC,KAAK,EAAE;YACf,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC7B,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,IAAI,CAAC;KACf;IAEK,yBAAG,GAAT;;;;;;wBACI,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;wBAC/B,qBAAM,IAAI,CAAC,GAAG,CAAC,GAAG,CACd,KAAK,EACL,UAAC,GAAiB;gCACd,OAAA,GAAG,IAAI,KAAI,CAAC,YAAY,CAAC,uBAAqB,GAAG,CAAC,OAAS,CAAC;6BAAA,CACnE,EAAA;;wBAJD,SAIC,CAAC;;;;;KACL;IAEK,4BAAM,GAAZ,UAAa,OAAgB;;;;;;wBACzB,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;8BACK,OAAO,aAAP,OAAO;wBAAP,KAAA,OAAO,CAAA;;4BAAI,qBAAM,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAA;;wBAA3D,KAAA,SAA2D,CAAA;;;wBAAzG,aAAa,KAA4F;6BACzG,IAAI,CAAC,QAAQ,CAAC,6BAA6B,EAA3C,wBAA2C;8BAC1B,aAAa,EAAE,iBAAiB;wBAAG,qBAAM,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAA;;wBAA3E,aAAa,cAAsC,CAAC,SAAuB,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAC,CAAC;;4BAEpG,qBAAM,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,EAAA;;wBAApC,SAAoC,CAAC;;;;;KACxC;IAEK,0BAAI,GAAV;;;;;;wBACI,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;wBAChC,qBAAM,IAAI,CAAC,GAAG,CAAC,GAAG,uBAAM,OAAO,CAAC,GAAG,KAAE,cAAc,EAAE,CAAC,IAAG,CAAC,IAAI,CAC1D,UAAC,GAAiB;gCACd,GAAG,IAAI,KAAI,CAAC,YAAY,CAAC,iBAAe,GAAG,CAAC,OAAS,CAAC,CAAC;6BAC1D,CACJ,EAAA;;wBAJD,SAIC,CAAC;wBAEF,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;;;;;KAChC;IAEK,0BAAI,GAAV;;;;;;;wBACI,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;wBACb,qBAAM,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,aAAa,CAAC,EAClD,UAAO,GAAiB;;;;;iDAChB,GAAG,EAAH,wBAAG;4CACH,IAAI,CAAC,YAAY,CAAC,iBAAe,GAAG,CAAC,OAAS,CAAC,CAAC;4CACjC,qBAAM,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAA;;4CAAhC,WAAS,SAAuB;4CACtC,IAAI,QAAM,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE;gDAC9B,IAAI,CAAC,cAAc,CAAC,QAAM,CAAC,UAAU,CAAC,CAAC;6CAC1C;;;;;iCAER,CACJ,EAAA;;wBAVK,UAAU,GAAG,SAUlB;wBACD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;wBAC7B,sBAAO,UAAU,CAAC,KAAK,CAAC,MAAM,EAAC;;;;KAClC;;IAID,qCAAe,GAAf,UAAgB,OAAgB;QAAhC,iBAUC;QATG,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,UAAU,CACpC;YACI,KAAI,CAAC,YAAY,CAAC,OAAO,CAAC,cAAM,OAAA,KAAI,CAAC,YAAY,CAAC,IAAI,CAAC,GAAA,CAAC,CAAC;YACzD,KAAI,CAAC,QAAQ,CAAC,cAAc,GAAG,IAAI,IAAI,EAAE,CAAC,QAAQ,EAAE,CAAC;YACrD,KAAI,CAAC,YAAY,EAAE,CAAC;YACpB,KAAI,CAAC,eAAe,EAAE,CAAC;SAC1B,EACD,CAAC,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,IAAI,CAAC,QAAQ,CAAC,gBAAgB,IAAI,KAAK,CACtD,CAAC;KACL;IAED,mCAAa,GAAb,UAAc,OAAgB;QAA9B,iBAUC;QATG,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,UAAU,CAClC;YACI,KAAI,CAAC,YAAY,CAAC,OAAO,CAAC,cAAM,OAAA,KAAI,CAAC,qBAAqB,EAAE,GAAA,CAAC,CAAC;YAC9D,KAAI,CAAC,QAAQ,CAAC,YAAY,GAAG,IAAI,IAAI,EAAE,CAAC,QAAQ,EAAE,CAAC;YACnD,KAAI,CAAC,YAAY,EAAE,CAAC;YACpB,KAAI,CAAC,aAAa,EAAE,CAAC;SACxB,EACD,CAAC,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,IAAI,CAAC,QAAQ,CAAC,gBAAgB,IAAI,KAAK,CACtD,CAAC;KACL;IAED,qCAAe,GAAf;QACI,IAAI,IAAI,CAAC,eAAe,EAAE;YACtB,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;YAC1C,OAAO,IAAI,CAAC;SACf;QACD,OAAO,KAAK,CAAC;KAChB;IAED,mCAAa,GAAb;QACI,IAAI,IAAI,CAAC,aAAa,EAAE;YACpB,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACxC,OAAO,IAAI,CAAC;SACf;QACD,OAAO,KAAK,CAAC;KAChB;IAEK,oCAAc,GAApB,UAAqB,UAAoB;;;;;gBACrC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;gBAChC,KAAK;oBACP,kBAAkB;oBAClB,2FAA2F;mBACxF,UAAU,CAAC,GAAG,CAAC,UAAA,CAAC;oBACf,IAAM,IAAI,GAAG,KAAI,CAAC,GAAG,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;oBACrD,IAAI,IAAI,YAAYC,cAAK,EAAE;wBACvB,IAAM,IAAI,GAAG,KAAI,CAAC,GAAG,CAAC,aAAa,CAAC,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;wBAC9D,OAAO,SAAO,IAAI,OAAI,CAAC;qBAC1B;yBAAM;wBACH,OAAO,mBAAiB,CAAG,CAAC;qBAC/B;iBACJ,CAAC,CACL,CAAC;gBACF,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;;;;KAC3C;IAEK,sCAAgB,GAAtB,UAAuB,IAAY;;;;;;4BAC/B,qBAAM,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,EAAA;;wBAAjE,SAAiE,CAAC;wBAE9D,mBAAmB,GAAG,KAAK,CAAC;wBAChC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,gBAAgB,CAAC,UAAA,IAAI;4BACpC,IAAI,IAAI,CAAC,cAAc,EAAE,IAAI,EAAE,IAAI,KAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,EAAE;gCAC1F,mBAAmB,GAAG,IAAI,CAAC;6BAC9B;yBACJ,CAAC,CAAC;wBACH,IAAI,CAAC,mBAAmB,EAAE;4BACtB,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,kBAAkB,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;yBACvE;;;;;KACJ;;IAGD,oCAAc,GAAd,UAAe,OAAe,EAAE,OAA0B;;QAA1B,wBAAA,EAAA,UAAkB,CAAC,GAAG,IAAI;QACtD,MAAA,IAAI,CAAC,SAAS,0CAAE,cAAc,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,OAAO,CAAC,CAAC;QAE/D,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE;YAC9B,IAAIC,eAAM,CAAC,OAAO,CAAC,CAAC;SACvB;QAED,OAAO,CAAC,GAAG,CAAC,2BAAyB,OAAS,CAAC,CAAC;KACnD;IACD,kCAAY,GAAZ,UAAa,OAAe,EAAE,OAAmB;;QAAnB,wBAAA,EAAA,WAAmB;QAC7C,IAAIA,eAAM,CAAC,OAAO,CAAC,CAAC;QACpB,OAAO,CAAC,GAAG,CAAC,yBAAuB,OAAS,CAAC,CAAC;QAC9C,MAAA,IAAI,CAAC,SAAS,0CAAE,cAAc,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,OAAO,CAAC,CAAC;KAClE;IAEK,yCAAmB,GAAzB,UAA0B,QAAgB;;;;;;6BAClC,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAjC,wBAAiC;wBACpB,qBAAM,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAA;;wBAAhC,WAAS,SAAuB;wBAChC,QAAQ,GAAG,QAAM,CAAC,KAAK,CAAC,MAAM,CAAC;wBACnC,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,cAAc,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;;;6BAG9D,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,EAA9B,wBAA8B;wBACjB,qBAAM,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAA;;wBAAhC,WAAS,SAAuB;wBAEhC,cAA0C,EAAE,CAAC;wBACjD,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,UAAC,KAAuB;4BACzC,IAAI,KAAK,CAAC,KAAK,IAAI,WAAS,EAAE;gCAC1B,WAAS,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;6BAC3C;iCAAM;gCACH,WAAS,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;6BACzC;yBACJ,CAAC,CAAC;wBAEC,MAAM,GAAG,EAAE,CAAC;wBAChB,WAAqD,EAAzB,KAAA,MAAM,CAAC,OAAO,CAAC,WAAS,CAAC,EAAzB,cAAyB,EAAzB,IAAyB,EAAE;4BAA9C,WAAe,EAAd,MAAM,QAAA,EAAE,eAAK;4BACnB,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,GAAG,GAAG,OAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;yBAC/C;wBAEG,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;wBAE9B,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;;;wBAGhD,MAAM,GAAI,MAAc,CAAC,MAAM,CAAC;wBACpC,sBAAO,QAAQ,CAAC,OAAO,CACnB,UAAU,EACV,MAAM,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAClD,EAAC;;;;KACL;IAGL,kBAAC;AAAD,CAxZA,CAAyCC,eAAM,GAwZ9C;AAGD;IAAqC,0CAAgB;IAArD;;KAqNC;IApNG,wCAAO,GAAP;QAAA,iBAmNC;QAlNS,IAAA,WAAW,GAAK,IAAI,YAAT,CAAU;QAC3B,IAAM,MAAM,GAAiB,IAAY,CAAC,MAAM,CAAC;QAEjD,WAAW,CAAC,KAAK,EAAE,CAAC;QACpB,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,qBAAqB,EAAE,CAAC,CAAC;QAE5D,IAAIC,gBAAO,CAAC,WAAW,CAAC;aACnB,OAAO,CAAC,iCAAiC,CAAC;aAC1C,OAAO,CACJ,gHAAgH,CACnH;aACA,OAAO,CAAC,UAAC,IAAI;YACV,OAAA,IAAI;iBACC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC;iBAClD,QAAQ,CAAC,UAAC,KAAK;gBACZ,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE;oBACvB,MAAM,CAAC,QAAQ,CAAC,gBAAgB,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;oBACjD,MAAM,CAAC,YAAY,EAAE,CAAC;oBAEtB,IAAI,MAAM,CAAC,QAAQ,CAAC,gBAAgB,GAAG,CAAC,EAAE;wBACtC,MAAM,CAAC,eAAe,EAAE,CAAC;wBACzB,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC;wBACzD,IAAIF,eAAM,CACN,qCAAmC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,cAAW,CACjF,CAAC;qBACL;yBAAM,IACH,MAAM,CAAC,QAAQ,CAAC,gBAAgB,IAAI,CAAC;wBACrC,MAAM,CAAC,eAAe,EACxB;wBACE,MAAM,CAAC,eAAe,EAAE;4BACpB,IAAIA,eAAM,CAAC,4BAA4B,CAAC,CAAC;qBAChD;iBACJ;qBAAM;oBACH,IAAIA,eAAM,CAAC,gCAAgC,CAAC,CAAC;iBAChD;aACJ,CAAC;SAAA,CACT,CAAC;QACN,IAAIE,gBAAO,CAAC,WAAW,CAAC;aACnB,OAAO,CAAC,8BAA8B,CAAC;aACvC,OAAO,CACJ,mGAAmG,CACtG;aACA,OAAO,CAAC,UAAC,IAAI;YACV,OAAA,IAAI;iBACC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC;iBAClD,QAAQ,CAAC,UAAC,KAAK;gBACZ,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE;oBACvB,MAAM,CAAC,QAAQ,CAAC,gBAAgB,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;oBACjD,MAAM,CAAC,YAAY,EAAE,CAAC;oBAEtB,IAAI,MAAM,CAAC,QAAQ,CAAC,gBAAgB,GAAG,CAAC,EAAE;wBACtC,MAAM,CAAC,aAAa,EAAE,CAAC;wBACvB,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC;wBACvD,IAAIF,eAAM,CACN,mCAAiC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,cAAW,CAC/E,CAAC;qBACL;yBAAM,IACH,MAAM,CAAC,QAAQ,CAAC,gBAAgB,IAAI,CAAC;wBACrC,MAAM,CAAC,aAAa,EACtB;wBACE,MAAM,CAAC,aAAa,EAAE;4BAClB,IAAIA,eAAM,CAAC,0BAA0B,CAAC,CAAC;qBAC9C;iBACJ;qBAAM;oBACH,IAAIA,eAAM,CAAC,gCAAgC,CAAC,CAAC;iBAChD;aACJ,CAAC;SAAA,CACT,CAAC;QAEN,IAAIE,gBAAO,CAAC,WAAW,CAAC;aACnB,OAAO,CAAC,gBAAgB,CAAC;aACzB,OAAO,CACJ,iEAAiE;YACjE,uEAAuE,CAC1E;aACA,OAAO,CAAC,UAAC,IAAI;YACV,OAAA,IAAI;iBACC,cAAc,CAAC,cAAc,CAAC;iBAC9B,QAAQ,CACL,MAAM,CAAC,QAAQ,CAAC,aAAa;kBACvB,MAAM,CAAC,QAAQ,CAAC,aAAa;kBAC7B,EAAE,CACX;iBACA,QAAQ,CAAC,UAAC,KAAK;gBACZ,MAAM,CAAC,QAAQ,CAAC,aAAa,GAAG,KAAK,CAAC;gBACtC,MAAM,CAAC,YAAY,EAAE,CAAC;aACzB,CAAC;SAAA,CACT,CAAC;QAEN,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACnB,OAAO,CAAC,6BAA6B,CAAC;aACtC,OAAO,CAAC,wDAAwD,CAAC;aACjE,OAAO,CAAC,UAAC,IAAI;YACV,OAAA,IAAI;iBACC,cAAc,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC;iBAChD,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC;iBAC1C,QAAQ,CAAC,UAAO,KAAK;;;;4BAClB,MAAM,CAAC,QAAQ,CAAC,gBAAgB,GAAG,KAAK,CAAC;4BACzC,qBAAM,MAAM,CAAC,YAAY,EAAE,EAAA;;4BAA3B,SAA2B,CAAC;;;;iBAC/B,CAAC;SAAA,CACT,CAAC;QAEN,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACnB,OAAO,CAAC,wBAAwB,CAAC;aACjC,SAAS,CAAC,UAAC,MAAM;YACd,OAAA,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC;;;;gCACT,qBAAM,MAAM,CAAC,mBAAmB,CACvD,MAAM,CAAC,QAAQ,CAAC,aAAa,CAChC,EAAA;;4BAFG,oBAAoB,GAAG,SAE1B;4BACD,IAAIF,eAAM,CAAC,KAAG,oBAAsB,CAAC,CAAC;;;;iBACzC,CAAC;SAAA,CACL,CAAC;QAEN,IAAIE,gBAAO,CAAC,WAAW,CAAC;aACnB,OAAO,CAAC,sDAAsD,CAAC;aAC/D,SAAS,CAAC,UAAC,MAAM;YACd,OAAA,MAAM;iBACD,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,6BAA6B,CAAC;iBACvD,QAAQ,CAAC,UAAC,KAAK;gBACZ,MAAM,CAAC,QAAQ,CAAC,6BAA6B,GAAG,KAAK,CAAC;gBACtD,MAAM,CAAC,YAAY,EAAE,CAAC;aACzB,CAAC;SAAA,CACT,CAAC;QAEN,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACnB,OAAO,CAAC,gBAAgB,CAAC;aACzB,OAAO,CAAC,8BAA8B,CAAC;aACvC,WAAW,CAAC,UAAO,QAAQ;;;;;4BACL,qBAAM,MAAM,CAAC,GAAG,CAAC,WAAW,EAAE,EAAA;;wBAA3C,UAAU,GAAG,SAA8B;wBACjD,WAAmC,EAAd,KAAA,UAAU,CAAC,GAAG,EAAd,cAAc,EAAd,IAAc,EAAE;4BAA1B,MAAM;4BACb,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;yBACtC;wBACD,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;wBACtC,QAAQ,CAAC,QAAQ,CAAC,UAAO,MAAM;;;;4CAC3B,qBAAM,MAAM,CAAC,GAAG,CAAC,QAAQ,CACrB,MAAM,EACN,EAAE,EACF,UAAO,GAAU;;gDACb,IAAI,GAAG,EAAE;oDACL,IAAIF,eAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;oDACxB,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;iDACzC;qDAAM;oDACH,IAAIA,eAAM,CAAC,oBAAkB,MAAQ,CAAC,CAAC;iDAC1C;;;6CACJ,CACJ,EAAA;;wCAXD,SAWC,CAAC;;;;6BACL,CAAC,CAAC;;;;aACN,CAAC,CAAC;QAEP,IAAIE,gBAAO,CAAC,WAAW,CAAC;aACnB,OAAO,CAAC,yBAAyB,CAAC;aAClC,OAAO,CAAC,iDAAiD,CAAC;aAC1D,SAAS,CAAC,UAAC,MAAM;YACd,OAAA,MAAM;iBACD,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC;iBACxC,QAAQ,CAAC,UAAC,KAAK;gBACZ,MAAM,CAAC,QAAQ,CAAC,cAAc,GAAG,KAAK,CAAC;gBACvC,MAAM,CAAC,YAAY,EAAE,CAAC;aACzB,CAAC;SAAA,CACT,CAAC;QAEN,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACnB,OAAO,CAAC,cAAc,CAAC;aACvB,OAAO,CAAC,8CAA8C,CAAC;aACvD,SAAS,CAAC,UAAC,MAAM;YACd,OAAA,MAAM;iBACD,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC;iBACrC,QAAQ,CAAC,UAAC,KAAK;gBACZ,MAAM,CAAC,QAAQ,CAAC,WAAW,GAAG,KAAK,CAAC;gBACpC,MAAM,CAAC,YAAY,EAAE,CAAC;aACzB,CAAC;SAAA,CACT,CAAC;QAEN,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACnB,OAAO,CAAC,0BAA0B,CAAC;aACnC,OAAO,CAAC,qDAAqD,CAAC;aAC9D,SAAS,CAAC,UAAC,MAAM;YACd,OAAA,MAAM;iBACD,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC;iBACxC,QAAQ,CAAC,UAAC,KAAK;gBACZ,MAAM,CAAC,QAAQ,CAAC,cAAc,GAAG,KAAK,CAAC;gBACvC,MAAM,CAAC,YAAY,EAAE,CAAC;aACzB,CAAC;SAAA,CACT,CAAC;QAEN,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACnB,OAAO,CAAC,uBAAuB,CAAC;aAChC,OAAO,CACJ,oGAAoG,CACvG;aACA,SAAS,CAAC,UAAC,MAAM;YACd,OAAA,MAAM;iBACD,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC;iBACvC,QAAQ,CAAC,UAAC,KAAK;gBACZ,MAAM,CAAC,QAAQ,CAAC,aAAa,GAAG,KAAK,CAAC;gBACtC,MAAM,CAAC,YAAY,EAAE,CAAC;aACzB,CAAC;SAAA,CACT,CAAC;QAEN,IAAIA,gBAAO,CAAC,WAAW,CAAC;aACnB,OAAO,CAAC,iBAAiB,CAAC;aAC1B,OAAO,CAAC,2DAA2D,CAAC;aACpE,SAAS,CAAC,UAAC,MAAM;YACd,OAAA,MAAM;iBACD,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC;iBACvC,QAAQ,CAAC,UAAC,KAAK;gBACZ,MAAM,CAAC,QAAQ,CAAC,aAAa,GAAG,KAAK,CAAC;gBACtC,MAAM,CAAC,YAAY,EAAE,CAAC;aACzB,CAAC;SAAA,CACT,CAAC;KACT;IACL,6BAAC;AAAD,CArNA,CAAqCC,yBAAgB,GAqNpD;AAOD;IAQI,mBAAY,WAAwB,EAAE,MAAmB;QAPlD,aAAQ,GAAuB,EAAE,CAAC;QAQrC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;KACxB;IAEM,kCAAc,GAArB,UAAsB,OAAe,EAAE,OAAe;QAClD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACf,OAAO,EAAE,UAAQ,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAG;YACxC,OAAO,EAAE,OAAO;SACnB,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,EAAE,CAAC;KAClB;IAEM,2BAAO,GAAd;QACI,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE;YAClD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;YAC5C,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;YACtD,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;SAC1C;aAAM,IAAI,IAAI,CAAC,cAAc,EAAE;YAC5B,IAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,oBAAoB,CAAC;YAC1D,IAAI,UAAU,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE;gBAC3C,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;gBAC3B,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;aACpC;SACJ;aAAM;YACH,IAAI,CAAC,YAAY,EAAE,CAAC;SACvB;KACJ;IAEO,gCAAY,GAApB;QACI,QAAQ,IAAI,CAAC,MAAM,CAAC,KAAK;YACrB,KAAK,WAAW,CAAC,IAAI;gBACjB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;gBAC5C,MAAM;YACV,KAAK,WAAW,CAAC,MAAM;gBACnB,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,6BAA6B,CAAC,CAAC;gBACxD,MAAM;YACV,KAAK,WAAW,CAAC,GAAG;gBAChB,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,6BAA6B,CAAC,CAAC;gBACxD,MAAM;YACV,KAAK,WAAW,CAAC,MAAM;gBACnB,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,2BAA2B,CAAC,CAAC;gBACtD,MAAM;YACV,KAAK,WAAW,CAAC,IAAI;gBACjB,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,wBAAwB,CAAC,CAAC;gBACnD,MAAM;YACV,KAAK,WAAW,CAAC,IAAI;gBACjB,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,wBAAwB,CAAC,CAAC;gBACnD,MAAM;YACV,KAAK,WAAW,CAAC,UAAU;gBACvB,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;gBAC3D,MAAM;YACV;gBACI,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;gBAC3D,MAAM;SACb;KACJ;IAEO,kCAAc,GAAtB,UAAuB,SAAiB;QACpC,IAAI,SAAS,EAAE;YACX,IAAI,QAAM,GAAI,MAAc,CAAC,MAAM,CAAC;YACpC,IAAI,OAAO,GAAG,QAAM,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC;YAC1C,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,sBAAoB,OAAO,OAAI,CAAC,CAAC;SAC7D;aAAM;YACH,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;SAC1C;KACJ;IACL,gBAAC;AAAD,CAAC,IAAA;AACD;IAAiC,sCAAoB;IAGjD,4BAAY,MAAmB;QAA/B,YACI,kBAAM,MAAM,CAAC,GAAG,CAAC,SAGpB;QAFG,KAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,KAAI,CAAC,cAAc,CAAC,wEAAwE,CAAC,CAAC;;KACjG;IAGD,2CAAc,GAAd,UAAe,KAAa;QACxB,IAAM,IAAI,GAAI,MAAc,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC;QACpF,IAAI,KAAK,IAAI,EAAE;YAAE,KAAK,GAAG,KAAK,CAAC;QAC/B,OAAO,CAAC,KAAK,EAAK,IAAI,UAAK,KAAO,EAAK,KAAK,UAAK,IAAM,CAAC,CAAC;KAC5D;IAED,6CAAgB,GAAhB,UAAiB,KAAa,EAAE,EAAe;QAC3C,EAAE,CAAC,SAAS,GAAG,KAAK,CAAC;KACxB;IAED,+CAAkB,GAAlB,UAAmB,IAAY,EAAE,CAA6B;QAA9D,iBAEC;QADG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,cAAM,OAAA,KAAI,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,GAAA,CAAC,CAAC;KACjF;IAEL,yBAAC;AAAD,CAxBA,CAAiCC,qBAAY,GAwB5C;AACD;IAAgC,qCAAmC;IAI/D,2BAAY,MAAmB,EAAE,YAAgC;QAAjE,YACI,kBAAM,MAAM,CAAC,GAAG,CAAC,SAIpB;QAHG,KAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,KAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,KAAI,CAAC,cAAc,CAAC,oDAAoD,CAAC,CAAC;;KAC7E;IAED,oCAAQ,GAAR;QACI,OAAO,IAAI,CAAC,YAAY,CAAC;KAC5B;IAED,uCAAW,GAAX,UAAY,IAAsB;QAC9B,IAAI,IAAI,CAAC,KAAK,IAAI,GAAG,IAAI,IAAI,CAAC,WAAW,IAAI,GAAG,EAAE;YAC9C,OAAO,iBAAe,IAAI,CAAC,IAAM,CAAC;SACrC;QAED,IAAI,WAAW,GAAG,EAAE,CAAC;QACrB,IAAI,KAAK,GAAG,EAAE,CAAC;QAEf,IAAI,IAAI,CAAC,WAAW,IAAI,GAAG;YAAE,WAAW,GAAG,kBAAgB,IAAI,CAAC,WAAW,MAAG,CAAC;QAC/E,IAAI,IAAI,CAAC,KAAK,IAAI,GAAG;YAAE,KAAK,GAAG,YAAU,IAAI,CAAC,KAAO,CAAC;QAEtD,OAAO,KAAG,WAAW,GAAG,KAAK,WAAM,IAAI,CAAC,IAAM,CAAC;KAClD;IAED,wCAAY,GAAZ,UAAa,IAAsB,EAAE,CAA6B;QAC9D,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,EAAE;YAC1E,IAAI,CAAC,GAAW,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SACnD;aAAM;YACH,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;SAC1D;KACJ;IACL,wBAAC;AAAD,CApCA,CAAgCC,0BAAiB,GAoChD;AAED;IAAA;QACI,UAAK,GAA2B,EAAE,CAAC;KAgBtC;IAdG,8BAAO,GAAP,UAAQ,IAAwB;QAC5B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtB,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YACzB,IAAI,CAAC,UAAU,EAAE,CAAC;SACrB;KACJ;IACK,iCAAU,GAAhB;;;;gBACI,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;oBACvB,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC;wBACpB,KAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;wBACnB,KAAI,CAAC,UAAU,EAAE,CAAC;qBACrB,CAAC,CAAC;iBACN;;;;KACJ;IACL,mBAAC;AAAD,CAAC;;;;"} diff --git a/.obsidian/plugins/obsidian-git/manifest.json b/.obsidian/plugins/obsidian-git/manifest.json new file mode 100644 index 000000000..5763293ab --- /dev/null +++ b/.obsidian/plugins/obsidian-git/manifest.json @@ -0,0 +1,8 @@ +{ + "id": "obsidian-git", + "name": "Obsidian Git", + "description": "Backup your vault with git.", + "isDesktopOnly": true, + "js": "main.js", + "version": "1.9.0" +} diff --git a/.obsidian/workspace b/.obsidian/workspace new file mode 100644 index 000000000..4bb3aae73 --- /dev/null +++ b/.obsidian/workspace @@ -0,0 +1,111 @@ +{ + "main": { + "id": "dfd308004f3fc7b5", + "type": "split", + "children": [ + { + "id": "3d7c319d327c6624", + "type": "leaf", + "state": { + "type": "markdown", + "state": { + "file": "2021-05-07.md", + "mode": "source" + } + } + } + ], + "direction": "vertical" + }, + "left": { + "id": "2faba265b9292c7f", + "type": "split", + "children": [ + { + "id": "f510565592a031af", + "type": "tabs", + "children": [ + { + "id": "961d680309b2af56", + "type": "leaf", + "state": { + "type": "file-explorer", + "state": {} + } + }, + { + "id": "4c9c5d93a7ed714f", + "type": "leaf", + "state": { + "type": "search", + "state": { + "query": "", + "matchingCase": false, + "explainSearch": false, + "collapseAll": false, + "extraContext": false, + "sortOrder": "alphabetical" + } + } + }, + { + "id": "8af6596dc98ffa6b", + "type": "leaf", + "state": { + "type": "starred", + "state": {} + } + } + ] + } + ], + "direction": "horizontal", + "width": 300 + }, + "right": { + "id": "afe2921ea1b550bb", + "type": "split", + "children": [ + { + "id": "769f8c6855cce1d4", + "type": "tabs", + "children": [ + { + "id": "30e969c9166f9896", + "type": "leaf", + "state": { + "type": "backlink", + "state": { + "file": "2021-05-07.md", + "collapseAll": false, + "extraContext": false, + "sortOrder": "alphabetical", + "showSearch": false, + "searchQuery": "", + "backlinkCollapsed": false, + "unlinkedCollapsed": true + } + } + }, + { + "id": "a62fc60423ac06f4", + "type": "leaf", + "state": { + "type": "outline", + "state": { + "file": "2021-05-07.md" + } + } + } + ] + } + ], + "direction": "horizontal", + "width": 300, + "collapsed": true + }, + "active": "3d7c319d327c6624", + "lastOpenFiles": [ + "2021-05-07.md" + ] +} \ No newline at end of file diff --git a/2020 04 03.md b/2020-04-03.md similarity index 100% rename from 2020 04 03.md rename to 2020-04-03.md diff --git a/2020 04 05.md b/2020-04-05.md similarity index 100% rename from 2020 04 05.md rename to 2020-04-05.md diff --git a/2020 04 06.md b/2020-04-06.md similarity index 100% rename from 2020 04 06.md rename to 2020-04-06.md diff --git a/2020 04 07.md b/2020-04-07.md similarity index 100% rename from 2020 04 07.md rename to 2020-04-07.md diff --git a/2020 04 09.md b/2020-04-09.md similarity index 100% rename from 2020 04 09.md rename to 2020-04-09.md diff --git a/2020 04 10.md b/2020-04-10.md similarity index 100% rename from 2020 04 10.md rename to 2020-04-10.md diff --git a/2020 04 11.md b/2020-04-11.md similarity index 100% rename from 2020 04 11.md rename to 2020-04-11.md diff --git a/2020 04 12.md b/2020-04-12.md similarity index 100% rename from 2020 04 12.md rename to 2020-04-12.md diff --git a/2020 04 13.md b/2020-04-13.md similarity index 100% rename from 2020 04 13.md rename to 2020-04-13.md diff --git a/2020 04 17.md b/2020-04-17.md similarity index 100% rename from 2020 04 17.md rename to 2020-04-17.md diff --git a/2020 04 18.md b/2020-04-18.md similarity index 100% rename from 2020 04 18.md rename to 2020-04-18.md diff --git a/2020 04 19.md b/2020-04-19.md similarity index 100% rename from 2020 04 19.md rename to 2020-04-19.md diff --git a/2020 04 22.md b/2020-04-22.md similarity index 100% rename from 2020 04 22.md rename to 2020-04-22.md diff --git a/2020 04 23.md b/2020-04-23.md similarity index 100% rename from 2020 04 23.md rename to 2020-04-23.md diff --git a/2020 04 24.md b/2020-04-24.md similarity index 100% rename from 2020 04 24.md rename to 2020-04-24.md diff --git a/2020 04 25.md b/2020-04-25.md similarity index 100% rename from 2020 04 25.md rename to 2020-04-25.md diff --git a/2020 04 26.md b/2020-04-26.md similarity index 100% rename from 2020 04 26.md rename to 2020-04-26.md diff --git a/2020 04 27.md b/2020-04-27.md similarity index 100% rename from 2020 04 27.md rename to 2020-04-27.md diff --git a/2020 05 01.md b/2020-05-01.md similarity index 100% rename from 2020 05 01.md rename to 2020-05-01.md diff --git a/2020 05 02.md b/2020-05-02.md similarity index 100% rename from 2020 05 02.md rename to 2020-05-02.md diff --git a/2020 05 03.md b/2020-05-03.md similarity index 100% rename from 2020 05 03.md rename to 2020-05-03.md diff --git a/2020 05 04.md b/2020-05-04.md similarity index 100% rename from 2020 05 04.md rename to 2020-05-04.md diff --git a/2020 05 05.md b/2020-05-05.md similarity index 100% rename from 2020 05 05.md rename to 2020-05-05.md diff --git a/2020 05 06.md b/2020-05-06.md similarity index 100% rename from 2020 05 06.md rename to 2020-05-06.md diff --git a/2020 05 07.md b/2020-05-07.md similarity index 100% rename from 2020 05 07.md rename to 2020-05-07.md diff --git a/2020 05 08.md b/2020-05-08.md similarity index 100% rename from 2020 05 08.md rename to 2020-05-08.md diff --git a/2020 05 09.md b/2020-05-09.md similarity index 100% rename from 2020 05 09.md rename to 2020-05-09.md diff --git a/2020 05 10.md b/2020-05-10.md similarity index 100% rename from 2020 05 10.md rename to 2020-05-10.md diff --git a/2020 05 15.md b/2020-05-15.md similarity index 100% rename from 2020 05 15.md rename to 2020-05-15.md diff --git a/2020 05 16.md b/2020-05-16.md similarity index 100% rename from 2020 05 16.md rename to 2020-05-16.md diff --git a/2020 05 17.md b/2020-05-17.md similarity index 100% rename from 2020 05 17.md rename to 2020-05-17.md diff --git a/2020 05 18.md b/2020-05-18.md similarity index 100% rename from 2020 05 18.md rename to 2020-05-18.md diff --git a/2020 05 19.md b/2020-05-19.md similarity index 100% rename from 2020 05 19.md rename to 2020-05-19.md diff --git a/2020 05 20.md b/2020-05-20.md similarity index 100% rename from 2020 05 20.md rename to 2020-05-20.md diff --git a/2020 05 21.md b/2020-05-21.md similarity index 100% rename from 2020 05 21.md rename to 2020-05-21.md diff --git a/2020 05 22.md b/2020-05-22.md similarity index 100% rename from 2020 05 22.md rename to 2020-05-22.md diff --git a/2020 05 23.md b/2020-05-23.md similarity index 100% rename from 2020 05 23.md rename to 2020-05-23.md diff --git a/2020 05 24.md b/2020-05-24.md similarity index 100% rename from 2020 05 24.md rename to 2020-05-24.md diff --git a/2020 06 01.md b/2020-06-01.md similarity index 100% rename from 2020 06 01.md rename to 2020-06-01.md diff --git a/2020 06 02.md b/2020-06-02.md similarity index 100% rename from 2020 06 02.md rename to 2020-06-02.md diff --git a/2020 06 03.md b/2020-06-03.md similarity index 100% rename from 2020 06 03.md rename to 2020-06-03.md diff --git a/2020 06 04.md b/2020-06-04.md similarity index 100% rename from 2020 06 04.md rename to 2020-06-04.md diff --git a/2020 06 06.md b/2020-06-06.md similarity index 100% rename from 2020 06 06.md rename to 2020-06-06.md diff --git a/2020 06 07.md b/2020-06-07.md similarity index 100% rename from 2020 06 07.md rename to 2020-06-07.md diff --git a/2020 06 08.md b/2020-06-08.md similarity index 100% rename from 2020 06 08.md rename to 2020-06-08.md diff --git a/2020 06 09.md b/2020-06-09.md similarity index 100% rename from 2020 06 09.md rename to 2020-06-09.md diff --git a/2020 06 10.md b/2020-06-10.md similarity index 100% rename from 2020 06 10.md rename to 2020-06-10.md diff --git a/2020 06 11.md b/2020-06-11.md similarity index 100% rename from 2020 06 11.md rename to 2020-06-11.md diff --git a/2020 06 12.md b/2020-06-12.md similarity index 100% rename from 2020 06 12.md rename to 2020-06-12.md diff --git a/2020 06 13.md b/2020-06-13.md similarity index 100% rename from 2020 06 13.md rename to 2020-06-13.md diff --git a/2020 06 14.md b/2020-06-14.md similarity index 100% rename from 2020 06 14.md rename to 2020-06-14.md diff --git a/2020 06 15.md b/2020-06-15.md similarity index 100% rename from 2020 06 15.md rename to 2020-06-15.md diff --git a/2020 06 16.md b/2020-06-16.md similarity index 100% rename from 2020 06 16.md rename to 2020-06-16.md diff --git a/2020 06 17.md b/2020-06-17.md similarity index 100% rename from 2020 06 17.md rename to 2020-06-17.md diff --git a/2020 06 18.md b/2020-06-18.md similarity index 100% rename from 2020 06 18.md rename to 2020-06-18.md diff --git a/2020 06 19.md b/2020-06-19.md similarity index 100% rename from 2020 06 19.md rename to 2020-06-19.md diff --git a/2020 06 20.md b/2020-06-20.md similarity index 100% rename from 2020 06 20.md rename to 2020-06-20.md diff --git a/2020 06 21.md b/2020-06-21.md similarity index 100% rename from 2020 06 21.md rename to 2020-06-21.md diff --git a/2020 06 24.md b/2020-06-24.md similarity index 100% rename from 2020 06 24.md rename to 2020-06-24.md diff --git a/2020 06 27.md b/2020-06-27.md similarity index 100% rename from 2020 06 27.md rename to 2020-06-27.md diff --git a/2020 06 28.md b/2020-06-28.md similarity index 100% rename from 2020 06 28.md rename to 2020-06-28.md diff --git a/2020 06 29.md b/2020-06-29.md similarity index 100% rename from 2020 06 29.md rename to 2020-06-29.md diff --git a/2020 07 04.md b/2020-07-04.md similarity index 100% rename from 2020 07 04.md rename to 2020-07-04.md diff --git a/2020 07 05.md b/2020-07-05.md similarity index 100% rename from 2020 07 05.md rename to 2020-07-05.md diff --git a/2020 07 06.md b/2020-07-06.md similarity index 100% rename from 2020 07 06.md rename to 2020-07-06.md diff --git a/2020 07 07.md b/2020-07-07.md similarity index 100% rename from 2020 07 07.md rename to 2020-07-07.md diff --git a/2020 07 08.md b/2020-07-08.md similarity index 100% rename from 2020 07 08.md rename to 2020-07-08.md diff --git a/2020 07 09.md b/2020-07-09.md similarity index 100% rename from 2020 07 09.md rename to 2020-07-09.md diff --git a/2020 07 10.md b/2020-07-10.md similarity index 100% rename from 2020 07 10.md rename to 2020-07-10.md diff --git a/2020 07 11.md b/2020-07-11.md similarity index 100% rename from 2020 07 11.md rename to 2020-07-11.md diff --git a/2020 07 12.md b/2020-07-12.md similarity index 100% rename from 2020 07 12.md rename to 2020-07-12.md diff --git a/2020 07 14.md b/2020-07-14.md similarity index 100% rename from 2020 07 14.md rename to 2020-07-14.md diff --git a/2020 07 15.md b/2020-07-15.md similarity index 100% rename from 2020 07 15.md rename to 2020-07-15.md diff --git a/2020 07 16.md b/2020-07-16.md similarity index 100% rename from 2020 07 16.md rename to 2020-07-16.md diff --git a/2020 07 17.md b/2020-07-17.md similarity index 100% rename from 2020 07 17.md rename to 2020-07-17.md diff --git a/2020 07 18.md b/2020-07-18.md similarity index 100% rename from 2020 07 18.md rename to 2020-07-18.md diff --git a/2020 07 19.md b/2020-07-19.md similarity index 100% rename from 2020 07 19.md rename to 2020-07-19.md diff --git a/2020 07 20.md b/2020-07-20.md similarity index 100% rename from 2020 07 20.md rename to 2020-07-20.md diff --git a/2020 07 21.md b/2020-07-21.md similarity index 100% rename from 2020 07 21.md rename to 2020-07-21.md diff --git a/2020 07 22.md b/2020-07-22.md similarity index 100% rename from 2020 07 22.md rename to 2020-07-22.md diff --git a/2020 07 23.md b/2020-07-23.md similarity index 100% rename from 2020 07 23.md rename to 2020-07-23.md diff --git a/2020 07 24.md b/2020-07-24.md similarity index 100% rename from 2020 07 24.md rename to 2020-07-24.md diff --git a/2020 07 25.md b/2020-07-25.md similarity index 100% rename from 2020 07 25.md rename to 2020-07-25.md diff --git a/2020 07 26.md b/2020-07-26.md similarity index 100% rename from 2020 07 26.md rename to 2020-07-26.md diff --git a/2020 07 27.md b/2020-07-27.md similarity index 100% rename from 2020 07 27.md rename to 2020-07-27.md diff --git a/2020 07 29.md b/2020-07-29.md similarity index 100% rename from 2020 07 29.md rename to 2020-07-29.md diff --git a/2020 07 30.md b/2020-07-30.md similarity index 100% rename from 2020 07 30.md rename to 2020-07-30.md diff --git a/2020 07 31.md b/2020-07-31.md similarity index 100% rename from 2020 07 31.md rename to 2020-07-31.md diff --git a/2020 08 01.md b/2020-08-01.md similarity index 100% rename from 2020 08 01.md rename to 2020-08-01.md diff --git a/2020 08 02.md b/2020-08-02.md similarity index 100% rename from 2020 08 02.md rename to 2020-08-02.md diff --git a/2020 08 03.md b/2020-08-03.md similarity index 100% rename from 2020 08 03.md rename to 2020-08-03.md diff --git a/2020 08 04.md b/2020-08-04.md similarity index 100% rename from 2020 08 04.md rename to 2020-08-04.md diff --git a/2020 08 05.md b/2020-08-05.md similarity index 100% rename from 2020 08 05.md rename to 2020-08-05.md diff --git a/2020 08 06.md b/2020-08-06.md similarity index 100% rename from 2020 08 06.md rename to 2020-08-06.md diff --git a/2020 08 07.md b/2020-08-07.md similarity index 100% rename from 2020 08 07.md rename to 2020-08-07.md diff --git a/2020 08 08.md b/2020-08-08.md similarity index 100% rename from 2020 08 08.md rename to 2020-08-08.md diff --git a/2020 08 09.md b/2020-08-09.md similarity index 100% rename from 2020 08 09.md rename to 2020-08-09.md diff --git a/2020 08 10.md b/2020-08-10.md similarity index 100% rename from 2020 08 10.md rename to 2020-08-10.md diff --git a/2020 08 11.md b/2020-08-11.md similarity index 100% rename from 2020 08 11.md rename to 2020-08-11.md diff --git a/2020 08 12.md b/2020-08-12.md similarity index 100% rename from 2020 08 12.md rename to 2020-08-12.md diff --git a/2020 08 13.md b/2020-08-13.md similarity index 100% rename from 2020 08 13.md rename to 2020-08-13.md diff --git a/2020 08 14.md b/2020-08-14.md similarity index 100% rename from 2020 08 14.md rename to 2020-08-14.md diff --git a/2020 08 15.md b/2020-08-15.md similarity index 100% rename from 2020 08 15.md rename to 2020-08-15.md diff --git a/2020 08 16.md b/2020-08-16.md similarity index 100% rename from 2020 08 16.md rename to 2020-08-16.md diff --git a/2020 08 17.md b/2020-08-17.md similarity index 100% rename from 2020 08 17.md rename to 2020-08-17.md diff --git a/2020 08 18.md b/2020-08-18.md similarity index 100% rename from 2020 08 18.md rename to 2020-08-18.md diff --git a/2020 08 19.md b/2020-08-19.md similarity index 100% rename from 2020 08 19.md rename to 2020-08-19.md diff --git a/2020 08 20.md b/2020-08-20.md similarity index 100% rename from 2020 08 20.md rename to 2020-08-20.md diff --git a/2020 08 21.md b/2020-08-21.md similarity index 100% rename from 2020 08 21.md rename to 2020-08-21.md diff --git a/2020 08 22.md b/2020-08-22.md similarity index 100% rename from 2020 08 22.md rename to 2020-08-22.md diff --git a/2020 08 23.md b/2020-08-23.md similarity index 100% rename from 2020 08 23.md rename to 2020-08-23.md diff --git a/2020 08 24.md b/2020-08-24.md similarity index 100% rename from 2020 08 24.md rename to 2020-08-24.md diff --git a/2020 08 25.md b/2020-08-25.md similarity index 100% rename from 2020 08 25.md rename to 2020-08-25.md diff --git a/2020 08 26.md b/2020-08-26.md similarity index 100% rename from 2020 08 26.md rename to 2020-08-26.md diff --git a/2020 08 27.md b/2020-08-27.md similarity index 100% rename from 2020 08 27.md rename to 2020-08-27.md diff --git a/2020 08 28.md b/2020-08-28.md similarity index 100% rename from 2020 08 28.md rename to 2020-08-28.md diff --git a/2020 08 29.md b/2020-08-29.md similarity index 100% rename from 2020 08 29.md rename to 2020-08-29.md diff --git a/2020 08 30.md b/2020-08-30.md similarity index 100% rename from 2020 08 30.md rename to 2020-08-30.md diff --git a/2020 08 31.md b/2020-08-31.md similarity index 100% rename from 2020 08 31.md rename to 2020-08-31.md diff --git a/2020 09 01.md b/2020-09-01.md similarity index 100% rename from 2020 09 01.md rename to 2020-09-01.md diff --git a/2020 09 02.md b/2020-09-02.md similarity index 100% rename from 2020 09 02.md rename to 2020-09-02.md diff --git a/2020 09 03.md b/2020-09-03.md similarity index 100% rename from 2020 09 03.md rename to 2020-09-03.md diff --git a/2020 09 04.md b/2020-09-04.md similarity index 100% rename from 2020 09 04.md rename to 2020-09-04.md diff --git a/2020 09 05.md b/2020-09-05.md similarity index 100% rename from 2020 09 05.md rename to 2020-09-05.md diff --git a/2020 09 06.md b/2020-09-06.md similarity index 100% rename from 2020 09 06.md rename to 2020-09-06.md diff --git a/2020 09 07.md b/2020-09-07.md similarity index 100% rename from 2020 09 07.md rename to 2020-09-07.md diff --git a/2020 09 08.md b/2020-09-08.md similarity index 100% rename from 2020 09 08.md rename to 2020-09-08.md diff --git a/2020 09 09.md b/2020-09-09.md similarity index 100% rename from 2020 09 09.md rename to 2020-09-09.md diff --git a/2020 09 10.md b/2020-09-10.md similarity index 100% rename from 2020 09 10.md rename to 2020-09-10.md diff --git a/2020 09 11.md b/2020-09-11.md similarity index 100% rename from 2020 09 11.md rename to 2020-09-11.md diff --git a/2020 09 12.md b/2020-09-12.md similarity index 100% rename from 2020 09 12.md rename to 2020-09-12.md diff --git a/2020 09 13.md b/2020-09-13.md similarity index 100% rename from 2020 09 13.md rename to 2020-09-13.md diff --git a/2020 09 14.md b/2020-09-14.md similarity index 100% rename from 2020 09 14.md rename to 2020-09-14.md diff --git a/2020 09 15.md b/2020-09-15.md similarity index 100% rename from 2020 09 15.md rename to 2020-09-15.md diff --git a/2020 09 16.md b/2020-09-16.md similarity index 100% rename from 2020 09 16.md rename to 2020-09-16.md diff --git a/2020 09 17.md b/2020-09-17.md similarity index 100% rename from 2020 09 17.md rename to 2020-09-17.md diff --git a/2020 09 18.md b/2020-09-18.md similarity index 100% rename from 2020 09 18.md rename to 2020-09-18.md diff --git a/2020 09 19.md b/2020-09-19.md similarity index 100% rename from 2020 09 19.md rename to 2020-09-19.md diff --git a/2020 09 20.md b/2020-09-20.md similarity index 100% rename from 2020 09 20.md rename to 2020-09-20.md diff --git a/2020 09 21.md b/2020-09-21.md similarity index 100% rename from 2020 09 21.md rename to 2020-09-21.md diff --git a/2020 09 22.md b/2020-09-22.md similarity index 100% rename from 2020 09 22.md rename to 2020-09-22.md diff --git a/2020 09 23.md b/2020-09-23.md similarity index 100% rename from 2020 09 23.md rename to 2020-09-23.md diff --git a/2020 09 24.md b/2020-09-24.md similarity index 100% rename from 2020 09 24.md rename to 2020-09-24.md diff --git a/2020 09 25.md b/2020-09-25.md similarity index 100% rename from 2020 09 25.md rename to 2020-09-25.md diff --git a/2020 09 26.md b/2020-09-26.md similarity index 100% rename from 2020 09 26.md rename to 2020-09-26.md diff --git a/2020 09 27.md b/2020-09-27.md similarity index 100% rename from 2020 09 27.md rename to 2020-09-27.md diff --git a/2020 09 28.md b/2020-09-28.md similarity index 100% rename from 2020 09 28.md rename to 2020-09-28.md diff --git a/2020 09 29.md b/2020-09-29.md similarity index 100% rename from 2020 09 29.md rename to 2020-09-29.md diff --git a/2020 09 30.md b/2020-09-30.md similarity index 100% rename from 2020 09 30.md rename to 2020-09-30.md diff --git a/2020 10 01.md b/2020-10-01.md similarity index 100% rename from 2020 10 01.md rename to 2020-10-01.md diff --git a/2020 10 02.md b/2020-10-02.md similarity index 100% rename from 2020 10 02.md rename to 2020-10-02.md diff --git a/2020 10 03.md b/2020-10-03.md similarity index 100% rename from 2020 10 03.md rename to 2020-10-03.md diff --git a/2020 10 04.md b/2020-10-04.md similarity index 100% rename from 2020 10 04.md rename to 2020-10-04.md diff --git a/2020 10 05.md b/2020-10-05.md similarity index 100% rename from 2020 10 05.md rename to 2020-10-05.md diff --git a/2020 10 06.md b/2020-10-06.md similarity index 100% rename from 2020 10 06.md rename to 2020-10-06.md diff --git a/2020 10 07.md b/2020-10-07.md similarity index 100% rename from 2020 10 07.md rename to 2020-10-07.md diff --git a/2020 10 08.md b/2020-10-08.md similarity index 100% rename from 2020 10 08.md rename to 2020-10-08.md diff --git a/2020 10 09.md b/2020-10-09.md similarity index 100% rename from 2020 10 09.md rename to 2020-10-09.md diff --git a/2020 10 10.md b/2020-10-10.md similarity index 100% rename from 2020 10 10.md rename to 2020-10-10.md diff --git a/2020 10 11.md b/2020-10-11.md similarity index 100% rename from 2020 10 11.md rename to 2020-10-11.md diff --git a/2020 10 12.md b/2020-10-12.md similarity index 100% rename from 2020 10 12.md rename to 2020-10-12.md diff --git a/2020 10 13.md b/2020-10-13.md similarity index 100% rename from 2020 10 13.md rename to 2020-10-13.md diff --git a/2020 10 14.md b/2020-10-14.md similarity index 100% rename from 2020 10 14.md rename to 2020-10-14.md diff --git a/2020 10 15.md b/2020-10-15.md similarity index 100% rename from 2020 10 15.md rename to 2020-10-15.md diff --git a/2020 10 16.md b/2020-10-16.md similarity index 100% rename from 2020 10 16.md rename to 2020-10-16.md diff --git a/2020 10 17.md b/2020-10-17.md similarity index 100% rename from 2020 10 17.md rename to 2020-10-17.md diff --git a/2020 10 18.md b/2020-10-18.md similarity index 100% rename from 2020 10 18.md rename to 2020-10-18.md diff --git a/2020 10 19.md b/2020-10-19.md similarity index 100% rename from 2020 10 19.md rename to 2020-10-19.md diff --git a/2020 10 20.md b/2020-10-20.md similarity index 100% rename from 2020 10 20.md rename to 2020-10-20.md diff --git a/2020 10 21.md b/2020-10-21.md similarity index 100% rename from 2020 10 21.md rename to 2020-10-21.md diff --git a/2020 10 22.md b/2020-10-22.md similarity index 100% rename from 2020 10 22.md rename to 2020-10-22.md diff --git a/2020 10 23.md b/2020-10-23.md similarity index 100% rename from 2020 10 23.md rename to 2020-10-23.md diff --git a/2020 10 24.md b/2020-10-24.md similarity index 100% rename from 2020 10 24.md rename to 2020-10-24.md diff --git a/2020 10 25.md b/2020-10-25.md similarity index 100% rename from 2020 10 25.md rename to 2020-10-25.md diff --git a/2020 10 26.md b/2020-10-26.md similarity index 100% rename from 2020 10 26.md rename to 2020-10-26.md diff --git a/2020 10 27.md b/2020-10-27.md similarity index 100% rename from 2020 10 27.md rename to 2020-10-27.md diff --git a/2020 10 28.md b/2020-10-28.md similarity index 100% rename from 2020 10 28.md rename to 2020-10-28.md diff --git a/2020 10 29.md b/2020-10-29.md similarity index 100% rename from 2020 10 29.md rename to 2020-10-29.md diff --git a/2020 10 30.md b/2020-10-30.md similarity index 100% rename from 2020 10 30.md rename to 2020-10-30.md diff --git a/2020 10 31.md b/2020-10-31.md similarity index 100% rename from 2020 10 31.md rename to 2020-10-31.md diff --git a/2020 11 01.md b/2020-11-01.md similarity index 100% rename from 2020 11 01.md rename to 2020-11-01.md diff --git a/2020 11 02.md b/2020-11-02.md similarity index 100% rename from 2020 11 02.md rename to 2020-11-02.md diff --git a/2020 11 03.md b/2020-11-03.md similarity index 100% rename from 2020 11 03.md rename to 2020-11-03.md diff --git a/2020 11 04.md b/2020-11-04.md similarity index 100% rename from 2020 11 04.md rename to 2020-11-04.md diff --git a/2020 11 05.md b/2020-11-05.md similarity index 100% rename from 2020 11 05.md rename to 2020-11-05.md diff --git a/2020 11 06.md b/2020-11-06.md similarity index 100% rename from 2020 11 06.md rename to 2020-11-06.md diff --git a/2020 11 07.md b/2020-11-07.md similarity index 100% rename from 2020 11 07.md rename to 2020-11-07.md diff --git a/2020 11 08.md b/2020-11-08.md similarity index 100% rename from 2020 11 08.md rename to 2020-11-08.md diff --git a/2020 11 09.md b/2020-11-09.md similarity index 100% rename from 2020 11 09.md rename to 2020-11-09.md diff --git a/2020 11 10.md b/2020-11-10.md similarity index 100% rename from 2020 11 10.md rename to 2020-11-10.md diff --git a/2020 11 11.md b/2020-11-11.md similarity index 100% rename from 2020 11 11.md rename to 2020-11-11.md diff --git a/2020 11 12.md b/2020-11-12.md similarity index 100% rename from 2020 11 12.md rename to 2020-11-12.md diff --git a/2020 11 13.md b/2020-11-13.md similarity index 100% rename from 2020 11 13.md rename to 2020-11-13.md diff --git a/2020 11 14.md b/2020-11-14.md similarity index 100% rename from 2020 11 14.md rename to 2020-11-14.md diff --git a/2020 11 15.md b/2020-11-15.md similarity index 100% rename from 2020 11 15.md rename to 2020-11-15.md diff --git a/2020 11 16.md b/2020-11-16.md similarity index 100% rename from 2020 11 16.md rename to 2020-11-16.md diff --git a/2020 11 17.md b/2020-11-17.md similarity index 100% rename from 2020 11 17.md rename to 2020-11-17.md diff --git a/2020 11 18.md b/2020-11-18.md similarity index 100% rename from 2020 11 18.md rename to 2020-11-18.md diff --git a/2020 11 19.md b/2020-11-19.md similarity index 100% rename from 2020 11 19.md rename to 2020-11-19.md diff --git a/2020 11 20.md b/2020-11-20.md similarity index 100% rename from 2020 11 20.md rename to 2020-11-20.md diff --git a/2020 11 21.md b/2020-11-21.md similarity index 100% rename from 2020 11 21.md rename to 2020-11-21.md diff --git a/2020 11 22.md b/2020-11-22.md similarity index 100% rename from 2020 11 22.md rename to 2020-11-22.md diff --git a/2020 11 23.md b/2020-11-23.md similarity index 100% rename from 2020 11 23.md rename to 2020-11-23.md diff --git a/2020 11 24.md b/2020-11-24.md similarity index 100% rename from 2020 11 24.md rename to 2020-11-24.md diff --git a/2020 11 25.md b/2020-11-25.md similarity index 100% rename from 2020 11 25.md rename to 2020-11-25.md diff --git a/2020 11 26.md b/2020-11-26.md similarity index 100% rename from 2020 11 26.md rename to 2020-11-26.md diff --git a/2020 11 27.md b/2020-11-27.md similarity index 100% rename from 2020 11 27.md rename to 2020-11-27.md diff --git a/2020 11 28.md b/2020-11-28.md similarity index 100% rename from 2020 11 28.md rename to 2020-11-28.md diff --git a/2020 11 29.md b/2020-11-29.md similarity index 100% rename from 2020 11 29.md rename to 2020-11-29.md diff --git a/2020 11 30.md b/2020-11-30.md similarity index 100% rename from 2020 11 30.md rename to 2020-11-30.md diff --git a/2020 12 01.md b/2020-12-01.md similarity index 100% rename from 2020 12 01.md rename to 2020-12-01.md diff --git a/2020 12 02.md b/2020-12-02.md similarity index 100% rename from 2020 12 02.md rename to 2020-12-02.md diff --git a/2020 12 03.md b/2020-12-03.md similarity index 100% rename from 2020 12 03.md rename to 2020-12-03.md diff --git a/2020 12 04.md b/2020-12-04.md similarity index 100% rename from 2020 12 04.md rename to 2020-12-04.md diff --git a/2020 12 05.md b/2020-12-05.md similarity index 100% rename from 2020 12 05.md rename to 2020-12-05.md diff --git a/2020 12 06.md b/2020-12-06.md similarity index 100% rename from 2020 12 06.md rename to 2020-12-06.md diff --git a/2020 12 07.md b/2020-12-07.md similarity index 100% rename from 2020 12 07.md rename to 2020-12-07.md diff --git a/2020 12 08.md b/2020-12-08.md similarity index 100% rename from 2020 12 08.md rename to 2020-12-08.md diff --git a/2020 12 09.md b/2020-12-09.md similarity index 100% rename from 2020 12 09.md rename to 2020-12-09.md diff --git a/2020 12 10.md b/2020-12-10.md similarity index 100% rename from 2020 12 10.md rename to 2020-12-10.md diff --git a/2020 12 11.md b/2020-12-11.md similarity index 100% rename from 2020 12 11.md rename to 2020-12-11.md diff --git a/2020 12 12.md b/2020-12-12.md similarity index 100% rename from 2020 12 12.md rename to 2020-12-12.md diff --git a/2020 12 13.md b/2020-12-13.md similarity index 100% rename from 2020 12 13.md rename to 2020-12-13.md diff --git a/2020 12 14.md b/2020-12-14.md similarity index 100% rename from 2020 12 14.md rename to 2020-12-14.md diff --git a/2020 12 15.md b/2020-12-15.md similarity index 100% rename from 2020 12 15.md rename to 2020-12-15.md diff --git a/2020 12 16.md b/2020-12-16.md similarity index 100% rename from 2020 12 16.md rename to 2020-12-16.md diff --git a/2020 12 17.md b/2020-12-17.md similarity index 100% rename from 2020 12 17.md rename to 2020-12-17.md diff --git a/2020 12 18.md b/2020-12-18.md similarity index 100% rename from 2020 12 18.md rename to 2020-12-18.md diff --git a/2020 12 19.md b/2020-12-19.md similarity index 100% rename from 2020 12 19.md rename to 2020-12-19.md diff --git a/2020 12 20.md b/2020-12-20.md similarity index 100% rename from 2020 12 20.md rename to 2020-12-20.md diff --git a/2020 12 21.md b/2020-12-21.md similarity index 100% rename from 2020 12 21.md rename to 2020-12-21.md diff --git a/2020 12 22.md b/2020-12-22.md similarity index 100% rename from 2020 12 22.md rename to 2020-12-22.md diff --git a/2020 12 23.md b/2020-12-23.md similarity index 100% rename from 2020 12 23.md rename to 2020-12-23.md diff --git a/2020 12 24.md b/2020-12-24.md similarity index 100% rename from 2020 12 24.md rename to 2020-12-24.md diff --git a/2020 12 25.md b/2020-12-25.md similarity index 100% rename from 2020 12 25.md rename to 2020-12-25.md diff --git a/2020 12 26.md b/2020-12-26.md similarity index 100% rename from 2020 12 26.md rename to 2020-12-26.md diff --git a/2020 12 27.md b/2020-12-27.md similarity index 100% rename from 2020 12 27.md rename to 2020-12-27.md diff --git a/2020 12 28.md b/2020-12-28.md similarity index 100% rename from 2020 12 28.md rename to 2020-12-28.md diff --git a/2020 12 29.md b/2020-12-29.md similarity index 100% rename from 2020 12 29.md rename to 2020-12-29.md diff --git a/2020 12 30.md b/2020-12-30.md similarity index 100% rename from 2020 12 30.md rename to 2020-12-30.md diff --git a/2020 12 31.md b/2020-12-31.md similarity index 100% rename from 2020 12 31.md rename to 2020-12-31.md diff --git a/2021 01 01.md b/2021-01-01.md similarity index 100% rename from 2021 01 01.md rename to 2021-01-01.md diff --git a/2021 01 02.md b/2021-01-02.md similarity index 100% rename from 2021 01 02.md rename to 2021-01-02.md diff --git a/2021 01 03.md b/2021-01-03.md similarity index 100% rename from 2021 01 03.md rename to 2021-01-03.md diff --git a/2021 01 04.md b/2021-01-04.md similarity index 100% rename from 2021 01 04.md rename to 2021-01-04.md diff --git a/2021 01 05.md b/2021-01-05.md similarity index 100% rename from 2021 01 05.md rename to 2021-01-05.md diff --git a/2021 01 06.md b/2021-01-06.md similarity index 100% rename from 2021 01 06.md rename to 2021-01-06.md diff --git a/2021 01 07.md b/2021-01-07.md similarity index 100% rename from 2021 01 07.md rename to 2021-01-07.md diff --git a/2021 01 08.md b/2021-01-08.md similarity index 100% rename from 2021 01 08.md rename to 2021-01-08.md diff --git a/2021 01 09.md b/2021-01-09.md similarity index 100% rename from 2021 01 09.md rename to 2021-01-09.md diff --git a/2021 01 10.md b/2021-01-10.md similarity index 100% rename from 2021 01 10.md rename to 2021-01-10.md diff --git a/2021 01 11.md b/2021-01-11.md similarity index 100% rename from 2021 01 11.md rename to 2021-01-11.md diff --git a/2021 01 12.md b/2021-01-12.md similarity index 100% rename from 2021 01 12.md rename to 2021-01-12.md diff --git a/2021 01 13.md b/2021-01-13.md similarity index 100% rename from 2021 01 13.md rename to 2021-01-13.md diff --git a/2021 01 14.md b/2021-01-14.md similarity index 100% rename from 2021 01 14.md rename to 2021-01-14.md diff --git a/2021 01 15.md b/2021-01-15.md similarity index 100% rename from 2021 01 15.md rename to 2021-01-15.md diff --git a/2021 01 16.md b/2021-01-16.md similarity index 100% rename from 2021 01 16.md rename to 2021-01-16.md diff --git a/2021 01 17.md b/2021-01-17.md similarity index 100% rename from 2021 01 17.md rename to 2021-01-17.md diff --git a/2021 01 18.md b/2021-01-18.md similarity index 100% rename from 2021 01 18.md rename to 2021-01-18.md diff --git a/2021 01 19.md b/2021-01-19.md similarity index 100% rename from 2021 01 19.md rename to 2021-01-19.md diff --git a/2021 01 20.md b/2021-01-20.md similarity index 100% rename from 2021 01 20.md rename to 2021-01-20.md diff --git a/2021 01 21.md b/2021-01-21.md similarity index 100% rename from 2021 01 21.md rename to 2021-01-21.md diff --git a/2021 01 22.md b/2021-01-22.md similarity index 100% rename from 2021 01 22.md rename to 2021-01-22.md diff --git a/2021 01 23.md b/2021-01-23.md similarity index 100% rename from 2021 01 23.md rename to 2021-01-23.md diff --git a/2021 01 24.md b/2021-01-24.md similarity index 100% rename from 2021 01 24.md rename to 2021-01-24.md diff --git a/2021 01 25.md b/2021-01-25.md similarity index 100% rename from 2021 01 25.md rename to 2021-01-25.md diff --git a/2021 01 26.md b/2021-01-26.md similarity index 100% rename from 2021 01 26.md rename to 2021-01-26.md diff --git a/2021 01 27.md b/2021-01-27.md similarity index 100% rename from 2021 01 27.md rename to 2021-01-27.md diff --git a/2021 01 28.md b/2021-01-28.md similarity index 100% rename from 2021 01 28.md rename to 2021-01-28.md diff --git a/2021 01 29.md b/2021-01-29.md similarity index 100% rename from 2021 01 29.md rename to 2021-01-29.md diff --git a/2021 01 30.md b/2021-01-30.md similarity index 100% rename from 2021 01 30.md rename to 2021-01-30.md diff --git a/2021 01 31.md b/2021-01-31.md similarity index 100% rename from 2021 01 31.md rename to 2021-01-31.md diff --git a/2021 02 01.md b/2021-02-01.md similarity index 100% rename from 2021 02 01.md rename to 2021-02-01.md diff --git a/2021 02 02.md b/2021-02-02.md similarity index 100% rename from 2021 02 02.md rename to 2021-02-02.md diff --git a/2021 02 03.md b/2021-02-03.md similarity index 100% rename from 2021 02 03.md rename to 2021-02-03.md diff --git a/2021 02 04.md b/2021-02-04.md similarity index 100% rename from 2021 02 04.md rename to 2021-02-04.md diff --git a/2021 02 05.md b/2021-02-05.md similarity index 100% rename from 2021 02 05.md rename to 2021-02-05.md diff --git a/2021 02 06.md b/2021-02-06.md similarity index 100% rename from 2021 02 06.md rename to 2021-02-06.md diff --git a/2021 02 07.md b/2021-02-07.md similarity index 100% rename from 2021 02 07.md rename to 2021-02-07.md diff --git a/2021 02 08.md b/2021-02-08.md similarity index 100% rename from 2021 02 08.md rename to 2021-02-08.md diff --git a/2021 02 09.md b/2021-02-09.md similarity index 100% rename from 2021 02 09.md rename to 2021-02-09.md diff --git a/2021 02 10.md b/2021-02-10.md similarity index 100% rename from 2021 02 10.md rename to 2021-02-10.md diff --git a/2021 02 11.md b/2021-02-11.md similarity index 100% rename from 2021 02 11.md rename to 2021-02-11.md diff --git a/2021 02 12.md b/2021-02-12.md similarity index 100% rename from 2021 02 12.md rename to 2021-02-12.md diff --git a/2021 02 13.md b/2021-02-13.md similarity index 100% rename from 2021 02 13.md rename to 2021-02-13.md diff --git a/2021 02 14.md b/2021-02-14.md similarity index 100% rename from 2021 02 14.md rename to 2021-02-14.md diff --git a/2021 02 15.md b/2021-02-15.md similarity index 100% rename from 2021 02 15.md rename to 2021-02-15.md diff --git a/2021 02 16.md b/2021-02-16.md similarity index 100% rename from 2021 02 16.md rename to 2021-02-16.md diff --git a/2021 02 17.md b/2021-02-17.md similarity index 100% rename from 2021 02 17.md rename to 2021-02-17.md diff --git a/2021 02 18.md b/2021-02-18.md similarity index 100% rename from 2021 02 18.md rename to 2021-02-18.md diff --git a/2021 02 19.md b/2021-02-19.md similarity index 100% rename from 2021 02 19.md rename to 2021-02-19.md diff --git a/2021 02 20.md b/2021-02-20.md similarity index 100% rename from 2021 02 20.md rename to 2021-02-20.md diff --git a/2021 02 21.md b/2021-02-21.md similarity index 100% rename from 2021 02 21.md rename to 2021-02-21.md diff --git a/2021 02 22.md b/2021-02-22.md similarity index 100% rename from 2021 02 22.md rename to 2021-02-22.md diff --git a/2021 02 23.md b/2021-02-23.md similarity index 100% rename from 2021 02 23.md rename to 2021-02-23.md diff --git a/2021 02 24.md b/2021-02-24.md similarity index 100% rename from 2021 02 24.md rename to 2021-02-24.md diff --git a/2021 02 25.md b/2021-02-25.md similarity index 100% rename from 2021 02 25.md rename to 2021-02-25.md diff --git a/2021 02 26.md b/2021-02-26.md similarity index 100% rename from 2021 02 26.md rename to 2021-02-26.md diff --git a/2021 02 27.md b/2021-02-27.md similarity index 100% rename from 2021 02 27.md rename to 2021-02-27.md diff --git a/2021 02 28.md b/2021-02-28.md similarity index 100% rename from 2021 02 28.md rename to 2021-02-28.md diff --git a/2021 03 01.md b/2021-03-01.md similarity index 100% rename from 2021 03 01.md rename to 2021-03-01.md diff --git a/2021 03 02.md b/2021-03-02.md similarity index 100% rename from 2021 03 02.md rename to 2021-03-02.md diff --git a/2021 03 03.md b/2021-03-03.md similarity index 100% rename from 2021 03 03.md rename to 2021-03-03.md diff --git a/2021 03 04.md b/2021-03-04.md similarity index 100% rename from 2021 03 04.md rename to 2021-03-04.md diff --git a/2021 03 05.md b/2021-03-05.md similarity index 100% rename from 2021 03 05.md rename to 2021-03-05.md diff --git a/2021 03 06.md b/2021-03-06.md similarity index 100% rename from 2021 03 06.md rename to 2021-03-06.md diff --git a/2021 03 07.md b/2021-03-07.md similarity index 100% rename from 2021 03 07.md rename to 2021-03-07.md diff --git a/2021 03 08.md b/2021-03-08.md similarity index 100% rename from 2021 03 08.md rename to 2021-03-08.md diff --git a/2021 03 09.md b/2021-03-09.md similarity index 100% rename from 2021 03 09.md rename to 2021-03-09.md diff --git a/2021 03 10.md b/2021-03-10.md similarity index 100% rename from 2021 03 10.md rename to 2021-03-10.md diff --git a/2021 03 11.md b/2021-03-11.md similarity index 100% rename from 2021 03 11.md rename to 2021-03-11.md diff --git a/2021 03 12.md b/2021-03-12.md similarity index 100% rename from 2021 03 12.md rename to 2021-03-12.md diff --git a/2021 03 13.md b/2021-03-13.md similarity index 100% rename from 2021 03 13.md rename to 2021-03-13.md diff --git a/2021 03 14.md b/2021-03-14.md similarity index 100% rename from 2021 03 14.md rename to 2021-03-14.md diff --git a/2021 03 15.md b/2021-03-15.md similarity index 100% rename from 2021 03 15.md rename to 2021-03-15.md diff --git a/2021 03 16.md b/2021-03-16.md similarity index 100% rename from 2021 03 16.md rename to 2021-03-16.md diff --git a/2021 03 17.md b/2021-03-17.md similarity index 100% rename from 2021 03 17.md rename to 2021-03-17.md diff --git a/2021 03 18.md b/2021-03-18.md similarity index 100% rename from 2021 03 18.md rename to 2021-03-18.md diff --git a/2021 03 19.md b/2021-03-19.md similarity index 100% rename from 2021 03 19.md rename to 2021-03-19.md diff --git a/2021 03 20.md b/2021-03-20.md similarity index 100% rename from 2021 03 20.md rename to 2021-03-20.md diff --git a/2021 03 21.md b/2021-03-21.md similarity index 100% rename from 2021 03 21.md rename to 2021-03-21.md diff --git a/2021 03 22.md b/2021-03-22.md similarity index 100% rename from 2021 03 22.md rename to 2021-03-22.md diff --git a/2021 03 23.md b/2021-03-23.md similarity index 100% rename from 2021 03 23.md rename to 2021-03-23.md diff --git a/2021 03 24.md b/2021-03-24.md similarity index 100% rename from 2021 03 24.md rename to 2021-03-24.md diff --git a/2021 03 25.md b/2021-03-25.md similarity index 100% rename from 2021 03 25.md rename to 2021-03-25.md diff --git a/2021 03 26.md b/2021-03-26.md similarity index 100% rename from 2021 03 26.md rename to 2021-03-26.md diff --git a/2021 03 27.md b/2021-03-27.md similarity index 100% rename from 2021 03 27.md rename to 2021-03-27.md diff --git a/2021 03 28.md b/2021-03-28.md similarity index 100% rename from 2021 03 28.md rename to 2021-03-28.md diff --git a/2021 03 29.md b/2021-03-29.md similarity index 100% rename from 2021 03 29.md rename to 2021-03-29.md diff --git a/2021 03 30.md b/2021-03-30.md similarity index 100% rename from 2021 03 30.md rename to 2021-03-30.md diff --git a/2021 03 31.md b/2021-03-31.md similarity index 100% rename from 2021 03 31.md rename to 2021-03-31.md diff --git a/2021 04 01.md b/2021-04-01.md similarity index 100% rename from 2021 04 01.md rename to 2021-04-01.md diff --git a/2021 04 02.md b/2021-04-02.md similarity index 100% rename from 2021 04 02.md rename to 2021-04-02.md diff --git a/2021 04 03.md b/2021-04-03.md similarity index 100% rename from 2021 04 03.md rename to 2021-04-03.md diff --git a/2021 04 05.md b/2021-04-05.md similarity index 100% rename from 2021 04 05.md rename to 2021-04-05.md diff --git a/2021 04 06.md b/2021-04-06.md similarity index 100% rename from 2021 04 06.md rename to 2021-04-06.md diff --git a/2021 04 07.md b/2021-04-07.md similarity index 100% rename from 2021 04 07.md rename to 2021-04-07.md diff --git a/2021 04 08.md b/2021-04-08.md similarity index 100% rename from 2021 04 08.md rename to 2021-04-08.md diff --git a/2021 04 09.md b/2021-04-09.md similarity index 100% rename from 2021 04 09.md rename to 2021-04-09.md diff --git a/2021 04 10.md b/2021-04-10.md similarity index 100% rename from 2021 04 10.md rename to 2021-04-10.md diff --git a/2021 04 11.md b/2021-04-11.md similarity index 100% rename from 2021 04 11.md rename to 2021-04-11.md diff --git a/2021 04 12.md b/2021-04-12.md similarity index 100% rename from 2021 04 12.md rename to 2021-04-12.md diff --git a/2021 04 13.md b/2021-04-13.md similarity index 100% rename from 2021 04 13.md rename to 2021-04-13.md diff --git a/2021 04 14.md b/2021-04-14.md similarity index 100% rename from 2021 04 14.md rename to 2021-04-14.md diff --git a/2021 04 15.md b/2021-04-15.md similarity index 100% rename from 2021 04 15.md rename to 2021-04-15.md diff --git a/2021 04 16.md b/2021-04-16.md similarity index 100% rename from 2021 04 16.md rename to 2021-04-16.md diff --git a/2021 04 17.md b/2021-04-17.md similarity index 100% rename from 2021 04 17.md rename to 2021-04-17.md diff --git a/2021 04 18.md b/2021-04-18.md similarity index 100% rename from 2021 04 18.md rename to 2021-04-18.md diff --git a/2021 04 19.md b/2021-04-19.md similarity index 100% rename from 2021 04 19.md rename to 2021-04-19.md diff --git a/2021 04 20.md b/2021-04-20.md similarity index 100% rename from 2021 04 20.md rename to 2021-04-20.md diff --git a/2021 04 21.md b/2021-04-21.md similarity index 100% rename from 2021 04 21.md rename to 2021-04-21.md diff --git a/2021 04 22.md b/2021-04-22.md similarity index 100% rename from 2021 04 22.md rename to 2021-04-22.md diff --git a/2021 04 23.md b/2021-04-23.md similarity index 100% rename from 2021 04 23.md rename to 2021-04-23.md diff --git a/2021 04 24.md b/2021-04-24.md similarity index 100% rename from 2021 04 24.md rename to 2021-04-24.md diff --git a/2021 04 25.md b/2021-04-25.md similarity index 100% rename from 2021 04 25.md rename to 2021-04-25.md diff --git a/2021 04 27.md b/2021-04-27.md similarity index 100% rename from 2021 04 27.md rename to 2021-04-27.md diff --git a/2021 04 28.md b/2021-04-28.md similarity index 100% rename from 2021 04 28.md rename to 2021-04-28.md diff --git a/2021 04 29.md b/2021-04-29.md similarity index 100% rename from 2021 04 29.md rename to 2021-04-29.md diff --git a/2021 04 30.md b/2021-04-30.md similarity index 100% rename from 2021 04 30.md rename to 2021-04-30.md diff --git a/2021 05 01.md b/2021-05-01.md similarity index 100% rename from 2021 05 01.md rename to 2021-05-01.md diff --git a/2021 05 02.md b/2021-05-02.md similarity index 100% rename from 2021 05 02.md rename to 2021-05-02.md diff --git a/2021 05 03.md b/2021-05-03.md similarity index 100% rename from 2021 05 03.md rename to 2021-05-03.md diff --git a/2021 05 04.md b/2021-05-04.md similarity index 100% rename from 2021 05 04.md rename to 2021-05-04.md diff --git a/2021 05 05.md b/2021-05-05.md similarity index 100% rename from 2021 05 05.md rename to 2021-05-05.md diff --git a/2021 05 06.md b/2021-05-06.md similarity index 100% rename from 2021 05 06.md rename to 2021-05-06.md diff --git a/2021 05 07.md b/2021-05-07.md similarity index 100% rename from 2021 05 07.md rename to 2021-05-07.md