'use strict';

var obsidian = require('obsidian');
var path = require('path');
var child_process_1 = require('child_process');
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 }; }

function _interopNamespace(e) {
    if (e && e.__esModule) return e;
    var n = Object.create(null);
    if (e) {
        Object.keys(e).forEach(function (k) {
            if (k !== 'default') {
                var d = Object.getOwnPropertyDescriptor(e, k);
                Object.defineProperty(n, k, d.get ? d : {
                    enumerable: true,
                    get: function () { return e[k]; }
                });
            }
        });
    }
    n["default"] = e;
    return Object.freeze(n);
}

var path__namespace = /*#__PURE__*/_interopNamespace(path);
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, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
}

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 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 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;
}());

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.autoPullInterval);
                        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.gitManager.formatCommitMessage()];
                        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.gitManager.branchInfo()];
                    case 1:
                        branchInfo = _b.sent();
                        for (_i = 0, _a = branchInfo.branches; _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 () {
                            return __generator(this, function (_a) {
                                switch (_a.label) {
                                    case 0: return [4 /*yield*/, plugin.gitManager.checkout(option)];
                                    case 1:
                                        _a.sent();
                                        new obsidian.Notice("Checked out to " + option);
                                        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("Update submodules")
            .setDesc('"Create backup" and "pull" takes care of submodules. Missing features: Conflicted files, count of pulled/pushed/committed files. Tracking branch needs to be set for each submodule')
            .addToggle(function (toggle) {
            return toggle
                .setValue(plugin.settings.updateSubmodules)
                .onChange(function (value) {
                plugin.settings.updateSubmodules = 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();
            });
        });
        new obsidian.Setting(containerEl)
            .setName("Custom Git binary path")
            .addText(function (cb) {
            cb.setValue(plugin.settings.gitPath);
            cb.setPlaceholder("git");
            cb.onChange(function (value) {
                plugin.settings.gitPath = value;
                plugin.gitManager.updateGitPath(value || "git");
                plugin.saveSettings();
            });
        });
    };
    return ObsidianGitSettingsTab;
}(obsidian.PluginSettingTab));

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 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 GeneralModal = /** @class */ (function (_super) {
    __extends(GeneralModal, _super);
    function GeneralModal(app, remotes, placeholder) {
        var _this = _super.call(this, app) || this;
        _this.resolve = null;
        _this.list = remotes;
        _this.setPlaceholder(placeholder);
        return _this;
    }
    GeneralModal.prototype.open = function () {
        var _this = this;
        _super.prototype.open.call(this);
        return new Promise(function (resolve) {
            _this.resolve = resolve;
        });
    };
    GeneralModal.prototype.selectSuggestion = function (value, evt) {
        if (this.resolve)
            this.resolve(value);
        _super.prototype.selectSuggestion.call(this, value, evt);
    };
    GeneralModal.prototype.onClose = function () {
        if (this.resolve)
            this.resolve(undefined);
    };
    GeneralModal.prototype.getSuggestions = function (query) {
        return __spreadArray([query.length > 0 ? query : "..."], this.list);
    };
    GeneralModal.prototype.renderSuggestion = function (value, el) {
        el.innerText = value;
    };
    GeneralModal.prototype.onChooseSuggestion = function (item, _) { };
    return GeneralModal;
}(obsidian.SuggestModal));

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;

});

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<MergeSummary>) => 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;

});

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;

});

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;

});

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;

});

/**
 * 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;
		let namespacesCache;
		let enabledCache;

		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: () => {
				if (enableOverride !== null) {
					return enableOverride;
				}
				if (namespacesCache !== createDebug.namespaces) {
					namespacesCache = createDebug.namespaces;
					enabledCache = createDebug.enabled(namespace);
				}

				return enabledCache;
			},
			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.namespaces = namespaces;

		createDebug.names = [];
		createDebug.skips = [];

		let i;
		const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
		const len = split.length;

		for (i = 0; i < len; i++) {
			if (!split[i]) {
				// 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;

});

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);

});

var util = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.delay = exports.pick = 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;
/**
 * Get a new object from a source object with only the listed properties.
 */
function pick(source, properties) {
    return Object.assign({}, ...properties.map((property) => property in source ? { [property]: source[property] } : {}));
}
exports.pick = pick;
function delay(duration = 0) {
    return new Promise(done => setTimeout(done, duration));
}
exports.delay = delay;

});

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;

});

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 = {}));

});

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;

});

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;

});

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;

});

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;

});

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;

});

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);

});

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));
}

});

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;

});

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: 'empty',
        parser,
    };
}
exports.adhocExecTask = adhocExecTask;
function configurationErrorTask(error) {
    return {
        commands: exports.EMPTY_COMMANDS,
        format: 'empty',
        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.format === 'empty' || !task.commands.length;
}
exports.isEmptyTask = isEmptyTask;

});

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';
}

});

var ConfigList_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.configGetParser = 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();
    for (const item of configParser(text)) {
        config.addValue(item.file, String(item.key), item.value);
    }
    return config;
}
exports.configListParser = configListParser;
function configGetParser(text, key) {
    let value = null;
    const values = [];
    const scopes = new Map();
    for (const item of configParser(text, key)) {
        if (item.key !== key) {
            continue;
        }
        values.push(value = item.value);
        if (!scopes.has(item.file)) {
            scopes.set(item.file, []);
        }
        scopes.get(item.file).push(value);
    }
    return {
        key,
        paths: Array.from(scopes.keys()),
        scopes,
        value,
        values
    };
}
exports.configGetParser = configGetParser;
function configFilePath(filePath) {
    return filePath.replace(/^(file):/, '');
}
function* configParser(text, requestedKey = null) {
    const lines = text.split('\0');
    for (let i = 0, max = lines.length - 1; i < max;) {
        const file = configFilePath(lines[i++]);
        let value = lines[i++];
        let key = requestedKey;
        if (value.includes('\n')) {
            const line = utils.splitOn(value, '\n');
            key = line[0];
            value = line[1];
        }
        yield { file, key, value };
    }
}

});

var config = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.GitConfigScope = void 0;


var GitConfigScope;
(function (GitConfigScope) {
    GitConfigScope["system"] = "system";
    GitConfigScope["global"] = "global";
    GitConfigScope["local"] = "local";
    GitConfigScope["worktree"] = "worktree";
})(GitConfigScope = exports.GitConfigScope || (exports.GitConfigScope = {}));
function asConfigScope(scope, fallback) {
    if (typeof scope === 'string' && GitConfigScope.hasOwnProperty(scope)) {
        return scope;
    }
    return fallback;
}
function addConfigTask(key, value, append, scope) {
    const commands = ['config', `--${scope}`];
    if (append) {
        commands.push('--add');
    }
    commands.push(key, value);
    return {
        commands,
        format: 'utf-8',
        parser(text) {
            return text;
        }
    };
}
function getConfigTask(key, scope) {
    const commands = ['config', '--null', '--show-origin', '--get-all', key];
    if (scope) {
        commands.splice(1, 0, `--${scope}`);
    }
    return {
        commands,
        format: 'utf-8',
        parser(text) {
            return ConfigList_1.configGetParser(text, key);
        }
    };
}
function listConfigTask(scope) {
    const commands = ['config', '--list', '--show-origin', '--null'];
    if (scope) {
        commands.push(`--${scope}`);
    }
    return {
        commands,
        format: 'utf-8',
        parser(text) {
            return ConfigList_1.configListParser(text);
        },
    };
}
function default_1() {
    return {
        addConfig(key, value, ...rest) {
            return this._runTask(addConfigTask(key, value, rest[0] === true, asConfigScope(rest[1], GitConfigScope.local)), utils.trailingFunctionArgument(arguments));
        },
        getConfig(key, scope) {
            return this._runTask(getConfigTask(key, asConfigScope(scope, undefined)), utils.trailingFunctionArgument(arguments));
        },
        listConfig(...rest) {
            return this._runTask(listConfigTask(asConfigScope(rest[0], undefined)), utils.trailingFunctionArgument(arguments));
        },
    };
}
exports.default = default_1;

});

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);
}

});

var api_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });









const api = {
    CheckRepoActions: checkIsRepo.CheckRepoActions,
    CleanOptions: clean.CleanOptions,
    GitConfigScope: config.GitConfigScope,
    GitConstructError: gitConstructError.GitConstructError,
    GitError: gitError.GitError,
    GitPluginError: gitPluginError.GitPluginError,
    GitResponseError: gitResponseError.GitResponseError,
    ResetMode: reset.ResetMode,
    TaskConfigurationError: taskConfigurationError.TaskConfigurationError,
};
exports.default = api;

});

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;

});

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;

});

var completionDetection_plugin = 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.completionDetectionPlugin = void 0;


const never = dist.default().promise;
function completionDetectionPlugin({ onClose = true, onExit = 50 } = {}) {
    function createEvents() {
        let exitCode = -1;
        const events = {
            close: dist.default(),
            closeTimeout: dist.default(),
            exit: dist.default(),
            exitTimeout: dist.default(),
        };
        const result = Promise.race([
            onClose === false ? never : events.closeTimeout.promise,
            onExit === false ? never : events.exitTimeout.promise,
        ]);
        configureTimeout(onClose, events.close, events.closeTimeout);
        configureTimeout(onExit, events.exit, events.exitTimeout);
        return {
            close(code) {
                exitCode = code;
                events.close.done();
            },
            exit(code) {
                exitCode = code;
                events.exit.done();
            },
            get exitCode() {
                return exitCode;
            },
            result,
        };
    }
    function configureTimeout(flag, event, timeout) {
        if (flag === false) {
            return;
        }
        (flag === true ? event.promise : event.promise.then(() => utils.delay(flag))).then(timeout.done);
    }
    return {
        type: 'spawn.after',
        action(_data, { spawned, close }) {
            var _a, _b;
            return __awaiter(this, void 0, void 0, function* () {
                const events = createEvents();
                let deferClose = true;
                let quickClose = () => void (deferClose = false);
                (_a = spawned.stdout) === null || _a === void 0 ? void 0 : _a.on('data', quickClose);
                (_b = spawned.stderr) === null || _b === void 0 ? void 0 : _b.on('data', quickClose);
                spawned.on('error', quickClose);
                spawned.on('close', (code) => events.close(code));
                spawned.on('exit', (code) => events.exit(code));
                try {
                    yield events.result;
                    if (deferClose) {
                        yield utils.delay(50);
                    }
                    close(events.exitCode);
                }
                catch (err) {
                    close(events.exitCode, err);
                }
            });
        }
    };
}
exports.completionDetectionPlugin = completionDetectionPlugin;

});

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;

});

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;

});

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 = /^([\s\S]+?):\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';
}

});

var simpleGitPlugin = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

});

var spawnOptionsPlugin_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.spawnOptionsPlugin = void 0;

function spawnOptionsPlugin(spawnOptions) {
    const options = utils.pick(spawnOptions, ['uid', 'gid']);
    return {
        type: 'spawn.options',
        action(data) {
            return Object.assign(Object.assign({}, options), data);
        },
    };
}
exports.spawnOptionsPlugin = spawnOptionsPlugin;

});

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;

});

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(completionDetection_plugin, exports);
__exportStar(errorDetection_plugin, exports);
__exportStar(pluginStore, exports);
__exportStar(progressMonitorPlugin_1, exports);
__exportStar(simpleGitPlugin, exports);
__exportStar(spawnOptionsPlugin_1, exports);
__exportStar(timoutPlugin, exports);

});

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;

});

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;

});

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._cwd || this._executor.cwd;
    }
    set cwd(cwd) {
        this._cwd = cwd;
    }
    get env() {
        return this._executor.env;
    }
    get outputHandler() {
        return this._executor.outputHandler;
    }
    chain() {
        return this;
    }
    push(task) {
        this._queue.push(task);
        return this._chain = this._chain.then(() => this.attemptTask(task));
    }
    attemptTask(task$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(this);
        });
    }
    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 = this._plugins.exec('spawn.options', {
                cwd: this.cwd,
                env: this.env,
                windowsHide: true,
            }, pluginContext(task, task.commands));
            return new Promise((done) => {
                const stdOut = [];
                const stdErr = [];
                let rejection;
                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));
                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, close(exitCode, reason) {
                        done({
                            stdOut,
                            stdErr,
                            exitCode,
                            rejection: rejection || reason,
                        });
                    },
                    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);
    };
}

});

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;

});

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) {
            callback((err instanceof gitResponseError.GitResponseError) ? addDeprecationNoticeToError(err) : err, undefined);
        }
    };
    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;
    }
}

});

var changeWorkingDirectory = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.changeWorkingDirectoryTask = void 0;


function changeWorkingDirectoryTask(directory, root) {
    return task.adhocExecTask((instance) => {
        if (!utils.folderExists(directory)) {
            throw new Error(`Git.cwd: cannot change to non-directory "${directory}"`);
        }
        return ((root || instance).cwd = directory);
    });
}
exports.changeWorkingDirectoryTask = changeWorkingDirectoryTask;

});

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;

});

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;

});

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;

});

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;

});

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;
}

});

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;

});

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["mailMap"] = 10] = "mailMap";
    excludeOptions[excludeOptions["multiLine"] = 11] = "multiLine";
    excludeOptions[excludeOptions["strictDate"] = 12] = "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: opt.mailMap !== false ? '%aN' : '%an',
        author_email: opt.mailMap !== false ? '%aE' : '%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;
function default_1() {
    return {
        log(...rest) {
            const next = utils.trailingFunctionArgument(arguments);
            const task = rejectDeprecatedSignatures(...rest) ||
                createLogTask(parseLogOptions(utils.trailingOptionsArgument(arguments), utils.filterType(arguments[0], utils.filterArray)));
            return this._runTask(task, next);
        }
    };
    function createLogTask(options) {
        return logTask(options.splitter, options.fields, options.commands);
    }
    function rejectDeprecatedSignatures(from, to) {
        return (utils.filterString(from) &&
            utils.filterString(to) &&
            task.configurationErrorTask(`git.log(string, string) should be replaced with git.log({ from: string, to: string })`));
    }
}
exports.default = default_1;

});

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;

});

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;

});

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);
    }),
];

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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));
        }
    }
}

});

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;

});

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));
    }
    cwd(directory) {
        const next = utils.trailingFunctionArgument(arguments);
        if (typeof directory === 'string') {
            return this._runTask(changeWorkingDirectory.changeWorkingDirectoryTask(directory, this._executor), next);
        }
        if (typeof (directory === null || directory === void 0 ? void 0 : directory.path) === 'string') {
            return this._runTask(changeWorkingDirectory.changeWorkingDirectoryTask(directory.path, directory.root && this._executor || undefined), next);
        }
        return this._runTask(task.configurationErrorTask('Git.cwd: workingDirectory must be supplied as a string'), next);
    }
    hashObject(path, write) {
        return this._runTask(hashObject.hashObjectTask(path, write === true), utils.trailingFunctionArgument(arguments));
    }
    init(bare) {
        return this._runTask(init.initTask(bare === true, this._executor.cwd, utils.getTrailingOptions(arguments)), utils.trailingFunctionArgument(arguments));
    }
    merge() {
        return this._runTask(merge.mergeTask(utils.getTrailingOptions(arguments)), utils.trailingFunctionArgument(arguments));
    }
    mergeFromTo(remote, branch) {
        if (!(utils.filterString(remote) && utils.filterString(branch))) {
            return this._runTask(task.configurationErrorTask(`Git.mergeFromTo requires that the 'remote' and 'branch' arguments are supplied as strings`));
        }
        return this._runTask(merge.mergeTask([remote, branch, ...utils.getTrailingOptions(arguments)]), utils.trailingFunctionArgument(arguments, false));
    }
    outputHandler(handler) {
        this._executor.outputHandler = handler;
        return this;
    }
    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));
    }
    stash() {
        return this._runTask(task.straightThroughStringTask(['stash', ...utils.getTrailingOptions(arguments)]), utils.trailingFunctionArgument(arguments));
    }
    status() {
        return this._runTask(status.statusTask(utils.getTrailingOptions(arguments)), utils.trailingFunctionArgument(arguments));
    }
}
exports.SimpleGitApi = SimpleGitApi;
Object.assign(SimpleGitApi.prototype, config.default(), log.default());

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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;

});

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+/)));
}

});

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;

});

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;

});

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;

});

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;
}

});

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;

});

const {GitExecutor} = gitExecutor;
const {SimpleGitApi} = simpleGitApi;

const {Scheduler} = scheduler;
const {GitLogger} = gitLogger;
const {configurationErrorTask} = task;
const {
   asArray,
   filterArray,
   filterPrimitives,
   filterString,
   filterStringOrStringArray,
   filterType,
   getTrailingOptions,
   trailingFunctionArgument,
   trailingOptionsArgument
} = utils;
const {applyPatchTask} = applyPatch;
const {branchTask, branchLocalTask, deleteBranchesTask, deleteBranchTask} = branch;
const {checkIgnoreTask} = checkIgnore;
const {checkIsRepoTask} = checkIsRepo;
const {cloneTask, cloneMirrorTask} = clone;
const {cleanWithOptionsTask, isCleanOptionsArray} = clean;
const {commitTask} = commit;
const {diffSummaryTask} = diff;
const {fetchTask} = fetch;
const {moveTask} = move;
const {pullTask} = pull;
const {pushTagsTask} = push;
const {addRemoteTask, getRemotesTask, listRemotesTask, remoteTask, removeRemoteTask} = remote;
const {getResetMode, resetTask} = reset;
const {stashListTask} = stashList;
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;
};

/**
 * List the stash(s) of the local repo
 */
Git.prototype.stashList = function (options) {
   return this._runTask(
      stashListTask(
         trailingOptionsArgument(arguments) || {},
         filterArray(options) && options || []
      ),
      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),
   );
};

/**
 * 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),
   );
};

/**
 * 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),
   );
};

/**
 * 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),
   );
};

Git.prototype.exec = function (then) {
   const task = {
      commands: [],
      format: 'utf-8',
      parser () {
         if (typeof then === 'function') {
            then();
         }
      }
   };

   return this._runTask(task);
};

/**
 * 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));
    }
    plugins$1.add(plugins.completionDetectionPlugin(config.completion));
    config.progress && plugins$1.add(plugins.progressMonitorPlugin(config.progress));
    config.timeout && plugins$1.add(plugins.timeoutPlugin(config.timeout));
    config.spawnOptions && plugins$1.add(plugins.spawnOptionsPlugin(config.spawnOptions));
    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;

});

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);
}

});

const {gitP} = promiseWrapped;
const {esModuleFactory, gitInstanceFactory, gitExportFactory} = gitFactory;

var src = esModuleFactory(
   gitExportFactory(gitInstanceFactory, {gitP})
);

var GitManager = /** @class */ (function () {
    function GitManager(plugin) {
        this.plugin = plugin;
        this.app = plugin.app;
    }
    GitManager.prototype.formatCommitMessage = function () {
        return __awaiter(this, void 0, void 0, function () {
            var template, status_1, numFiles, status_2, changeset_1, chunks, _i, _a, _b, action, files_1, files, moment, _c;
            return __generator(this, function (_d) {
                switch (_d.label) {
                    case 0:
                        template = this.plugin.settings.commitMessage;
                        if (!template.includes("{{numFiles}}")) return [3 /*break*/, 2];
                        return [4 /*yield*/, this.status()];
                    case 1:
                        status_1 = _d.sent();
                        numFiles = status_1.changed.length;
                        template = template.replace("{{numFiles}}", String(numFiles));
                        _d.label = 2;
                    case 2:
                        if (!template.includes("{{files}}")) return [3 /*break*/, 4];
                        return [4 /*yield*/, this.status()];
                    case 3:
                        status_2 = _d.sent();
                        changeset_1 = {};
                        status_2.changed.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);
                        _d.label = 4;
                    case 4:
                        moment = window.moment;
                        template = template.replace("{{date}}", moment().format(this.plugin.settings.commitDateFormat));
                        if (!this.plugin.settings.listChangedFilesInMessageBody) return [3 /*break*/, 6];
                        _c = template + "\n\n" + "Affected files:" + "\n";
                        return [4 /*yield*/, this.status()];
                    case 5:
                        template = _c + (_d.sent()).staged.join("\n");
                        _d.label = 6;
                    case 6: return [2 /*return*/, template];
                }
            });
        });
    };
    return GitManager;
}());

var SimpleGit = /** @class */ (function (_super) {
    __extends(SimpleGit, _super);
    function SimpleGit(plugin) {
        var _this = _super.call(this, plugin) || this;
        var adapter = _this.app.vault.adapter;
        var path = adapter.getBasePath();
        if (_this.isGitInstalled()) {
            _this.git = src({
                baseDir: path,
                binary: _this.plugin.settings.gitPath || undefined,
            });
        }
        return _this;
    }
    SimpleGit.prototype.status = function () {
        return __awaiter(this, void 0, void 0, function () {
            var status;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.plugin.setState(PluginState.status);
                        return [4 /*yield*/, this.git.status()];
                    case 1:
                        status = _a.sent();
                        return [2 /*return*/, {
                                changed: status.files.map(function (e) {
                                    e.path = _this.fixFilePath(e.path);
                                    return e;
                                }),
                                staged: status.staged.map(this.fixFilePath),
                                conflicted: status.conflicted.map(this.fixFilePath),
                            }];
                }
            });
        });
    };
    //Remove wrong `"` like "My file.md"
    SimpleGit.prototype.fixFilePath = function (path) {
        path.startsWith('"') && path.endsWith('"') &&
            (path = path.substring(1, path.length - 1));
        return path;
    };
    SimpleGit.prototype.commitAll = function (message) {
        return __awaiter(this, void 0, void 0, function () {
            var _a, _b, _c, _d, _e, _f, _g, _h;
            var _this = this;
            return __generator(this, function (_j) {
                switch (_j.label) {
                    case 0:
                        if (!this.plugin.settings.updateSubmodules) return [3 /*break*/, 5];
                        this.plugin.setState(PluginState.commit);
                        _b = (_a = this.git).subModule;
                        _c = ["foreach", "--recursive"];
                        _d = "git add -A && if [ ! -z \"$(git status --porcelain)\" ]; then git commit -m \"";
                        if (!(message !== null && message !== void 0)) return [3 /*break*/, 1];
                        _e = message;
                        return [3 /*break*/, 3];
                    case 1: return [4 /*yield*/, this.formatCommitMessage()];
                    case 2:
                        _e = _j.sent();
                        _j.label = 3;
                    case 3: return [4 /*yield*/, _b.apply(_a, [_c.concat([_d + (_e) + "\"; fi"]), function (err) { return _this.onError(err); }])];
                    case 4:
                        _j.sent();
                        _j.label = 5;
                    case 5:
                        this.plugin.setState(PluginState.add);
                        return [4 /*yield*/, this.git.add("./*", function (err) { return _this.onError(err); })];
                    case 6:
                        _j.sent();
                        this.plugin.setState(PluginState.commit);
                        _g = (_f = this.git).commit;
                        if (!(message !== null && message !== void 0)) return [3 /*break*/, 7];
                        _h = message;
                        return [3 /*break*/, 9];
                    case 7: return [4 /*yield*/, this.formatCommitMessage()];
                    case 8:
                        _h = _j.sent();
                        _j.label = 9;
                    case 9: return [4 /*yield*/, _g.apply(_f, [_h])];
                    case 10: return [2 /*return*/, (_j.sent()).summary.changes];
                }
            });
        });
    };
    SimpleGit.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.plugin.setState(PluginState.pull);
                        if (!this.plugin.settings.updateSubmodules) return [3 /*break*/, 2];
                        return [4 /*yield*/, this.git.subModule(["update", "--remote", "--merge", "--recursive"], function (err) { return _this.onError(err); })];
                    case 1:
                        _a.sent();
                        _a.label = 2;
                    case 2: 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.plugin.displayError("Pull failed " + err.message);
                                        return [4 /*yield*/, this.git.status()];
                                    case 1:
                                        status_1 = _a.sent();
                                        if (status_1.conflicted.length > 0) {
                                            this.plugin.handleConflict(status_1.conflicted);
                                        }
                                        _a.label = 2;
                                    case 2: return [2 /*return*/];
                                }
                            });
                        }); })];
                    case 3:
                        pullResult = _a.sent();
                        return [2 /*return*/, pullResult.files.length];
                }
            });
        });
    };
    SimpleGit.prototype.push = function () {
        return __awaiter(this, void 0, void 0, function () {
            var status, trackingBranch, currentBranch, remoteChangedFiles;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.plugin.setState(PluginState.status);
                        return [4 /*yield*/, this.git.status()];
                    case 1:
                        status = _a.sent();
                        trackingBranch = status.tracking;
                        currentBranch = status.current;
                        return [4 /*yield*/, this.git.diffSummary([currentBranch, trackingBranch])];
                    case 2:
                        remoteChangedFiles = (_a.sent()).changed;
                        this.plugin.setState(PluginState.push);
                        if (!this.plugin.settings.updateSubmodules) return [3 /*break*/, 4];
                        return [4 /*yield*/, this.git.env(__assign(__assign({}, process.env), { "OBSIDIAN_GIT": 1 })).subModule(["foreach", "--recursive", "tracking=$(git for-each-ref --format='%(upstream:short)' \"$(git symbolic-ref -q HEAD)\"); echo $tracking; if [ ! -z \"$(git diff --shortstat $tracking)\" ]; then git push; fi"], function (err) { return _this.onError(err); })];
                    case 3:
                        _a.sent();
                        _a.label = 4;
                    case 4: return [4 /*yield*/, this.git.env(__assign(__assign({}, process.env), { "OBSIDIAN_GIT": 1 })).push(function (err) { return _this.onError(err); })];
                    case 5:
                        _a.sent();
                        return [2 /*return*/, remoteChangedFiles];
                }
            });
        });
    };
    SimpleGit.prototype.canPush = function () {
        return __awaiter(this, void 0, void 0, function () {
            var status, trackingBranch, currentBranch, remoteChangedFiles;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        // allow pushing in submodules even if the root has no changes.
                        if (this.plugin.settings.updateSubmodules === true) {
                            return [2 /*return*/, true];
                        }
                        return [4 /*yield*/, this.git.status(function (err) { return _this.onError(err); })];
                    case 1:
                        status = _a.sent();
                        trackingBranch = status.tracking;
                        currentBranch = status.current;
                        return [4 /*yield*/, this.git.diffSummary([currentBranch, trackingBranch])];
                    case 2:
                        remoteChangedFiles = (_a.sent()).changed;
                        return [2 /*return*/, remoteChangedFiles !== 0];
                }
            });
        });
    };
    SimpleGit.prototype.checkRequirements = function () {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        if (!this.isGitInstalled()) {
                            return [2 /*return*/, "missing-git"];
                        }
                        return [4 /*yield*/, this.git.checkIsRepo()];
                    case 1:
                        if (!(_a.sent())) {
                            return [2 /*return*/, "missing-repo"];
                        }
                        return [2 /*return*/, "valid"];
                }
            });
        });
    };
    SimpleGit.prototype.branchInfo = function () {
        return __awaiter(this, void 0, void 0, function () {
            var status, branches;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.git.status(function (err) { return _this.onError(err); })];
                    case 1:
                        status = _a.sent();
                        return [4 /*yield*/, this.git.branch(["--no-color"], function (err) { return _this.onError(err); })];
                    case 2:
                        branches = _a.sent();
                        return [2 /*return*/, {
                                current: status.current,
                                tracking: status.tracking,
                                branches: branches.all,
                            }];
                }
            });
        });
    };
    SimpleGit.prototype.checkout = function (branch) {
        return __awaiter(this, void 0, void 0, function () {
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.git.checkout(branch, function (err) { return _this.onError(err); })];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    SimpleGit.prototype.init = function () {
        return __awaiter(this, void 0, void 0, function () {
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.git.init(false, function (err) { return _this.onError(err); })];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    SimpleGit.prototype.clone = function (url, dir) {
        return __awaiter(this, void 0, void 0, function () {
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.git.clone(url, path__namespace.join(this.app.vault.adapter.getBasePath(), dir), [], function (err) { return _this.onError(err); })];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    SimpleGit.prototype.setConfig = function (path, value) {
        return __awaiter(this, void 0, void 0, function () {
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.git.addConfig(path, value, function (err) { return _this.onError(err); })];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    SimpleGit.prototype.getConfig = function (path) {
        return __awaiter(this, void 0, void 0, function () {
            var config;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.git.listConfig(function (err) { return _this.onError(err); })];
                    case 1:
                        config = _a.sent();
                        return [2 /*return*/, config.all[path]];
                }
            });
        });
    };
    SimpleGit.prototype.fetch = function (remote) {
        return __awaiter(this, void 0, void 0, function () {
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.git.fetch(remote != undefined ? [remote] : [], function (err) { return _this.onError(err); })];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    SimpleGit.prototype.setRemote = function (name, url) {
        return __awaiter(this, void 0, void 0, function () {
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.getRemotes()];
                    case 1:
                        if (!(_a.sent()).includes(name)) return [3 /*break*/, 3];
                        return [4 /*yield*/, this.git.remote(["set-url", name, url], function (err) { return _this.onError(err); })];
                    case 2:
                        _a.sent();
                        return [3 /*break*/, 5];
                    case 3: return [4 /*yield*/, this.git.remote(["add", name, url], function (err) { return _this.onError(err); })];
                    case 4:
                        _a.sent();
                        _a.label = 5;
                    case 5: return [2 /*return*/];
                }
            });
        });
    };
    SimpleGit.prototype.getRemoteBranches = function (remote) {
        return __awaiter(this, void 0, void 0, function () {
            var res, list, item;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.git.branch(["-r", "--list", remote + "*"], function (err) { return _this.onError(err); })];
                    case 1:
                        res = _a.sent();
                        list = [];
                        for (item in res.branches) {
                            list.push(res.branches[item].name);
                        }
                        return [2 /*return*/, list];
                }
            });
        });
    };
    SimpleGit.prototype.getRemotes = function () {
        return __awaiter(this, void 0, void 0, function () {
            var res;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.git.remote([], function (err) { return _this.onError(err); })];
                    case 1:
                        res = _a.sent();
                        if (res) {
                            return [2 /*return*/, res.trim().split("\n")];
                        }
                        else {
                            return [2 /*return*/, []];
                        }
                }
            });
        });
    };
    SimpleGit.prototype.removeRemote = function (remoteName) {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.git.removeRemote(remoteName)];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    SimpleGit.prototype.updateUpstreamBranch = function (remoteBranch) {
        return __awaiter(this, void 0, void 0, function () {
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.git.push(__spreadArray(["--set-upstream"], remoteBranch.split("/")), function (err) { return _this.onError(err); })];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    SimpleGit.prototype.updateGitPath = function (gitPath) {
        return this.git.customBinary(gitPath);
    };
    SimpleGit.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;
    };
    SimpleGit.prototype.onError = function (error) {
        if (error) {
            this.plugin.displayError(error.message);
        }
    };
    return SimpleGit;
}(GitManager));

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,
    updateSubmodules: false,
    gitPath: ""
};
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;
    }
    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: "Create backup",
                            callback: function () { return _this.promiseQueue.addTask(function () { return _this.createBackup(false); }); }
                        });
                        this.addCommand({
                            id: "edit-remotes",
                            name: "Edit remotes",
                            callback: function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
                                return [2 /*return*/, this.editRemotes()];
                            }); }); }
                        });
                        this.addCommand({
                            id: "remove-remote",
                            name: "Remove remote",
                            callback: function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
                                return [2 /*return*/, this.removeRemote()];
                            }); }); }
                        });
                        this.addCommand({
                            id: "init-repo",
                            name: "Initialize a new repo",
                            callback: function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
                                return [2 /*return*/, this.createNewRepo()];
                            }); }); }
                        });
                        this.addCommand({
                            id: "clone-repo",
                            name: "Clone an existing remote repo",
                            callback: function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
                                return [2 /*return*/, this.cloneNewRepo()];
                            }); }); }
                        });
                        this.addCommand({
                            id: "commit-push-specified-message",
                            name: "Create backup 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.gitManager.status()];
                                        case 1:
                                            status = _a.sent();
                                            this.setState(PluginState.idle);
                                            new ChangedFilesModal(this, status.changed).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.app.workspace.onLayoutReady(function () { return _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.saveLastAuto = function (date, mode) {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                if (mode === "backup") {
                    window.localStorage.setItem(this.manifest.id + ":lastAutoBackup", date.toString());
                }
                else if (mode === "pull") {
                    window.localStorage.setItem(this.manifest.id + ":lastAutoPull", date.toString());
                }
                return [2 /*return*/];
            });
        });
    };
    ObsidianGit.prototype.loadLastAuto = function () {
        var _a, _b;
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_c) {
                return [2 /*return*/, {
                        "backup": new Date((_a = window.localStorage.getItem(this.manifest.id + ":lastAutoBackup")) !== null && _a !== void 0 ? _a : ""),
                        "pull": new Date((_b = window.localStorage.getItem(this.manifest.id + ":lastAutoPull")) !== null && _b !== void 0 ? _b : "")
                    }];
            });
        });
    };
    ObsidianGit.prototype.init = function () {
        return __awaiter(this, void 0, void 0, function () {
            var result, _a, lastAutos, now, diff, now, diff, error_1;
            var _this = this;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        _b.trys.push([0, 8, , 9]);
                        this.gitManager = new SimpleGit(this);
                        return [4 /*yield*/, this.gitManager.checkRequirements()];
                    case 1:
                        result = _b.sent();
                        _a = result;
                        switch (_a) {
                            case "missing-git": return [3 /*break*/, 2];
                            case "missing-repo": return [3 /*break*/, 3];
                            case "valid": return [3 /*break*/, 4];
                        }
                        return [3 /*break*/, 6];
                    case 2:
                        this.displayError("Cannot run git command");
                        return [3 /*break*/, 7];
                    case 3:
                        new obsidian.Notice("Can't find a valid git repository. Please create one via the given command.");
                        return [3 /*break*/, 7];
                    case 4:
                        this.gitReady = true;
                        this.setState(PluginState.idle);
                        if (this.settings.autoPullOnBoot) {
                            this.promiseQueue.addTask(function () { return _this.pullChangesFromRemote(); });
                        }
                        return [4 /*yield*/, this.loadLastAuto()];
                    case 5:
                        lastAutos = _b.sent();
                        if (this.settings.autoSaveInterval > 0) {
                            now = new Date();
                            diff = this.settings.autoSaveInterval - (Math.round(((now.getTime() - lastAutos.backup.getTime()) / 1000) / 60));
                            this.startAutoBackup(diff <= 0 ? 0 : diff);
                        }
                        if (this.settings.autoPullInterval > 0) {
                            now = new Date();
                            diff = this.settings.autoPullInterval - (Math.round(((now.getTime() - lastAutos.pull.getTime()) / 1000) / 60));
                            this.startAutoPull(diff <= 0 ? 0 : diff);
                        }
                        return [3 /*break*/, 7];
                    case 6:
                        console.log("Something weird happened. The 'checkRequirements' result is " + result);
                        _b.label = 7;
                    case 7: return [3 /*break*/, 9];
                    case 8:
                        error_1 = _b.sent();
                        this.displayError(error_1);
                        console.error(error_1);
                        return [3 /*break*/, 9];
                    case 9: return [2 /*return*/];
                }
            });
        });
    };
    ObsidianGit.prototype.createNewRepo = function () {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.gitManager.init()];
                    case 1:
                        _a.sent();
                        new obsidian.Notice("Initialized new repo");
                        return [2 /*return*/];
                }
            });
        });
    };
    ObsidianGit.prototype.cloneNewRepo = function () {
        return __awaiter(this, void 0, void 0, function () {
            var modal, url, dir;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        modal = new GeneralModal(this.app, [], "Enter remote URL");
                        return [4 /*yield*/, modal.open()];
                    case 1:
                        url = _a.sent();
                        if (!url) return [3 /*break*/, 4];
                        return [4 /*yield*/, new GeneralModal(this.app, [], "Enter directory for clone. It needs to be empty or not existent.").open()];
                    case 2:
                        dir = _a.sent();
                        if (!dir) return [3 /*break*/, 4];
                        dir = path__namespace.normalize(dir);
                        new obsidian.Notice("Cloning new repo into \"" + dir + "\"");
                        return [4 /*yield*/, this.gitManager.clone(url, dir)];
                    case 3:
                        _a.sent();
                        new obsidian.Notice("Cloned new repo");
                        _a.label = 4;
                    case 4: return [2 /*return*/];
                }
            });
        });
    };
    /**
     * Retries to call `this.init()` if necessary, otherwise returns directly
     * @returns true if `this.gitManager` is ready to be used, false if not.
     */
    ObsidianGit.prototype.isAllInitialized = function () {
        return __awaiter(this, void 0, void 0, function () {
            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: return [2 /*return*/, this.gitReady];
                }
            });
        });
    };
    ObsidianGit.prototype.pullChangesFromRemote = function () {
        return __awaiter(this, void 0, void 0, function () {
            var filesUpdated, status_1;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.isAllInitialized()];
                    case 1:
                        if (!(_a.sent()))
                            return [2 /*return*/];
                        return [4 /*yield*/, this.gitManager.pull()];
                    case 2:
                        filesUpdated = _a.sent();
                        if (filesUpdated > 0) {
                            this.displayMessage("Pulled new changes. " + filesUpdated + " files updated");
                        }
                        else {
                            this.displayMessage("Everything is up-to-date");
                        }
                        if (!(this.gitManager instanceof SimpleGit)) return [3 /*break*/, 4];
                        return [4 /*yield*/, this.gitManager.status()];
                    case 3:
                        status_1 = _a.sent();
                        if (status_1.conflicted.length > 0) {
                            this.displayError("You have " + status_1.conflicted.length + " conflict files");
                        }
                        _a.label = 4;
                    case 4:
                        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 file, status_2, changedFiles, commitedFiles, remoteBranch, pulledFilesLength, status_3, _a, pushedFiles;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0: return [4 /*yield*/, this.isAllInitialized()];
                    case 1:
                        if (!(_b.sent()))
                            return [2 /*return*/];
                        if (!!fromAutoBackup) return [3 /*break*/, 3];
                        file = this.app.vault.getAbstractFileByPath(this.conflictOutputFile);
                        return [4 /*yield*/, this.app.vault.delete(file)];
                    case 2:
                        _b.sent();
                        _b.label = 3;
                    case 3:
                        if (!(this.gitManager instanceof SimpleGit)) return [3 /*break*/, 5];
                        return [4 /*yield*/, this.gitManager.status()];
                    case 4:
                        status_2 = _b.sent();
                        // check for conflict files on auto backup
                        if (fromAutoBackup && status_2.conflicted.length > 0) {
                            this.setState(PluginState.idle);
                            this.displayError("Did not commit, because you have " + status_2.conflicted.length + " conflict files. Please resolve them and commit per command.");
                            this.handleConflict(status_2.conflicted);
                            return [2 /*return*/];
                        }
                        _b.label = 5;
                    case 5: return [4 /*yield*/, this.gitManager.status()];
                    case 6:
                        changedFiles = (_b.sent()).changed;
                        if (!(changedFiles.length !== 0)) return [3 /*break*/, 8];
                        return [4 /*yield*/, this.gitManager.commitAll(commitMessage)];
                    case 7:
                        commitedFiles = _b.sent();
                        this.displayMessage("Committed " + commitedFiles + " files");
                        return [3 /*break*/, 9];
                    case 8:
                        this.displayMessage("No changes to commit");
                        _b.label = 9;
                    case 9:
                        if (!!this.settings.disablePush) return [3 /*break*/, 24];
                        return [4 /*yield*/, this.gitManager.branchInfo()];
                    case 10:
                        if (!!(_b.sent()).tracking) return [3 /*break*/, 14];
                        new obsidian.Notice("No upstream branch is set. Please select one.");
                        return [4 /*yield*/, this.selectRemoteBranch()];
                    case 11:
                        remoteBranch = _b.sent();
                        if (!(remoteBranch == undefined)) return [3 /*break*/, 12];
                        this.displayError("Did not push. No upstream-branch is set!", 10000);
                        this.setState(PluginState.idle);
                        return [2 /*return*/];
                    case 12: return [4 /*yield*/, this.gitManager.updateUpstreamBranch(remoteBranch)];
                    case 13:
                        _b.sent();
                        _b.label = 14;
                    case 14: return [4 /*yield*/, this.gitManager.canPush()];
                    case 15:
                        if (!_b.sent()) return [3 /*break*/, 23];
                        if (!this.settings.pullBeforePush) return [3 /*break*/, 17];
                        return [4 /*yield*/, this.gitManager.pull()];
                    case 16:
                        pulledFilesLength = _b.sent();
                        if (pulledFilesLength > 0) {
                            this.displayMessage("Pulled " + pulledFilesLength + " files from remote");
                        }
                        _b.label = 17;
                    case 17:
                        _a = this.gitManager instanceof SimpleGit;
                        if (!_a) return [3 /*break*/, 19];
                        return [4 /*yield*/, this.gitManager.status()];
                    case 18:
                        _a = (status_3 = _b.sent()).conflicted.length > 0;
                        _b.label = 19;
                    case 19:
                        if (!_a) return [3 /*break*/, 20];
                        this.displayError("Cannot push. You have " + status_3.conflicted.length + " conflict files");
                        this.handleConflict(status_3.conflicted);
                        return [2 /*return*/];
                    case 20: return [4 /*yield*/, this.gitManager.push()];
                    case 21:
                        pushedFiles = _b.sent();
                        this.lastUpdate = Date.now();
                        this.displayMessage("Pushed " + pushedFiles + " files to remote");
                        _b.label = 22;
                    case 22: return [3 /*break*/, 24];
                    case 23:
                        this.displayMessage("No changes to push");
                        _b.label = 24;
                    case 24:
                        this.setState(PluginState.idle);
                        return [2 /*return*/];
                }
            });
        });
    };
    ObsidianGit.prototype.startAutoBackup = function (minutes) {
        var _this = this;
        this.timeoutIDBackup = window.setTimeout(function () {
            _this.promiseQueue.addTask(function () { return _this.createBackup(true); });
            _this.saveLastAuto(new Date(), "backup");
            _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.saveLastAuto(new Date(), "pull");
            _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.editRemotes = function () {
        return __awaiter(this, void 0, void 0, function () {
            var remotes, nameModal, remoteName, urlModal, remoteURL;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.isAllInitialized()];
                    case 1:
                        if (!(_a.sent()))
                            return [2 /*return*/];
                        return [4 /*yield*/, this.gitManager.getRemotes()];
                    case 2:
                        remotes = _a.sent();
                        nameModal = new GeneralModal(this.app, remotes, "Select or create a new remote by typing its name and selecting it");
                        return [4 /*yield*/, nameModal.open()];
                    case 3:
                        remoteName = _a.sent();
                        if (!remoteName) return [3 /*break*/, 6];
                        urlModal = new GeneralModal(this.app, [], "Enter the remote URL");
                        return [4 /*yield*/, urlModal.open()];
                    case 4:
                        remoteURL = _a.sent();
                        return [4 /*yield*/, this.gitManager.setRemote(remoteName, remoteURL)];
                    case 5:
                        _a.sent();
                        return [2 /*return*/, remoteName];
                    case 6: return [2 /*return*/];
                }
            });
        });
    };
    ObsidianGit.prototype.selectRemoteBranch = function () {
        return __awaiter(this, void 0, void 0, function () {
            var remotes, selectedRemote, nameModal, remoteName, _a, branches, branchModal;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0: return [4 /*yield*/, this.gitManager.getRemotes()];
                    case 1:
                        remotes = _b.sent();
                        if (!(remotes.length === 0)) return [3 /*break*/, 4];
                        return [4 /*yield*/, this.editRemotes()];
                    case 2:
                        selectedRemote = _b.sent();
                        if (!(selectedRemote == undefined)) return [3 /*break*/, 4];
                        return [4 /*yield*/, this.gitManager.getRemotes()];
                    case 3:
                        remotes = _b.sent();
                        _b.label = 4;
                    case 4:
                        nameModal = new GeneralModal(this.app, remotes, "Select or create a new remote by typing its name and selecting it");
                        if (!(selectedRemote !== null && selectedRemote !== void 0)) return [3 /*break*/, 5];
                        _a = selectedRemote;
                        return [3 /*break*/, 7];
                    case 5: return [4 /*yield*/, nameModal.open()];
                    case 6:
                        _a = _b.sent();
                        _b.label = 7;
                    case 7:
                        remoteName = _a;
                        if (!remoteName) return [3 /*break*/, 11];
                        this.displayMessage("Fetching remote branches");
                        return [4 /*yield*/, this.gitManager.fetch(remoteName)];
                    case 8:
                        _b.sent();
                        return [4 /*yield*/, this.gitManager.getRemoteBranches(remoteName)];
                    case 9:
                        branches = _b.sent();
                        branchModal = new GeneralModal(this.app, branches, "Select or create a new remote branch by typing its name and selecting it");
                        return [4 /*yield*/, branchModal.open()];
                    case 10: return [2 /*return*/, _b.sent()];
                    case 11: return [2 /*return*/];
                }
            });
        });
    };
    ObsidianGit.prototype.removeRemote = function () {
        return __awaiter(this, void 0, void 0, function () {
            var remotes, nameModal, remoteName;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.isAllInitialized()];
                    case 1:
                        if (!(_a.sent()))
                            return [2 /*return*/];
                        return [4 /*yield*/, this.gitManager.getRemotes()];
                    case 2:
                        remotes = _a.sent();
                        nameModal = new GeneralModal(this.app, remotes, "Select a remote");
                        return [4 /*yield*/, nameModal.open()];
                    case 3:
                        remoteName = _a.sent();
                        if (remoteName) {
                            this.gitManager.removeRemote(remoteName);
                        }
                        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; }
        // Some errors might not be of type string
        message = message.toString();
        new obsidian.Notice(message);
        console.log("git obsidian error: " + message);
        (_a = this.statusBar) === null || _a === void 0 ? void 0 : _a.displayMessage(message.toLowerCase(), timeout);
    };
    return ObsidianGit;
}(obsidian.Plugin));

module.exports = ObsidianGit;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","src/modals/changedFilesModal.ts","src/modals/customMessageModal.ts","src/promiseQueue.ts","src/settings.ts","src/types.ts","src/statusBar.ts","src/modals/generalModal.ts","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/responses/ConfigList.js","node_modules/simple-git/src/lib/tasks/config.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/@kwsites/promise-deferred/dist/index.js","node_modules/simple-git/src/lib/plugins/completion-detection.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/spawn-options-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/tasks/change-working-directory.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/responses/DiffSummary.js","node_modules/simple-git/src/lib/parsers/parse-diff-summary.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-remote-objects.js","node_modules/simple-git/src/lib/parsers/parse-remote-messages.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-push.js","node_modules/simple-git/src/lib/tasks/push.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/simple-git-api.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/parsers/parse-commit.js","node_modules/simple-git/src/lib/tasks/commit.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/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/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","src/gitManager.ts","src/simpleGit.ts","src/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, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\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","import { FuzzySuggestModal } from \"obsidian\";\nimport ObsidianGit from \"src/main\";\nimport { FileStatusResult } from \"src/types\";\n\nexport class 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}","import { SuggestModal } from \"obsidian\";\nimport ObsidianGit from \"src/main\";\n\nexport class 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}","\nexport class 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}","import { Notice, PluginSettingTab, Setting } from \"obsidian\";\nimport ObsidianGit from \"./main\";\n\nexport class 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.autoPullInterval);\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.gitManager.formatCommitMessage();\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.gitManager.branchInfo();\n                for (const branch of branchInfo.branches) {\n                    dropdown.addOption(branch, branch);\n                }\n                dropdown.setValue(branchInfo.current);\n                dropdown.onChange(async (option) => {\n                    await plugin.gitManager.checkout(option);\n                    new Notice(`Checked out to ${option}`);\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(\"Update submodules\")\n            .setDesc('\"Create backup\" and \"pull\" takes care of submodules. Missing features: Conflicted files, count of pulled/pushed/committed files. Tracking branch needs to be set for each submodule')\n            .addToggle((toggle) =>\n                toggle\n                    .setValue(plugin.settings.updateSubmodules)\n                    .onChange((value) => {\n                        plugin.settings.updateSubmodules = 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        new Setting(containerEl)\n            .setName(\"Custom Git binary path\")\n            .addText((cb) => {\n                cb.setValue(plugin.settings.gitPath);\n                cb.setPlaceholder(\"git\");\n                cb.onChange((value) => {\n                    plugin.settings.gitPath = value;\n                    plugin.gitManager.updateGitPath(value || \"git\");\n                    plugin.saveSettings();\n                });\n            });\n    }\n}","export interface 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    standaloneMode: boolean;\n    proxyURL: string;\n    showStatusBar: boolean;\n    lastAutoBackUp: string;\n    lastAutoPull: string;\n}\n\nexport interface Author {\n    name: string;\n    email: string;\n}\nexport interface Status {\n    changed: FileStatusResult[];\n    staged: string[];\n}\nexport interface FileStatusResult {\n    path: string;\n    index: string;\n    working_dir: string;\n}\nexport interface DiffResult {\n    path: string;\n    type: \"equal\" | \"modify\" | \"add\" | \"remove\";\n}\n\nexport enum PluginState {\n    idle,\n    status,\n    pull,\n    add,\n    commit,\n    push,\n    conflicted,\n}\n\nexport interface BranchInfo {\n    current: string;\n    tracking: string;\n    branches: string[];\n}","import ObsidianGit from \"./main\";\nimport { PluginState } from \"./types\";\n\ninterface StatusBarMessage {\n    message: string;\n    timeout: number;\n}\n\nexport class 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}","import { App, SuggestModal } from \"obsidian\";\n\nexport class GeneralModal extends SuggestModal<string> {\n    list: string[];\n    resolve: ((value: string | PromiseLike<string>) => void) | null = null;\n\n\n    constructor(app: App, remotes: string[], placeholder: string) {\n        super(app);\n        this.list = remotes;\n        this.setPlaceholder(placeholder);\n    }\n\n    open(): Promise<string> {\n        super.open();\n        return new Promise((resolve) => {\n            this.resolve = resolve;\n        });\n    }\n\n    selectSuggestion(value: string, evt: MouseEvent | KeyboardEvent): void {\n        if (this.resolve) this.resolve(value);\n        super.selectSuggestion(value, evt);\n    }\n\n    onClose() {\n        if (this.resolve) this.resolve(undefined);\n    }\n\n    getSuggestions(query: string): string[] {\n        return [query.length > 0 ? query : \"...\", ...this.list];\n    }\n\n    renderSuggestion(value: string, el: HTMLElement): void {\n        el.innerText = value;\n    }\n\n    onChooseSuggestion(item: string, _: MouseEvent | KeyboardEvent) { }\n\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\t\tlet namespacesCache;\n\t\tlet enabledCache;\n\n\t\tfunction debug(...args) {\n\t\t\t// Disabled?\n\t\t\tif (!debug.enabled) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst self = debug;\n\n\t\t\t// Set `diff` timestamp\n\t\t\tconst curr = Number(new Date());\n\t\t\tconst ms = curr - (prevTime || curr);\n\t\t\tself.diff = ms;\n\t\t\tself.prev = prevTime;\n\t\t\tself.curr = curr;\n\t\t\tprevTime = curr;\n\n\t\t\targs[0] = createDebug.coerce(args[0]);\n\n\t\t\tif (typeof args[0] !== 'string') {\n\t\t\t\t// Anything else let's inspect with %O\n\t\t\t\targs.unshift('%O');\n\t\t\t}\n\n\t\t\t// Apply any `formatters` transformations\n\t\t\tlet index = 0;\n\t\t\targs[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {\n\t\t\t\t// If we encounter an escaped % then don't increase the array index\n\t\t\t\tif (match === '%%') {\n\t\t\t\t\treturn '%';\n\t\t\t\t}\n\t\t\t\tindex++;\n\t\t\t\tconst formatter = createDebug.formatters[format];\n\t\t\t\tif (typeof formatter === 'function') {\n\t\t\t\t\tconst val = args[index];\n\t\t\t\t\tmatch = formatter.call(self, val);\n\n\t\t\t\t\t// Now we need to remove `args[index]` since it's inlined in the `format`\n\t\t\t\t\targs.splice(index, 1);\n\t\t\t\t\tindex--;\n\t\t\t\t}\n\t\t\t\treturn match;\n\t\t\t});\n\n\t\t\t// Apply env-specific formatting (colors, etc.)\n\t\t\tcreateDebug.formatArgs.call(self, args);\n\n\t\t\tconst logFn = self.log || createDebug.log;\n\t\t\tlogFn.apply(self, args);\n\t\t}\n\n\t\tdebug.namespace = namespace;\n\t\tdebug.useColors = createDebug.useColors();\n\t\tdebug.color = createDebug.selectColor(namespace);\n\t\tdebug.extend = extend;\n\t\tdebug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.\n\n\t\tObject.defineProperty(debug, 'enabled', {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: false,\n\t\t\tget: () => {\n\t\t\t\tif (enableOverride !== null) {\n\t\t\t\t\treturn enableOverride;\n\t\t\t\t}\n\t\t\t\tif (namespacesCache !== createDebug.namespaces) {\n\t\t\t\t\tnamespacesCache = createDebug.namespaces;\n\t\t\t\t\tenabledCache = createDebug.enabled(namespace);\n\t\t\t\t}\n\n\t\t\t\treturn enabledCache;\n\t\t\t},\n\t\t\tset: v => {\n\t\t\t\tenableOverride = v;\n\t\t\t}\n\t\t});\n\n\t\t// Env-specific initialization logic for debug instances\n\t\tif (typeof createDebug.init === 'function') {\n\t\t\tcreateDebug.init(debug);\n\t\t}\n\n\t\treturn debug;\n\t}\n\n\tfunction extend(namespace, delimiter) {\n\t\tconst newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);\n\t\tnewDebug.log = this.log;\n\t\treturn newDebug;\n\t}\n\n\t/**\n\t* Enables a debug mode by namespaces. This can include modes\n\t* separated by a colon and wildcards.\n\t*\n\t* @param {String} namespaces\n\t* @api public\n\t*/\n\tfunction enable(namespaces) {\n\t\tcreateDebug.save(namespaces);\n\t\tcreateDebug.namespaces = namespaces;\n\n\t\tcreateDebug.names = [];\n\t\tcreateDebug.skips = [];\n\n\t\tlet i;\n\t\tconst split = (typeof namespaces === 'string' ? namespaces : '').split(/[\\s,]+/);\n\t\tconst len = split.length;\n\n\t\tfor (i = 0; i < len; i++) {\n\t\t\tif (!split[i]) {\n\t\t\t\t// ignore empty strings\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tnamespaces = split[i].replace(/\\*/g, '.*?');\n\n\t\t\tif (namespaces[0] === '-') {\n\t\t\t\tcreateDebug.skips.push(new RegExp('^' + namespaces.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.delay = exports.pick = 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;\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/**\n * Get a new object from a source object with only the listed properties.\n */\nfunction pick(source, properties) {\n    return Object.assign({}, ...properties.map((property) => property in source ? { [property]: source[property] } : {}));\n}\nexports.pick = pick;\nfunction delay(duration = 0) {\n    return new Promise(done => setTimeout(done, duration));\n}\nexports.delay = delay;\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: 'empty',\n        parser,\n    };\n}\nexports.adhocExecTask = adhocExecTask;\nfunction configurationErrorTask(error) {\n    return {\n        commands: exports.EMPTY_COMMANDS,\n        format: 'empty',\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.format === 'empty' || !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.configGetParser = exports.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    for (const item of configParser(text)) {\n        config.addValue(item.file, String(item.key), item.value);\n    }\n    return config;\n}\nexports.configListParser = configListParser;\nfunction configGetParser(text, key) {\n    let value = null;\n    const values = [];\n    const scopes = new Map();\n    for (const item of configParser(text, key)) {\n        if (item.key !== key) {\n            continue;\n        }\n        values.push(value = item.value);\n        if (!scopes.has(item.file)) {\n            scopes.set(item.file, []);\n        }\n        scopes.get(item.file).push(value);\n    }\n    return {\n        key,\n        paths: Array.from(scopes.keys()),\n        scopes,\n        value,\n        values\n    };\n}\nexports.configGetParser = configGetParser;\nfunction configFilePath(filePath) {\n    return filePath.replace(/^(file):/, '');\n}\nfunction* configParser(text, requestedKey = null) {\n    const lines = text.split('\\0');\n    for (let i = 0, max = lines.length - 1; i < max;) {\n        const file = configFilePath(lines[i++]);\n        let value = lines[i++];\n        let key = requestedKey;\n        if (value.includes('\\n')) {\n            const line = utils_1.splitOn(value, '\\n');\n            key = line[0];\n            value = line[1];\n        }\n        yield { file, key, value };\n    }\n}\n//# sourceMappingURL=ConfigList.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GitConfigScope = void 0;\nconst ConfigList_1 = require(\"../responses/ConfigList\");\nconst utils_1 = require(\"../utils\");\nvar GitConfigScope;\n(function (GitConfigScope) {\n    GitConfigScope[\"system\"] = \"system\";\n    GitConfigScope[\"global\"] = \"global\";\n    GitConfigScope[\"local\"] = \"local\";\n    GitConfigScope[\"worktree\"] = \"worktree\";\n})(GitConfigScope = exports.GitConfigScope || (exports.GitConfigScope = {}));\nfunction asConfigScope(scope, fallback) {\n    if (typeof scope === 'string' && GitConfigScope.hasOwnProperty(scope)) {\n        return scope;\n    }\n    return fallback;\n}\nfunction addConfigTask(key, value, append, scope) {\n    const commands = ['config', `--${scope}`];\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}\nfunction getConfigTask(key, scope) {\n    const commands = ['config', '--null', '--show-origin', '--get-all', key];\n    if (scope) {\n        commands.splice(1, 0, `--${scope}`);\n    }\n    return {\n        commands,\n        format: 'utf-8',\n        parser(text) {\n            return ConfigList_1.configGetParser(text, key);\n        }\n    };\n}\nfunction listConfigTask(scope) {\n    const commands = ['config', '--list', '--show-origin', '--null'];\n    if (scope) {\n        commands.push(`--${scope}`);\n    }\n    return {\n        commands,\n        format: 'utf-8',\n        parser(text) {\n            return ConfigList_1.configListParser(text);\n        },\n    };\n}\nfunction default_1() {\n    return {\n        addConfig(key, value, ...rest) {\n            return this._runTask(addConfigTask(key, value, rest[0] === true, asConfigScope(rest[1], GitConfigScope.local)), utils_1.trailingFunctionArgument(arguments));\n        },\n        getConfig(key, scope) {\n            return this._runTask(getConfigTask(key, asConfigScope(scope, undefined)), utils_1.trailingFunctionArgument(arguments));\n        },\n        listConfig(...rest) {\n            return this._runTask(listConfigTask(asConfigScope(rest[0], undefined)), utils_1.trailingFunctionArgument(arguments));\n        },\n    };\n}\nexports.default = default_1;\n//# sourceMappingURL=config.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 config_1 = require(\"./tasks/config\");\nconst reset_1 = require(\"./tasks/reset\");\nconst api = {\n    CheckRepoActions: check_is_repo_1.CheckRepoActions,\n    CleanOptions: clean_1.CleanOptions,\n    GitConfigScope: config_1.GitConfigScope,\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.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\";\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.completionDetectionPlugin = void 0;\nconst promise_deferred_1 = require(\"@kwsites/promise-deferred\");\nconst utils_1 = require(\"../utils\");\nconst never = promise_deferred_1.default().promise;\nfunction completionDetectionPlugin({ onClose = true, onExit = 50 } = {}) {\n    function createEvents() {\n        let exitCode = -1;\n        const events = {\n            close: promise_deferred_1.default(),\n            closeTimeout: promise_deferred_1.default(),\n            exit: promise_deferred_1.default(),\n            exitTimeout: promise_deferred_1.default(),\n        };\n        const result = Promise.race([\n            onClose === false ? never : events.closeTimeout.promise,\n            onExit === false ? never : events.exitTimeout.promise,\n        ]);\n        configureTimeout(onClose, events.close, events.closeTimeout);\n        configureTimeout(onExit, events.exit, events.exitTimeout);\n        return {\n            close(code) {\n                exitCode = code;\n                events.close.done();\n            },\n            exit(code) {\n                exitCode = code;\n                events.exit.done();\n            },\n            get exitCode() {\n                return exitCode;\n            },\n            result,\n        };\n    }\n    function configureTimeout(flag, event, timeout) {\n        if (flag === false) {\n            return;\n        }\n        (flag === true ? event.promise : event.promise.then(() => utils_1.delay(flag))).then(timeout.done);\n    }\n    return {\n        type: 'spawn.after',\n        action(_data, { spawned, close }) {\n            var _a, _b;\n            return __awaiter(this, void 0, void 0, function* () {\n                const events = createEvents();\n                let deferClose = true;\n                let quickClose = () => void (deferClose = false);\n                (_a = spawned.stdout) === null || _a === void 0 ? void 0 : _a.on('data', quickClose);\n                (_b = spawned.stderr) === null || _b === void 0 ? void 0 : _b.on('data', quickClose);\n                spawned.on('error', quickClose);\n                spawned.on('close', (code) => events.close(code));\n                spawned.on('exit', (code) => events.exit(code));\n                try {\n                    yield events.result;\n                    if (deferClose) {\n                        yield utils_1.delay(50);\n                    }\n                    close(events.exitCode);\n                }\n                catch (err) {\n                    close(events.exitCode, err);\n                }\n            });\n        }\n    };\n}\nexports.completionDetectionPlugin = completionDetectionPlugin;\n//# sourceMappingURL=completion-detection.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 = /^([\\s\\S]+?):\\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.spawnOptionsPlugin = void 0;\nconst utils_1 = require(\"../utils\");\nfunction spawnOptionsPlugin(spawnOptions) {\n    const options = utils_1.pick(spawnOptions, ['uid', 'gid']);\n    return {\n        type: 'spawn.options',\n        action(data) {\n            return Object.assign(Object.assign({}, options), data);\n        },\n    };\n}\nexports.spawnOptionsPlugin = spawnOptionsPlugin;\n//# sourceMappingURL=spawn-options-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(\"./completion-detection.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(\"./spawn-options-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._cwd || this._executor.cwd;\n    }\n    set cwd(cwd) {\n        this._cwd = 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(this);\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 = this._plugins.exec('spawn.options', {\n                cwd: this.cwd,\n                env: this.env,\n                windowsHide: true,\n            }, pluginContext(task, task.commands));\n            return new Promise((done) => {\n                const stdOut = [];\n                const stdErr = [];\n                let rejection;\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                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, close(exitCode, reason) {\n                        done({\n                            stdOut,\n                            stdErr,\n                            exitCode,\n                            rejection: rejection || reason,\n                        });\n                    },\n                    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            callback((err instanceof git_response_error_1.GitResponseError) ? addDeprecationNoticeToError(err) : err, undefined);\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.changeWorkingDirectoryTask = void 0;\nconst utils_1 = require(\"../utils\");\nconst task_1 = require(\"./task\");\nfunction changeWorkingDirectoryTask(directory, root) {\n    return task_1.adhocExecTask((instance) => {\n        if (!utils_1.folderExists(directory)) {\n            throw new Error(`Git.cwd: cannot change to non-directory \"${directory}\"`);\n        }\n        return ((root || instance).cwd = directory);\n    });\n}\nexports.changeWorkingDirectoryTask = changeWorkingDirectoryTask;\n//# sourceMappingURL=change-working-directory.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.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.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\");\nconst task_1 = require(\"./task\");\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[\"mailMap\"] = 10] = \"mailMap\";\n    excludeOptions[excludeOptions[\"multiLine\"] = 11] = \"multiLine\";\n    excludeOptions[excludeOptions[\"strictDate\"] = 12] = \"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: opt.mailMap !== false ? '%aN' : '%an',\n        author_email: opt.mailMap !== false ? '%aE' : '%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;\nfunction default_1() {\n    return {\n        log(...rest) {\n            const next = utils_1.trailingFunctionArgument(arguments);\n            const task = rejectDeprecatedSignatures(...rest) ||\n                createLogTask(parseLogOptions(utils_1.trailingOptionsArgument(arguments), utils_1.filterType(arguments[0], utils_1.filterArray)));\n            return this._runTask(task, next);\n        }\n    };\n    function createLogTask(options) {\n        return logTask(options.splitter, options.fields, options.commands);\n    }\n    function rejectDeprecatedSignatures(from, to) {\n        return (utils_1.filterString(from) &&\n            utils_1.filterString(to) &&\n            task_1.configurationErrorTask(`git.log(string, string) should be replaced with git.log({ from: string, to: string })`));\n    }\n}\nexports.default = default_1;\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.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.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.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.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.SimpleGitApi = void 0;\nconst task_callback_1 = require(\"./task-callback\");\nconst change_working_directory_1 = require(\"./tasks/change-working-directory\");\nconst config_1 = require(\"./tasks/config\");\nconst hash_object_1 = require(\"./tasks/hash-object\");\nconst init_1 = require(\"./tasks/init\");\nconst log_1 = require(\"./tasks/log\");\nconst merge_1 = require(\"./tasks/merge\");\nconst push_1 = require(\"./tasks/push\");\nconst status_1 = require(\"./tasks/status\");\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    cwd(directory) {\n        const next = utils_1.trailingFunctionArgument(arguments);\n        if (typeof directory === 'string') {\n            return this._runTask(change_working_directory_1.changeWorkingDirectoryTask(directory, this._executor), next);\n        }\n        if (typeof (directory === null || directory === void 0 ? void 0 : directory.path) === 'string') {\n            return this._runTask(change_working_directory_1.changeWorkingDirectoryTask(directory.path, directory.root && this._executor || undefined), next);\n        }\n        return this._runTask(task_1.configurationErrorTask('Git.cwd: workingDirectory must be supplied as a string'), next);\n    }\n    hashObject(path, write) {\n        return this._runTask(hash_object_1.hashObjectTask(path, write === true), utils_1.trailingFunctionArgument(arguments));\n    }\n    init(bare) {\n        return this._runTask(init_1.initTask(bare === true, this._executor.cwd, utils_1.getTrailingOptions(arguments)), utils_1.trailingFunctionArgument(arguments));\n    }\n    merge() {\n        return this._runTask(merge_1.mergeTask(utils_1.getTrailingOptions(arguments)), utils_1.trailingFunctionArgument(arguments));\n    }\n    mergeFromTo(remote, branch) {\n        if (!(utils_1.filterString(remote) && utils_1.filterString(branch))) {\n            return this._runTask(task_1.configurationErrorTask(`Git.mergeFromTo requires that the 'remote' and 'branch' arguments are supplied as strings`));\n        }\n        return this._runTask(merge_1.mergeTask([remote, branch, ...utils_1.getTrailingOptions(arguments)]), utils_1.trailingFunctionArgument(arguments, false));\n    }\n    outputHandler(handler) {\n        this._executor.outputHandler = handler;\n        return this;\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    stash() {\n        return this._runTask(task_1.straightThroughStringTask(['stash', ...utils_1.getTrailingOptions(arguments)]), utils_1.trailingFunctionArgument(arguments));\n    }\n    status() {\n        return this._runTask(status_1.statusTask(utils_1.getTrailingOptions(arguments)), utils_1.trailingFunctionArgument(arguments));\n    }\n}\nexports.SimpleGitApi = SimpleGitApi;\nObject.assign(SimpleGitApi.prototype, config_1.default(), log_1.default());\n//# sourceMappingURL=simple-git-api.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.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.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.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.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 {configurationErrorTask} = require('./lib/tasks/task');\nconst {\n   asArray,\n   filterArray,\n   filterPrimitives,\n   filterString,\n   filterStringOrStringArray,\n   filterType,\n   getTrailingOptions,\n   trailingFunctionArgument,\n   trailingOptionsArgument\n} = require('./lib/utils');\nconst {applyPatchTask} = require('./lib/tasks/apply-patch')\nconst {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 {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 {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 {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 * List the stash(s) of the local repo\n */\nGit.prototype.stashList = function (options) {\n   return this._runTask(\n      stashListTask(\n         trailingOptionsArgument(arguments) || {},\n         filterArray(options) && options || []\n      ),\n      trailingFunctionArgument(arguments),\n   );\n};\n\nfunction createCloneTask (api, task, repoPath, localPath) {\n   if (typeof repoPath !== 'string') {\n      return configurationErrorTask(`git.${ api }() requires a string 'repoPath'`);\n   }\n\n   return task(repoPath, filterType(localPath, filterString), getTrailingOptions(arguments));\n}\n\n\n/**\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 * 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 * Call any `git remote` function with arguments passed as an array of strings.\n *\n * @param {string[]} options\n * @param {Function} [then]\n */\nGit.prototype.remote = function (options, then) {\n   return this._runTask(\n      remoteTask(getTrailingOptions(arguments)),\n      trailingFunctionArgument(arguments),\n   );\n};\n\n/**\n * Call any `git tag` function with arguments passed as an array of strings.\n *\n * @param {string[]} options\n * @param {Function} [then]\n */\nGit.prototype.tag = function (options, then) {\n   const command = getTrailingOptions(arguments);\n\n   if (command[0] !== 'tag') {\n      command.unshift('tag');\n   }\n\n   return this._runTask(\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\nGit.prototype.exec = function (then) {\n   const task = {\n      commands: [],\n      format: 'utf-8',\n      parser () {\n         if (typeof then === 'function') {\n            then();\n         }\n      }\n   };\n\n   return this._runTask(task);\n};\n\n/**\n * Clears the queue of pending commands and returns the wrapper instance for chaining.\n *\n * @returns {Git}\n */\nGit.prototype.clearQueue = function () {\n   // TODO:\n   // this._executor.clear();\n   return this;\n};\n\n/**\n * Check if a pathname or pathnames are excluded by .gitignore\n *\n * @param {string|string[]} pathnames\n * @param {Function} [then]\n */\nGit.prototype.checkIgnore = function (pathnames, then) {\n   return this._runTask(\n      checkIgnoreTask(asArray((filterType(pathnames, filterStringOrStringArray, [])))),\n      trailingFunctionArgument(arguments),\n   );\n};\n\nGit.prototype.checkIsRepo = function (checkType, then) {\n   return this._runTask(\n      checkIsRepoTask(filterType(checkType, filterString)),\n      trailingFunctionArgument(arguments),\n   );\n};\n\nmodule.exports = Git;\n","\"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    plugins.add(plugins_1.completionDetectionPlugin(config.completion));\n    config.progress && plugins.add(plugins_1.progressMonitorPlugin(config.progress));\n    config.timeout && plugins.add(plugins_1.timeoutPlugin(config.timeout));\n    config.spawnOptions && plugins.add(plugins_1.spawnOptionsPlugin(config.spawnOptions));\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 { App } from \"obsidian\";\nimport ObsidianGit from \"./main\";\nimport { BranchInfo, FileStatusResult, Status } from \"./types\";\n\n\nexport abstract class GitManager {\n    readonly plugin: ObsidianGit;\n    readonly app: App;\n    constructor(plugin: ObsidianGit) {\n        this.plugin = plugin;\n        this.app = plugin.app;\n    }\n\n    abstract status(): Promise<Status>;\n\n    abstract commitAll(message?: string): Promise<number>;\n\n    abstract pull(): Promise<number>;\n\n    abstract push(): Promise<number>;\n\n    abstract canPush(): Promise<boolean>;\n\n    abstract checkRequirements(): Promise<\"valid\" | \"missing-repo\" | \"missing-git\">;\n\n    abstract branchInfo(): Promise<BranchInfo>;\n\n    abstract checkout(branch: string): Promise<void>;\n\n    abstract init(): Promise<void>;\n\n    abstract clone(url: string, dir: string): Promise<void>;\n\n    abstract setConfig(path: string, value: any): Promise<void>;\n\n    abstract getConfig(path: string): Promise<any>;\n\n    abstract fetch(remote?: string): Promise<void>;\n\n    abstract setRemote(name: string, url: string): Promise<void>;\n\n    abstract getRemotes(): Promise<string[]>;\n\n    abstract getRemoteBranches(remote: string): Promise<string[]>;\n\n    abstract removeRemote(remoteName: string): Promise<void>;\n\n    abstract updateUpstreamBranch(remoteBranch: string): Promise<void>;\n\n    abstract updateGitPath(gitPath: string): void;\n\n    async formatCommitMessage(): Promise<string> {\n        let template = this.plugin.settings.commitMessage;\n\n        if (template.includes(\"{{numFiles}}\")) {\n            let status = await this.status();\n            let numFiles = status.changed.length;\n            template = template.replace(\"{{numFiles}}\", String(numFiles));\n        }\n\n        if (template.includes(\"{{files}}\")) {\n            let status = await this.status();\n\n            let changeset: { [key: string]: string[]; } = {};\n            status.changed.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        template = template.replace(\n            \"{{date}}\",\n            moment().format(this.plugin.settings.commitDateFormat)\n        );\n        if (this.plugin.settings.listChangedFilesInMessageBody) {\n            template = template + \"\\n\\n\" + \"Affected files:\" + \"\\n\" + (await this.status()).staged.join(\"\\n\");\n        }\n        return template;\n    }\n}\n","import { spawnSync } from \"child_process\";\nimport { FileSystemAdapter } from \"obsidian\";\nimport * as path from \"path\";\nimport simpleGit, * as simple from \"simple-git\";\nimport { GitManager } from \"./gitManager\";\nimport ObsidianGit from \"./main\";\nimport { BranchInfo, FileStatusResult, PluginState } from \"./types\";\n\nexport class SimpleGit extends GitManager {\n    git: simple.SimpleGit;\n    constructor(plugin: ObsidianGit) {\n        super(plugin);\n\n        const adapter = this.app.vault.adapter as FileSystemAdapter;\n        const path = adapter.getBasePath();\n\n        if (this.isGitInstalled()) {\n            this.git = simpleGit({\n                baseDir: path,\n                binary: this.plugin.settings.gitPath || undefined,\n            });\n        }\n    }\n\n    async status(): Promise<{\n        changed: FileStatusResult[];\n        staged: string[];\n        conflicted: string[];\n    }> {\n        this.plugin.setState(PluginState.status);\n        const status = await this.git.status();\n        return {\n            changed: status.files.map((e) => {\n                e.path = this.fixFilePath(e.path);\n                return e;\n            }),\n            staged: status.staged.map(this.fixFilePath),\n            conflicted: status.conflicted.map(this.fixFilePath),\n        };\n    }\n\n    //Remove wrong `\"` like \"My file.md\"\n    fixFilePath(path: string): string {\n        path.startsWith('\"') && path.endsWith('\"') &&\n            (path = path.substring(1, path.length - 1));\n        return path;\n    }\n\n    async commitAll(message?: string): Promise<number> {\n        if (this.plugin.settings.updateSubmodules) {\n            this.plugin.setState(PluginState.commit);\n            await this.git.subModule([\"foreach\", \"--recursive\", `git add -A && if [ ! -z \"$(git status --porcelain)\" ]; then git commit -m \"${message ?? await this.formatCommitMessage()}\"; fi`], (err: any) => this.onError(err));\n        }\n        this.plugin.setState(PluginState.add);\n        await this.git.add(\n            \"./*\", (err: any) => this.onError(err)\n        );\n        this.plugin.setState(PluginState.commit);\n\n        return (await this.git.commit(message ?? await this.formatCommitMessage())).summary.changes;\n    }\n\n    async pull(): Promise<number> {\n        this.plugin.setState(PluginState.pull);\n        if (this.plugin.settings.updateSubmodules)\n            await this.git.subModule([\"update\", \"--remote\", \"--merge\", \"--recursive\"], (err: any) => this.onError(err));\n\n        const pullResult = await this.git.pull([\"--no-rebase\"],\n            async (err: Error | null) => {\n                if (err) {\n                    this.plugin.displayError(`Pull failed ${err.message}`);\n                    const status = await this.git.status();\n                    if (status.conflicted.length > 0) {\n                        this.plugin.handleConflict(status.conflicted);\n                    }\n                }\n            }\n        );\n\n        return pullResult.files.length;\n    }\n\n    async push(): Promise<number> {\n        this.plugin.setState(PluginState.status);\n        const status = await this.git.status();\n        const trackingBranch = status.tracking;\n        const currentBranch = status.current;\n        const remoteChangedFiles = (await this.git.diffSummary([currentBranch, trackingBranch])).changed;\n\n        this.plugin.setState(PluginState.push);\n        if (this.plugin.settings.updateSubmodules) {\n            await this.git.env({ ...process.env, \"OBSIDIAN_GIT\": 1 }).subModule([\"foreach\", \"--recursive\", `tracking=$(git for-each-ref --format='%(upstream:short)' \"$(git symbolic-ref -q HEAD)\"); echo $tracking; if [ ! -z \"$(git diff --shortstat $tracking)\" ]; then git push; fi`], (err: any) => this.onError(err));\n\n        }\n        await this.git.env({ ...process.env, \"OBSIDIAN_GIT\": 1 }).push((err: any) => this.onError(err));\n\n        return remoteChangedFiles;\n    }\n\n\n    async canPush(): Promise<boolean> {\n        // allow pushing in submodules even if the root has no changes.\n        if (this.plugin.settings.updateSubmodules === true) {\n            return true;\n        }\n        const status = await this.git.status((err: any) => this.onError(err));\n        const trackingBranch = status.tracking;\n        const currentBranch = status.current;\n        const remoteChangedFiles = (await this.git.diffSummary([currentBranch, trackingBranch])).changed;\n\n        return remoteChangedFiles !== 0;\n    }\n\n    async checkRequirements(): Promise<\"valid\" | \"missing-repo\" | \"missing-git\"> {\n        if (!this.isGitInstalled()) {\n            return \"missing-git\";\n        }\n        if (!(await this.git.checkIsRepo())) {\n            return \"missing-repo\";\n        }\n        return \"valid\";\n    }\n\n    async branchInfo(): Promise<BranchInfo> {\n        const status = await this.git.status((err: any) => this.onError(err));\n        const branches = await this.git.branch([\"--no-color\"], (err: any) => this.onError(err));\n\n        return {\n            current: status.current,\n            tracking: status.tracking,\n            branches: branches.all,\n        };\n    }\n\n    async checkout(branch: string): Promise<void> {\n        await this.git.checkout(branch, (err: any) => this.onError(err));\n    }\n\n    async init(): Promise<void> {\n        await this.git.init(false, (err: any) => this.onError(err));\n    }\n\n    async clone(url: string, dir: string): Promise<void> {\n        await this.git.clone(url, path.join((this.app.vault.adapter as FileSystemAdapter).getBasePath(), dir), [], (err: any) => this.onError(err));\n    }\n\n    async setConfig(path: string, value: any): Promise<void> {\n        await this.git.addConfig(path, value, (err: any) => this.onError(err));\n    }\n\n    async getConfig(path: string): Promise<any> {\n        const config = await this.git.listConfig((err: any) => this.onError(err));\n        return config.all[path];\n    }\n\n    async fetch(remote?: string): Promise<void> {\n        await this.git.fetch(remote != undefined ? [remote] : [], (err: any) => this.onError(err));\n    }\n\n    async setRemote(name: string, url: string): Promise<void> {\n        if ((await this.getRemotes()).includes(name))\n            await this.git.remote([\"set-url\", name, url], (err: any) => this.onError(err));\n\n        else {\n            await this.git.remote([\"add\", name, url], (err: any) => this.onError(err));\n        }\n    }\n\n    async getRemoteBranches(remote: string): Promise<string[]> {\n        const res = await this.git.branch([\"-r\", \"--list\", `${remote}*`], (err: any) => this.onError(err));\n        const list = [];\n        for (var item in res.branches) {\n            list.push(res.branches[item].name);\n        }\n        return list;\n    }\n\n    async getRemotes() {\n        const res = await this.git.remote([], (err: any) => this.onError(err));\n        if (res) {\n            return res.trim().split(\"\\n\");\n        } else {\n            return [];\n        }\n    }\n\n    async removeRemote(remoteName: string) {\n        await this.git.removeRemote(remoteName);\n    }\n\n    async updateUpstreamBranch(remoteBranch: string) {\n        await this.git.push([\"--set-upstream\", ...remoteBranch.split(\"/\")], (err: any) => this.onError(err));\n\n    }\n\n    updateGitPath(gitPath: string) {\n        return this.git.customBinary(gitPath);\n    }\n\n    private 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    private onError(error: Error | null) {\n        if (error) {\n            this.plugin.displayError(error.message);\n        }\n    }\n}","import { Notice, Plugin, TFile } from \"obsidian\";\nimport * as path from \"path\";\nimport { ChangedFilesModal } from \"src/modals/changedFilesModal\";\nimport { CustomMessageModal } from \"src/modals/customMessageModal\";\nimport { PromiseQueue } from \"src/promiseQueue\";\nimport { ObsidianGitSettingsTab } from \"src/settings\";\nimport { StatusBar } from \"src/statusBar\";\nimport { GitManager } from \"./gitManager\";\nimport { GeneralModal } from \"./modals/generalModal\";\nimport { SimpleGit } from \"./simpleGit\";\nimport { PluginState } from \"./types\";\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    updateSubmodules: boolean;\n    gitPath: 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    updateSubmodules: false,\n    gitPath: \"\"\n};\n\nexport default class ObsidianGit extends Plugin {\n    gitManager: GitManager;\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: \"Create backup\",\n            callback: () => this.promiseQueue.addTask(() => this.createBackup(false))\n        });\n\n        this.addCommand({\n            id: \"edit-remotes\",\n            name: \"Edit remotes\",\n            callback: async () => this.editRemotes()\n        });\n\n        this.addCommand({\n            id: \"remove-remote\",\n            name: \"Remove remote\",\n            callback: async () => this.removeRemote()\n        });\n\n        this.addCommand({\n            id: \"init-repo\",\n            name: \"Initialize a new repo\",\n            callback: async () => this.createNewRepo()\n        });\n\n        this.addCommand({\n            id: \"clone-repo\",\n            name: \"Clone an existing remote repo\",\n            callback: async () => this.cloneNewRepo()\n        });\n\n        this.addCommand({\n            id: \"commit-push-specified-message\",\n            name: \"Create backup 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.gitManager.status();\n                this.setState(PluginState.idle);\n\n                new ChangedFilesModal(this, status.changed).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        this.app.workspace.onLayoutReady(() => this.init());\n\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 saveLastAuto(date: Date, mode: \"backup\" | \"pull\") {\n        if (mode === \"backup\") {\n            window.localStorage.setItem(this.manifest.id + \":lastAutoBackup\", date.toString());\n        } else if (mode === \"pull\") {\n            window.localStorage.setItem(this.manifest.id + \":lastAutoPull\", date.toString());\n        }\n    }\n\n    async loadLastAuto(): Promise<{ \"backup\": Date, \"pull\": Date; }> {\n        return {\n            \"backup\": new Date(window.localStorage.getItem(this.manifest.id + \":lastAutoBackup\") ?? \"\"),\n            \"pull\": new Date(window.localStorage.getItem(this.manifest.id + \":lastAutoPull\") ?? \"\")\n        };\n    }\n\n    async init(): Promise<void> {\n        try {\n            this.gitManager = new SimpleGit(this);\n\n            const result = await this.gitManager.checkRequirements();\n            switch (result) {\n                case \"missing-git\":\n                    this.displayError(\"Cannot run git command\");\n                    break;\n                case \"missing-repo\":\n                    new Notice(\"Can't find a valid git repository. Please create one via the given command.\");\n                    break;\n                case \"valid\":\n                    this.gitReady = true;\n                    this.setState(PluginState.idle);\n\n                    if (this.settings.autoPullOnBoot) {\n                        this.promiseQueue.addTask(() => this.pullChangesFromRemote());\n                    }\n                    const lastAutos = await this.loadLastAuto();\n\n                    if (this.settings.autoSaveInterval > 0) {\n                        const now = new Date();\n\n                        const diff = this.settings.autoSaveInterval - (Math.round(((now.getTime() - lastAutos.backup.getTime()) / 1000) / 60));\n                        this.startAutoBackup(diff <= 0 ? 0 : diff);\n                    }\n                    if (this.settings.autoPullInterval > 0) {\n                        const now = new Date();\n\n                        const diff = this.settings.autoPullInterval - (Math.round(((now.getTime() - lastAutos.pull.getTime()) / 1000) / 60));\n                        this.startAutoPull(diff <= 0 ? 0 : diff);\n                    }\n                    break;\n                default:\n                    console.log(\"Something weird happened. The 'checkRequirements' result is \" + result);\n            }\n\n        } catch (error) {\n            this.displayError(error);\n            console.error(error);\n        }\n    }\n\n    async createNewRepo() {\n        await this.gitManager.init();\n        new Notice(\"Initialized new repo\");\n    }\n\n    async cloneNewRepo() {\n        const modal = new GeneralModal(this.app, [], \"Enter remote URL\");\n        const url = await modal.open();\n        if (url) {\n            let dir = await new GeneralModal(this.app, [], \"Enter directory for clone. It needs to be empty or not existent.\").open();\n            if (dir) {\n                dir = path.normalize(dir);\n                new Notice(`Cloning new repo into \"${dir}\"`);\n                await this.gitManager.clone(url, dir);\n                new Notice(\"Cloned new repo\");\n            }\n        }\n    }\n\n    /**\n     * Retries to call `this.init()` if necessary, otherwise returns directly\n     * @returns true if `this.gitManager` is ready to be used, false if not.\n     */\n    async isAllInitialized(): Promise<boolean> {\n        if (!this.gitReady) {\n            await this.init();\n        }\n        return this.gitReady;\n    }\n\n    async pullChangesFromRemote(): Promise<void> {\n\n        if (!await this.isAllInitialized()) return;\n\n        const filesUpdated = await this.gitManager.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        if (this.gitManager instanceof SimpleGit) {\n            const status = await this.gitManager.status();\n            if (status.conflicted.length > 0) {\n                this.displayError(`You have ${status.conflicted.length} conflict files`);\n            }\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 (!await this.isAllInitialized()) return;\n\n\n        if (!fromAutoBackup) {\n            const file = this.app.vault.getAbstractFileByPath(this.conflictOutputFile);\n            await this.app.vault.delete(file);\n        }\n        if (this.gitManager instanceof SimpleGit) {\n            const status = await this.gitManager.status();\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\n        const changedFiles = (await this.gitManager.status()).changed;\n\n        if (changedFiles.length !== 0) {\n            const commitedFiles = await this.gitManager.commitAll(commitMessage);\n            this.displayMessage(`Committed ${commitedFiles} files`);\n        } else {\n            this.displayMessage(\"No changes to commit\");\n        }\n\n        if (!this.settings.disablePush) {\n            if (!(await this.gitManager.branchInfo()).tracking) {\n                new Notice(\"No upstream branch is set. Please select one.\");\n                const remoteBranch = await this.selectRemoteBranch();\n\n                if (remoteBranch == undefined) {\n                    this.displayError(\"Did not push. No upstream-branch is set!\", 10000);\n                    this.setState(PluginState.idle);\n                    return;\n                } else {\n                    await this.gitManager.updateUpstreamBranch(remoteBranch);\n                }\n            }\n\n\n            // Prevent plugin to pull/push at every call of createBackup. Only if unpushed commits are present\n            if (await this.gitManager.canPush()) {\n                if (this.settings.pullBeforePush) {\n                    const pulledFilesLength = await this.gitManager.pull();\n                    if (pulledFilesLength > 0) {\n                        this.displayMessage(`Pulled ${pulledFilesLength} files from remote`);\n                    }\n                }\n\n                // Refresh because of pull\n                let status: any;\n                if (this.gitManager instanceof SimpleGit && (status = await this.gitManager.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 pushedFiles = await this.gitManager.push();\n                    this.lastUpdate = Date.now();\n                    this.displayMessage(`Pushed ${pushedFiles} files to remote`);\n                }\n            } else {\n                this.displayMessage(\"No changes to push\");\n            }\n        }\n        this.setState(PluginState.idle);\n    }\n\n    startAutoBackup(minutes?: number) {\n        this.timeoutIDBackup = window.setTimeout(\n            () => {\n                this.promiseQueue.addTask(() => this.createBackup(true));\n                this.saveLastAuto(new Date(), \"backup\");\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.saveLastAuto(new Date(), \"pull\");\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 editRemotes(): Promise<string | undefined> {\n        if (!await this.isAllInitialized()) return;\n\n        const remotes = await this.gitManager.getRemotes();\n\n        const nameModal = new GeneralModal(this.app, remotes, \"Select or create a new remote by typing its name and selecting it\");\n        const remoteName = await nameModal.open();\n\n        if (remoteName) {\n            const urlModal = new GeneralModal(this.app, [], \"Enter the remote URL\");\n            const remoteURL = await urlModal.open();\n            await this.gitManager.setRemote(remoteName, remoteURL);\n            return remoteName;\n        }\n\n    }\n\n    async selectRemoteBranch(): Promise<string | undefined> {\n        let remotes = await this.gitManager.getRemotes();\n        let selectedRemote: string;\n        if (remotes.length === 0) {\n            selectedRemote = await this.editRemotes();\n            if (selectedRemote == undefined) {\n                remotes = await this.gitManager.getRemotes();\n            }\n        }\n\n        const nameModal = new GeneralModal(this.app, remotes, \"Select or create a new remote by typing its name and selecting it\");\n        const remoteName = selectedRemote ?? await nameModal.open();\n\n        if (remoteName) {\n            this.displayMessage(\"Fetching remote branches\");\n            await this.gitManager.fetch(remoteName);\n            const branches = await this.gitManager.getRemoteBranches(remoteName);\n            const branchModal = new GeneralModal(this.app, branches, \"Select or create a new remote branch by typing its name and selecting it\");\n            return await branchModal.open();\n        }\n    }\n\n    async removeRemote() {\n        if (!await this.isAllInitialized()) return;\n\n\n        const remotes = await this.gitManager.getRemotes();\n\n        const nameModal = new GeneralModal(this.app, remotes, \"Select a remote\");\n        const remoteName = await nameModal.open();\n\n        if (remoteName) {\n            this.gitManager.removeRemote(remoteName);\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: any, timeout: number = 0): void {\n        // Some errors might not be of type string\n        message = message.toString();\n        new Notice(message);\n        console.log(`git obsidian error: ${message}`);\n        this.statusBar?.displayMessage(message.toLowerCase(), timeout);\n    }\n}"],"names":["FuzzySuggestModal","SuggestModal","Setting","Notice","PluginSettingTab","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","config_1","git_construct_error_1","git_plugin_error_1","git_response_error_1","reset_1","promise_deferred_1","debug_1","git_logger_1","tasks_pending_queue_1","task","gitError","child_process_1","git_executor_chain_1","parse_diff_summary_1","parse_list_log_summary_1","parse_remote_objects_1","parse_remote_messages_1","MergeSummary_1","parse_pull_1","parse_merge_1","parse_push_1","task_callback_1","change_working_directory_1","hash_object_1","init_1","merge_1","push_1","status_1","log_1","BranchDeleteSummary_1","BranchSummary_1","parse_branch_delete_1","parse_branch_1","CheckIgnore_1","parse_commit_1","parse_fetch_1","parse_move_1","GetRemoteSummary_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","plugins","plugins_1","Git","git_factory_1","simpleGit","path","spawnSync","TFile","Plugin"],"mappings":"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"}