diff --git a/.obsidian/community-plugins.json b/.obsidian/community-plugins.json index 8a47943..99e9de1 100644 --- a/.obsidian/community-plugins.json +++ b/.obsidian/community-plugins.json @@ -1,3 +1,6 @@ [ - "obsidian-charts" + "obsidian-charts", + "obsidian-git", + "obsidian-activity-history", + "obsidian-gist" ] \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-activity-history/data.json b/.obsidian/plugins/obsidian-activity-history/data.json new file mode 100644 index 0000000..4b738f1 --- /dev/null +++ b/.obsidian/plugins/obsidian-activity-history/data.json @@ -0,0 +1,38 @@ +{ + "firstRun": false, + "initialized": [ + { + "path": "/", + "initialized": true + } + ], + "trackedProjects": [ + "/" + ], + "checkpointList": [ + { + "path": "/", + "date": "2021-09-11", + "size": 2345 + } + ], + "activityHistory": [ + { + "path": "/", + "size": [ + { + "date": "2021-09-11", + "value": 248 + } + ] + } + ], + "activityColor1": "#c6e48b", + "activityColor2": "#7bc96f", + "activityColor3": "#239a3b", + "activityColor4": "#196127", + "textColor": "#000000", + "emptyColor": "#ecedf0", + "cellRadius": 1, + "type": "yearly" +} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-activity-history/main.js b/.obsidian/plugins/obsidian-activity-history/main.js new file mode 100644 index 0000000..a2aa490 --- /dev/null +++ b/.obsidian/plugins/obsidian-activity-history/main.js @@ -0,0 +1,2776 @@ +'use strict'; + +var obsidian = require('obsidian'); +require('constants'); + +/** + * Calculate size of MD files in the specified directory + * @param projectPath - path to project e.g. 'Test Project/First Sub Project' + * @param vaultFiles - list of all TFiles of Obsidian vault + */ +const getProjectSize = (projectPath, vaultFiles) => { + let projectSize = 0; + let reg = new RegExp(`^${projectPath}\/.*\.md$`); + if (projectPath === '/') { + reg = new RegExp(`^.*\.md$`); + } + for (let file in vaultFiles) { + if (vaultFiles[file].path.match(reg)) { + projectSize += vaultFiles[file].stat.size; + } + } + return projectSize; +}; +const updateActivity = (projectPath, vaultFiles, activitySettings) => { + let timestampNow = getTimestamp(); + let newSize = getProjectSize(projectPath, vaultFiles); + let checkpoint = getProjectCheckpoint(projectPath, activitySettings.checkpointList); + let activity = Math.abs(newSize - checkpoint.size); + if (timestampNow == checkpoint.date) { + updateProjectCheckpoint(projectPath, activitySettings.checkpointList, timestampNow, newSize); + activity = activity + getActivityAtDate(projectPath, activitySettings.activityHistory, timestampNow); + updateActivityAtDate(projectPath, activitySettings.activityHistory, timestampNow, activity); + } + updateProjectCheckpoint(projectPath, activitySettings.checkpointList, timestampNow, newSize); + updateActivityAtDate(projectPath, activitySettings.activityHistory, timestampNow, activity); +}; +/** + * Return timestamp for current day + */ +const getTimestamp = () => { + let today = new Date(); + let timestamp = today.getFullYear().toString(); + let month = today.getMonth() + 1; + let date = today.getDate(); + timestamp += `-${((month < 10) ? '0' : '') + month.toString()}`; + timestamp += `-${((date < 10) ? '0' : '') + date.toString()}`; + return timestamp; +}; +/** + * Return size for specified day + */ +const getActivityAtDate = (projectPath, activityHistoryList, timestamp) => { + for (let index = 0; index < activityHistoryList.length; index++) { + if (projectPath == activityHistoryList[index].path) { + for (let i = 0; i < activityHistoryList[index].size.length; i++) { + if (activityHistoryList[index].size[i].date == timestamp) { + return activityHistoryList[index].size[i].value; + } + } + } + } + return null; +}; +/** + * Return Activity History for specified project + */ +const getProjectActivityHistory = (projectPath, activityHistoryList) => { + for (let index = 0; index < activityHistoryList.length; index++) { + if (projectPath == activityHistoryList[index].path) { + return activityHistoryList[index]; + } + } + return null; +}; +/** + * Return checkpoint size & date for specified project + */ +const getProjectCheckpoint = (projectPath, checkpointList) => { + for (let index = 0; index < checkpointList.length; index++) { + if (projectPath == checkpointList[index].path) { + return checkpointList[index]; + } + } + return null; +}; +/** + * Update checkpoint size & date for specified project + */ +const updateProjectCheckpoint = (projectPath, checkpointList, valueDate, valueSize) => { + for (let index = 0; index < checkpointList.length; index++) { + if (projectPath == checkpointList[index].path) { + checkpointList[index] = { path: projectPath, date: valueDate, size: valueSize }; + } + } +}; +/** + * Return initialization status for specified project + */ +const getInitializationStatus = (projectPath, initializationList) => { + for (let index = 0; index < initializationList.length; index++) { + if (projectPath == initializationList[index].path) { + return initializationList[index]; + } + } + return null; +}; +/** + * Update timestamp for specified day + */ +const updateActivityAtDate = (projectPath, activityHistoryList, timestamp, value) => { + for (let index = 0; index < activityHistoryList.length; index++) { + if (projectPath == activityHistoryList[index].path) { + for (let i = activityHistoryList[index].size.length - 1; i >= 0; i--) { + if (activityHistoryList[index].size[i].date == timestamp) { + activityHistoryList[index].size[i].value = value; + return true; + } + } + activityHistoryList[index].size.push({ date: timestamp, value: value }); + return true; + } + } + return false; +}; +/** + * Check if project path is being tracked + */ +const isTracked = (projectPath, trackedProjects) => { + return trackedProjects.contains(projectPath); +}; +/** + * Check if project path is valid (at least 1 md file contained) + */ +const isValidProject = (projectPath, vaultFiles) => { + let reg = new RegExp(`^${projectPath}\/.*\.md$`); + for (let file in vaultFiles) { + if (vaultFiles[file].path.match(reg)) { + return true; + } + } + return false; +}; +/** + * Stop tracking specified project + */ +const removeProject = (projectPath, activitySettings) => { + activitySettings.trackedProjects.remove(projectPath); + activitySettings.initialized.remove(getInitializationStatus(projectPath, activitySettings.initialized)); + activitySettings.checkpointList.remove(getProjectCheckpoint(projectPath, activitySettings.checkpointList)); + activitySettings.activityHistory.remove(getProjectActivityHistory(projectPath, activitySettings.activityHistory)); + return activitySettings; +}; +/** + * Start tracking specified project + */ +const addProject = (projectPath, activitySettings, vaultFiles) => { + let timestampNow = getTimestamp(); + activitySettings.trackedProjects.push(projectPath); + activitySettings.initialized.push({ path: projectPath, initialized: true }); + activitySettings.checkpointList.push({ path: projectPath, date: timestampNow, size: getProjectSize(projectPath, vaultFiles) }); + activitySettings.activityHistory.push({ path: projectPath, size: [{ date: timestampNow, value: 0 }] }); + return activitySettings; +}; +/** + * Get Year Span for specified project + */ +const getYearRange = (projectPath, activityHistoryList) => { + let yearRange = []; + for (let index = 0; index < activityHistoryList.length; index++) { + if (projectPath == activityHistoryList[index].path) { + for (let i = activityHistoryList[index].size.length - 1; i >= 0; i--) { + let yearTmp = activityHistoryList[index].size[i].date.split('-')[0]; + if (yearRange) { + if (yearRange.every(x => x.year != yearTmp)) { + yearRange.push({ year: yearTmp }); + } + } + } + } + } + return yearRange; +}; +/** + * Check if string is a valid hexcolor + */ +const isHexColor = (hex) => { + return typeof hex === 'string' + && hex.length === 7 + && hex[0] === '#'; +}; +const updateActivityAll = (activitySettings, vaultFiles) => { + // Loop over all tracked projects + for (let project in activitySettings.trackedProjects) { + updateActivity(activitySettings.trackedProjects[project], vaultFiles, activitySettings); + } +}; + +class ActivityHistorySettingTab extends obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + let { containerEl } = this; + containerEl.empty(); + containerEl.createEl('h2', { text: 'Activity History Settings' }); + new obsidian.Setting(containerEl) + .setName('Tracked Projects:') + .setDesc(this.plugin.settings.trackedProjects.join(" --------- ")); + new obsidian.Setting(containerEl) + .setName('Track Project:') + .setDesc('Add project to tracking list. e.g. write `Project 1` to track the project located in `/Project 1`') + .addText(text => text + .setPlaceholder(`Project Example`) + .onChange(async (value) => { + if (value.trim() === '/') { + return; + } + // check if project already tracked + if (isTracked(value, this.plugin.settings.trackedProjects)) { + return; + } + // check if project is a valid project + if (!isValidProject(value, this.plugin.app.vault.getMarkdownFiles())) { + return; + } + // add & initialize project + addProject(value, this.plugin.settings, this.plugin.app.vault.getMarkdownFiles()); + // save settings + await this.plugin.saveSettings(); + })); + new obsidian.Setting(containerEl) + .setName('Stop Tracking Project:') + .setDesc('Remove project from the tracking list. e.g. `Project 1`') + .addText(text => text + .setPlaceholder(`Project Example`) + .onChange(async (value) => { + if (value.trim() === '/') { + return; + } + // check if project being tracked + if (!isTracked(value, this.plugin.settings.trackedProjects)) { + return; + } + // add & initialize project + removeProject(value, this.plugin.settings); + // save settings + await this.plugin.saveSettings(); + })); + new obsidian.Setting(containerEl) + .setName('Activity 1 Color:') + .setDesc('Color for lowest activity. Placeholder shows current color.') + .addDropdown(dropDown => dropDown + .addOption('yearly', 'Yearly') + .addOption('monthly', 'Monthly') + .setValue(this.plugin.settings.type || 'yearly') + .onChange((value) => { + this.plugin.settings.type = value; + this.plugin.saveSettings(); + })); + new obsidian.Setting(containerEl) + .setName('Activity 1 Color:') + .setDesc('Color for lowest activity. Placeholder shows current color.') + .addText(text => text + .setPlaceholder(this.plugin.settings.activityColor1) + .onChange(async (value) => { + // check if valid hex + if (!isHexColor(value)) { + return; + } + this.plugin.settings.activityColor1 = value; + await this.plugin.saveSettings(); + })); + new obsidian.Setting(containerEl) + .setName('Activity 2 Color:') + .setDesc('Color for low activity. Placeholder shows current color.') + .addText(text => text + .setPlaceholder(this.plugin.settings.activityColor2) + .onChange(async (value) => { + // check if valid hex + if (!isHexColor(value)) { + return; + } + this.plugin.settings.activityColor2 = value; + await this.plugin.saveSettings(); + })); + new obsidian.Setting(containerEl) + .setName('Activity 3 Color:') + .setDesc('Color for medium activity. Placeholder shows current color.') + .addText(text => text + .setPlaceholder(this.plugin.settings.activityColor3) + .onChange(async (value) => { + // check if valid hex + if (!isHexColor(value)) { + return; + } + this.plugin.settings.activityColor3 = value; + await this.plugin.saveSettings(); + })); + new obsidian.Setting(containerEl) + .setName('Activity 4 Color:') + .setDesc('Color for highest activity. Placeholder shows current color.') + .addText(text => text + .setPlaceholder(this.plugin.settings.activityColor4) + .onChange(async (value) => { + // check if valid hex + if (!isHexColor(value)) { + return; + } + this.plugin.settings.activityColor4 = value; + await this.plugin.saveSettings(); + })); + new obsidian.Setting(containerEl) + .setName('Text color:') + .setDesc('Text color. Placeholder shows current color.') + .addText(text => text + .setPlaceholder(this.plugin.settings.textColor) + .onChange(async (value) => { + // check if valid hex + if (!isHexColor(value)) { + return; + } + this.plugin.settings.textColor = value; + await this.plugin.saveSettings(); + })); + new obsidian.Setting(containerEl) + .setName('Empty color:') + .setDesc('Empty color. Placeholder shows current color.') + .addText(text => text + .setPlaceholder(this.plugin.settings.emptyColor) + .onChange(async (value) => { + // check if valid hex + if (!isHexColor(value)) { + return; + } + this.plugin.settings.emptyColor = value; + await this.plugin.saveSettings(); + })); + new obsidian.Setting(containerEl) + .setName('Cell Radius:') + .setDesc('Cell Radius. integer, default is 1 = square, the higher the more round.') + .addText(text => text + .setPlaceholder(this.plugin.settings.cellRadius) + .onChange(async (value) => { + let numValue = parseInt(value); + // check if valid hex + if (isNaN(numValue)) { + return; + } + this.plugin.settings.cellRadius = Math.abs(numValue); + await this.plugin.saveSettings(); + })); + } +} + +function noop() { } +function run(fn) { + return fn(); +} +function blank_object() { + return Object.create(null); +} +function run_all(fns) { + fns.forEach(run); +} +function is_function(thing) { + return typeof thing === 'function'; +} +function safe_not_equal(a, b) { + return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function'); +} +function is_empty(obj) { + return Object.keys(obj).length === 0; +} + +function append(target, node) { + target.appendChild(node); +} +function insert(target, node, anchor) { + target.insertBefore(node, anchor || null); +} +function detach(node) { + node.parentNode.removeChild(node); +} +function destroy_each(iterations, detaching) { + for (let i = 0; i < iterations.length; i += 1) { + if (iterations[i]) + iterations[i].d(detaching); + } +} +function element(name) { + return document.createElement(name); +} +function svg_element(name) { + return document.createElementNS('http://www.w3.org/2000/svg', name); +} +function text(data) { + return document.createTextNode(data); +} +function empty() { + return text(''); +} +function listen(node, event, handler, options) { + node.addEventListener(event, handler, options); + return () => node.removeEventListener(event, handler, options); +} +function attr(node, attribute, value) { + if (value == null) + node.removeAttribute(attribute); + else if (node.getAttribute(attribute) !== value) + node.setAttribute(attribute, value); +} +function children(element) { + return Array.from(element.childNodes); +} +function set_data(text, data) { + data = '' + data; + if (text.wholeText !== data) + text.data = data; +} +function select_option(select, value) { + for (let i = 0; i < select.options.length; i += 1) { + const option = select.options[i]; + if (option.__value === value) { + option.selected = true; + return; + } + } +} +function select_value(select) { + const selected_option = select.querySelector(':checked') || select.options[0]; + return selected_option && selected_option.__value; +} + +let current_component; +function set_current_component(component) { + current_component = component; +} + +const dirty_components = []; +const binding_callbacks = []; +const render_callbacks = []; +const flush_callbacks = []; +const resolved_promise = Promise.resolve(); +let update_scheduled = false; +function schedule_update() { + if (!update_scheduled) { + update_scheduled = true; + resolved_promise.then(flush); + } +} +function add_render_callback(fn) { + render_callbacks.push(fn); +} +function add_flush_callback(fn) { + flush_callbacks.push(fn); +} +let flushing = false; +const seen_callbacks = new Set(); +function flush() { + if (flushing) + return; + flushing = true; + do { + // first, call beforeUpdate functions + // and update components + for (let i = 0; i < dirty_components.length; i += 1) { + const component = dirty_components[i]; + set_current_component(component); + update(component.$$); + } + set_current_component(null); + dirty_components.length = 0; + while (binding_callbacks.length) + binding_callbacks.pop()(); + // then, once components are updated, call + // afterUpdate functions. This may cause + // subsequent updates... + for (let i = 0; i < render_callbacks.length; i += 1) { + const callback = render_callbacks[i]; + if (!seen_callbacks.has(callback)) { + // ...so guard against infinite loops + seen_callbacks.add(callback); + callback(); + } + } + render_callbacks.length = 0; + } while (dirty_components.length); + while (flush_callbacks.length) { + flush_callbacks.pop()(); + } + update_scheduled = false; + flushing = false; + seen_callbacks.clear(); +} +function update($$) { + if ($$.fragment !== null) { + $$.update(); + run_all($$.before_update); + const dirty = $$.dirty; + $$.dirty = [-1]; + $$.fragment && $$.fragment.p($$.ctx, dirty); + $$.after_update.forEach(add_render_callback); + } +} +const outroing = new Set(); +let outros; +function group_outros() { + outros = { + r: 0, + c: [], + p: outros // parent group + }; +} +function check_outros() { + if (!outros.r) { + run_all(outros.c); + } + outros = outros.p; +} +function transition_in(block, local) { + if (block && block.i) { + outroing.delete(block); + block.i(local); + } +} +function transition_out(block, local, detach, callback) { + if (block && block.o) { + if (outroing.has(block)) + return; + outroing.add(block); + outros.c.push(() => { + outroing.delete(block); + if (callback) { + if (detach) + block.d(1); + callback(); + } + }); + block.o(local); + } +} + +function bind(component, name, callback) { + const index = component.$$.props[name]; + if (index !== undefined) { + component.$$.bound[index] = callback; + callback(component.$$.ctx[index]); + } +} +function create_component(block) { + block && block.c(); +} +function mount_component(component, target, anchor) { + const { fragment, on_mount, on_destroy, after_update } = component.$$; + fragment && fragment.m(target, anchor); + // onMount happens before the initial afterUpdate + add_render_callback(() => { + const new_on_destroy = on_mount.map(run).filter(is_function); + if (on_destroy) { + on_destroy.push(...new_on_destroy); + } + else { + // Edge case - component was destroyed immediately, + // most likely as a result of a binding initialising + run_all(new_on_destroy); + } + component.$$.on_mount = []; + }); + after_update.forEach(add_render_callback); +} +function destroy_component(component, detaching) { + const $$ = component.$$; + if ($$.fragment !== null) { + run_all($$.on_destroy); + $$.fragment && $$.fragment.d(detaching); + // TODO null out other refs, including component.$$ (but need to + // preserve final state?) + $$.on_destroy = $$.fragment = null; + $$.ctx = []; + } +} +function make_dirty(component, i) { + if (component.$$.dirty[0] === -1) { + dirty_components.push(component); + schedule_update(); + component.$$.dirty.fill(0); + } + component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31)); +} +function init(component, options, instance, create_fragment, not_equal, props, dirty = [-1]) { + const parent_component = current_component; + set_current_component(component); + const $$ = component.$$ = { + fragment: null, + ctx: null, + // state + props, + update: noop, + not_equal, + bound: blank_object(), + // lifecycle + on_mount: [], + on_destroy: [], + before_update: [], + after_update: [], + context: new Map(parent_component ? parent_component.$$.context : []), + // everything else + callbacks: blank_object(), + dirty, + skip_bound: false + }; + let ready = false; + $$.ctx = instance + ? instance(component, options.props || {}, (i, ret, ...rest) => { + const value = rest.length ? rest[0] : ret; + if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) { + if (!$$.skip_bound && $$.bound[i]) + $$.bound[i](value); + if (ready) + make_dirty(component, i); + } + return ret; + }) + : []; + $$.update(); + ready = true; + run_all($$.before_update); + // `false` as a special case of no DOM component + $$.fragment = create_fragment ? create_fragment($$.ctx) : false; + if (options.target) { + if (options.hydrate) { + const nodes = children(options.target); + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + $$.fragment && $$.fragment.l(nodes); + nodes.forEach(detach); + } + else { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + $$.fragment && $$.fragment.c(); + } + if (options.intro) + transition_in(component.$$.fragment); + mount_component(component, options.target, options.anchor); + flush(); + } + set_current_component(parent_component); +} +/** + * Base class for Svelte components. Used when dev=false. + */ +class SvelteComponent { + $destroy() { + destroy_component(this, 1); + this.$destroy = noop; + } + $on(type, callback) { + const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = [])); + callbacks.push(callback); + return () => { + const index = callbacks.indexOf(callback); + if (index !== -1) + callbacks.splice(index, 1); + }; + } + $set($$props) { + if (this.$$set && !is_empty($$props)) { + this.$$.skip_bound = true; + this.$$set($$props); + this.$$.skip_bound = false; + } + } +} + +/** + * Get the last day of the month. + * + * @param {Date} date + * + * @return {Date} + */ +function getMonthEnd(date) { + return new Date(date.getFullYear(), date.getMonth() + 1, 0); +} + +/** + * Get the first day of the month. + * + * @param {Date} date + * + * @return {Date} + */ +function getMonthStart(date) { + return new Date(date.getFullYear(), date.getMonth(), 1); +} + +/** + * Get the last day of the week. + * + * @param {Date} date + * + * @return {Date} + */ +function getWeekEnd(date) { + return new Date(date.getFullYear(), date.getMonth(), date.getDate() + (6 - date.getDay())); +} + +/** + * Return the week index of a date. + * + * @param {Date} date + * + * @return {number} + */ +function getWeekIndex(date) { + const firstWeekday = new Date(date.getFullYear(), date.getMonth(), 1).getDay(); + const offsetDate = date.getDate() + firstWeekday - 1; + + return Math.floor(offsetDate / 7); +} + +/** + * Get the first day of the week. + * + * @param {Date} date + * + * @return {Date} + */ +function getWeekStart(date) { + return new Date(date.getFullYear(), date.getMonth(), date.getDate() - date.getDay()); +} + +/** + * Normalize to a javascript Date object. + * + * @param {Date|number|string} value + * + * @return {Date} + */ +function normalizeDate(value) { + if (value instanceof Date) { + return value; + } + + if (['number', 'string'].includes(typeof value)) { + return new Date(value); + } + + throw new Error('Invalid date value'); +} + +/** + * Stringify a date. + * + * @param {Date} date + * + * @return {string} + */ +function stringifyDate(date) { + return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}` +} + +/** + * Divide a calendar into months. + * + * @param {Object} options + * @param {boolean} options.allowOverflow + * @param {Array} options.calendar + * @param {Date|string|number} options.endDate + * @param {Date|string|number} options.startDate + * + * @return {Array>} + */ +function chunkMonths({ allowOverflow, calendar, endDate, startDate }) { + let prevMonth = -1; + + startDate = normalizeDate(startDate); + endDate = normalizeDate(endDate); + + return calendar.reduce((acc, day) => { + const currentMonth = day.date.getMonth(); + + if (prevMonth !== currentMonth) { + acc.push([]); + prevMonth = currentMonth; + } + + if ( + allowOverflow || ( + (!startDate || day.date >= startDate) && + (!endDate || day.date <= endDate) + ) + ) { + acc[acc.length - 1].push(day); + } + + return acc; + }, []); +} + +/** + * Divide a calendar into weeks. + * + * @param {Object} options + * @param {boolean} options.allowOverflow + * @param {Array} options.calendar + * @param {Date|string|number} options.endDate + * @param {Date|string|number} options.startDate + * + * @return {Array>} + */ +function chunkWeeks({ allowOverflow, calendar, endDate, startDate }) { + startDate = normalizeDate(startDate); + endDate = normalizeDate(endDate); + + return calendar.reduce((acc, day, index) => { + if (index % 7 === 0) { + acc.push([]); + } + + if ( + allowOverflow || ( + (!startDate || day.date >= startDate) && + (!endDate || day.date <= endDate) + ) + ) { + acc[acc.length - 1].push(day); + } + + return acc; + }, []); +} + +/** + * Determine the first day rendered on the heatmap. + * + * @param {Object} props + * @param {Array} props.colors + * @param {Array} props.data + * @param {string} props.emptyColor + * @param {Date|number|string} props.endDate + * @param {Date|number|string} props.startDate + * @param {string} props.view + * + * @return {Date} + */ +function getCalendar({ colors, data, emptyColor, endDate, startDate, view }) { + startDate = startDate ? normalizeDate(startDate) : new Date(); + endDate = endDate ? normalizeDate(endDate) : new Date(); + + if (view === 'monthly') { + startDate = getMonthStart(startDate); + endDate = getMonthEnd(endDate); + } else { + startDate = getWeekStart(startDate); + endDate = getWeekEnd(endDate); + } + + let max = 0; + const startDayOfMonth = startDate.getDate(); + const totalDays = Math.floor((endDate - startDate) / 86400000) + 1; // 86400000 = 1000 * 60 * 60 * 24 + + return new Array(totalDays) + .fill() + .map((x, offset) => { + const day = getDay({ data, offset, startDate, startDayOfMonth }); + + if (day.value > max) { + max = day.value; + } + + return day; + }) + .map(({ date, value }) => { + let color = getColor({ colors, max, value }) || emptyColor; + + return { color, date, value } + }); +} + +/** + * Determine what color a value should be. + * + * @param {options} options + * @param {Array} options.colors + * @param {number} options.max + * @param {number} options.value + * + * @return {string|null} + */ +function getColor({ colors, max, value }) { + if (colors.length && value) { + let color = colors[0]; + + const intencity = value / max; + + for (let i = 1; i < colors.length; i++) { + if (intencity < i / colors.length) { + return color; + } + + color = colors[i]; + } + + return colors[colors.length - 1]; + } + + return null; +} + +/** + * Aggregate the value of each day. + * + * @param {Object} options + * @param {Array} options.data + * @param {number} options.offset + * @param {number} options.startDayOfMonth + * @param {Date} options.startDate + * + * @return {Object} + */ +function getDay({ data, offset, startDate, startDayOfMonth }) { + const date = new Date(startDate); + date.setDate(startDayOfMonth + offset); + + const nextDate = new Date(date); + nextDate.setDate(date.getDate() + 1); + + const value = data.reduce((acc, obj) => { + const datapoint = normalizeDate(obj.date); + + return datapoint >= date && datapoint < nextDate ? acc + obj.value : acc; + }, 0); + + return { date, value }; +} + +/* node_modules/svelte-heatmap/src/views/Cell.svelte generated by Svelte v3.32.3 */ + +function create_fragment(ctx) { + let rect; + let rect_data_date_value; + + return { + c() { + rect = svg_element("rect"); + attr(rect, "data-date", rect_data_date_value = stringifyDate(/*date*/ ctx[1])); + attr(rect, "data-value", /*value*/ ctx[4]); + attr(rect, "fill", /*color*/ ctx[0]); + attr(rect, "height", /*size*/ ctx[3]); + attr(rect, "rx", /*radius*/ ctx[2]); + attr(rect, "width", /*size*/ ctx[3]); + attr(rect, "x", /*x*/ ctx[5]); + attr(rect, "y", /*y*/ ctx[6]); + }, + m(target, anchor) { + insert(target, rect, anchor); + }, + p(ctx, [dirty]) { + if (dirty & /*date*/ 2 && rect_data_date_value !== (rect_data_date_value = stringifyDate(/*date*/ ctx[1]))) { + attr(rect, "data-date", rect_data_date_value); + } + + if (dirty & /*value*/ 16) { + attr(rect, "data-value", /*value*/ ctx[4]); + } + + if (dirty & /*color*/ 1) { + attr(rect, "fill", /*color*/ ctx[0]); + } + + if (dirty & /*size*/ 8) { + attr(rect, "height", /*size*/ ctx[3]); + } + + if (dirty & /*radius*/ 4) { + attr(rect, "rx", /*radius*/ ctx[2]); + } + + if (dirty & /*size*/ 8) { + attr(rect, "width", /*size*/ ctx[3]); + } + + if (dirty & /*x*/ 32) { + attr(rect, "x", /*x*/ ctx[5]); + } + + if (dirty & /*y*/ 64) { + attr(rect, "y", /*y*/ ctx[6]); + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) detach(rect); + } + }; +} + +function instance($$self, $$props, $$invalidate) { + let { color } = $$props; + let { date } = $$props; + let { radius } = $$props; + let { size } = $$props; + let { value } = $$props; + let { x } = $$props; + let { y } = $$props; + + $$self.$$set = $$props => { + if ("color" in $$props) $$invalidate(0, color = $$props.color); + if ("date" in $$props) $$invalidate(1, date = $$props.date); + if ("radius" in $$props) $$invalidate(2, radius = $$props.radius); + if ("size" in $$props) $$invalidate(3, size = $$props.size); + if ("value" in $$props) $$invalidate(4, value = $$props.value); + if ("x" in $$props) $$invalidate(5, x = $$props.x); + if ("y" in $$props) $$invalidate(6, y = $$props.y); + }; + + return [color, date, radius, size, value, x, y]; +} + +class Cell extends SvelteComponent { + constructor(options) { + super(); + + init(this, options, instance, create_fragment, safe_not_equal, { + color: 0, + date: 1, + radius: 2, + size: 3, + value: 4, + x: 5, + y: 6 + }); + } +} + +/* node_modules/svelte-heatmap/src/views/Month.svelte generated by Svelte v3.32.3 */ + +function get_each_context(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[13] = list[i]; + return child_ctx; +} + +// (2:4) {#each days as day} +function create_each_block(ctx) { + let cell; + let current; + + cell = new Cell({ + props: { + color: /*day*/ ctx[13].color, + date: /*day*/ ctx[13].date, + radius: /*cellRadius*/ ctx[0], + size: /*cellSize*/ ctx[2], + value: /*day*/ ctx[13].value, + x: /*day*/ ctx[13].date.getDay() * /*cellRect*/ ctx[1], + y: getWeekIndex(/*day*/ ctx[13].date) * /*cellRect*/ ctx[1] + /*monthLabelHeight*/ ctx[7] + } + }); + + return { + c() { + create_component(cell.$$.fragment); + }, + m(target, anchor) { + mount_component(cell, target, anchor); + current = true; + }, + p(ctx, dirty) { + const cell_changes = {}; + if (dirty & /*days*/ 8) cell_changes.color = /*day*/ ctx[13].color; + if (dirty & /*days*/ 8) cell_changes.date = /*day*/ ctx[13].date; + if (dirty & /*cellRadius*/ 1) cell_changes.radius = /*cellRadius*/ ctx[0]; + if (dirty & /*cellSize*/ 4) cell_changes.size = /*cellSize*/ ctx[2]; + if (dirty & /*days*/ 8) cell_changes.value = /*day*/ ctx[13].value; + if (dirty & /*days, cellRect*/ 10) cell_changes.x = /*day*/ ctx[13].date.getDay() * /*cellRect*/ ctx[1]; + if (dirty & /*days, cellRect, monthLabelHeight*/ 138) cell_changes.y = getWeekIndex(/*day*/ ctx[13].date) * /*cellRect*/ ctx[1] + /*monthLabelHeight*/ ctx[7]; + cell.$set(cell_changes); + }, + i(local) { + if (current) return; + transition_in(cell.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(cell.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(cell, detaching); + } + }; +} + +// (13:4) {#if monthLabelHeight > 0} +function create_if_block(ctx) { + let text_1; + let t_value = /*monthLabels*/ ctx[8][/*days*/ ctx[3][0].date.getMonth()] + ""; + let t; + + return { + c() { + text_1 = svg_element("text"); + t = text(t_value); + attr(text_1, "alignment-baseline", "hanging"); + attr(text_1, "fill", /*fontColor*/ ctx[4]); + attr(text_1, "font-family", /*fontFamily*/ ctx[5]); + attr(text_1, "font-size", /*fontSize*/ ctx[6]); + attr(text_1, "x", "0"); + attr(text_1, "y", "0"); + }, + m(target, anchor) { + insert(target, text_1, anchor); + append(text_1, t); + }, + p(ctx, dirty) { + if (dirty & /*monthLabels, days*/ 264 && t_value !== (t_value = /*monthLabels*/ ctx[8][/*days*/ ctx[3][0].date.getMonth()] + "")) set_data(t, t_value); + + if (dirty & /*fontColor*/ 16) { + attr(text_1, "fill", /*fontColor*/ ctx[4]); + } + + if (dirty & /*fontFamily*/ 32) { + attr(text_1, "font-family", /*fontFamily*/ ctx[5]); + } + + if (dirty & /*fontSize*/ 64) { + attr(text_1, "font-size", /*fontSize*/ ctx[6]); + } + }, + d(detaching) { + if (detaching) detach(text_1); + } + }; +} + +function create_fragment$1(ctx) { + let g; + let each_1_anchor; + let g_transform_value; + let current; + let each_value = /*days*/ ctx[3]; + let each_blocks = []; + + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i)); + } + + const out = i => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + + let if_block = /*monthLabelHeight*/ ctx[7] > 0 && create_if_block(ctx); + + return { + c() { + g = svg_element("g"); + + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + + each_1_anchor = empty(); + if (if_block) if_block.c(); + attr(g, "transform", g_transform_value = `translate(${/*translation*/ ctx[9]}, 0)`); + }, + m(target, anchor) { + insert(target, g, anchor); + + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(g, null); + } + + append(g, each_1_anchor); + if (if_block) if_block.m(g, null); + current = true; + }, + p(ctx, [dirty]) { + if (dirty & /*days, cellRadius, cellSize, cellRect, getWeekIndex, monthLabelHeight*/ 143) { + each_value = /*days*/ ctx[3]; + let i; + + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context(ctx, each_value, i); + + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(g, each_1_anchor); + } + } + + group_outros(); + + for (i = each_value.length; i < each_blocks.length; i += 1) { + out(i); + } + + check_outros(); + } + + if (/*monthLabelHeight*/ ctx[7] > 0) { + if (if_block) { + if_block.p(ctx, dirty); + } else { + if_block = create_if_block(ctx); + if_block.c(); + if_block.m(g, null); + } + } else if (if_block) { + if_block.d(1); + if_block = null; + } + + if (!current || dirty & /*translation*/ 512 && g_transform_value !== (g_transform_value = `translate(${/*translation*/ ctx[9]}, 0)`)) { + attr(g, "transform", g_transform_value); + } + }, + i(local) { + if (current) return; + + for (let i = 0; i < each_value.length; i += 1) { + transition_in(each_blocks[i]); + } + + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + + current = false; + }, + d(detaching) { + if (detaching) detach(g); + destroy_each(each_blocks, detaching); + if (if_block) if_block.d(); + } + }; +} + +function instance$1($$self, $$props, $$invalidate) { + let translation; + let { cellGap } = $$props; + let { cellRadius } = $$props; + let { cellRect } = $$props; + let { cellSize } = $$props; + let { days } = $$props; + let { fontColor } = $$props; + let { fontFamily } = $$props; + let { fontSize } = $$props; + let { index } = $$props; + let { monthGap } = $$props; + let { monthLabelHeight } = $$props; + let { monthLabels } = $$props; + + $$self.$$set = $$props => { + if ("cellGap" in $$props) $$invalidate(10, cellGap = $$props.cellGap); + if ("cellRadius" in $$props) $$invalidate(0, cellRadius = $$props.cellRadius); + if ("cellRect" in $$props) $$invalidate(1, cellRect = $$props.cellRect); + if ("cellSize" in $$props) $$invalidate(2, cellSize = $$props.cellSize); + if ("days" in $$props) $$invalidate(3, days = $$props.days); + if ("fontColor" in $$props) $$invalidate(4, fontColor = $$props.fontColor); + if ("fontFamily" in $$props) $$invalidate(5, fontFamily = $$props.fontFamily); + if ("fontSize" in $$props) $$invalidate(6, fontSize = $$props.fontSize); + if ("index" in $$props) $$invalidate(11, index = $$props.index); + if ("monthGap" in $$props) $$invalidate(12, monthGap = $$props.monthGap); + if ("monthLabelHeight" in $$props) $$invalidate(7, monthLabelHeight = $$props.monthLabelHeight); + if ("monthLabels" in $$props) $$invalidate(8, monthLabels = $$props.monthLabels); + }; + + $$self.$$.update = () => { + if ($$self.$$.dirty & /*cellRect, cellGap, monthGap, index*/ 7170) { + $$invalidate(9, translation = (7 * cellRect - cellGap + monthGap) * index); + } + }; + + return [ + cellRadius, + cellRect, + cellSize, + days, + fontColor, + fontFamily, + fontSize, + monthLabelHeight, + monthLabels, + translation, + cellGap, + index, + monthGap + ]; +} + +class Month extends SvelteComponent { + constructor(options) { + super(); + + init(this, options, instance$1, create_fragment$1, safe_not_equal, { + cellGap: 10, + cellRadius: 0, + cellRect: 1, + cellSize: 2, + days: 3, + fontColor: 4, + fontFamily: 5, + fontSize: 6, + index: 11, + monthGap: 12, + monthLabelHeight: 7, + monthLabels: 8 + }); + } +} + +/* node_modules/svelte-heatmap/src/views/Week.svelte generated by Svelte v3.32.3 */ + +function get_each_context$1(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[7] = list[i]; + child_ctx[6] = i; + return child_ctx; +} + +// (2:4) {#each days as day, index} +function create_each_block$1(ctx) { + let cell; + let current; + + cell = new Cell({ + props: { + color: /*day*/ ctx[7].color, + date: /*day*/ ctx[7].date, + radius: /*cellRadius*/ ctx[0], + size: /*cellSize*/ ctx[2], + value: /*day*/ ctx[7].value, + y: /*day*/ ctx[7].date.getDay() * /*cellRect*/ ctx[1] + } + }); + + return { + c() { + create_component(cell.$$.fragment); + }, + m(target, anchor) { + mount_component(cell, target, anchor); + current = true; + }, + p(ctx, dirty) { + const cell_changes = {}; + if (dirty & /*days*/ 8) cell_changes.color = /*day*/ ctx[7].color; + if (dirty & /*days*/ 8) cell_changes.date = /*day*/ ctx[7].date; + if (dirty & /*cellRadius*/ 1) cell_changes.radius = /*cellRadius*/ ctx[0]; + if (dirty & /*cellSize*/ 4) cell_changes.size = /*cellSize*/ ctx[2]; + if (dirty & /*days*/ 8) cell_changes.value = /*day*/ ctx[7].value; + if (dirty & /*days, cellRect*/ 10) cell_changes.y = /*day*/ ctx[7].date.getDay() * /*cellRect*/ ctx[1]; + cell.$set(cell_changes); + }, + i(local) { + if (current) return; + transition_in(cell.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(cell.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(cell, detaching); + } + }; +} + +function create_fragment$2(ctx) { + let g; + let g_transform_value; + let current; + let each_value = /*days*/ ctx[3]; + let each_blocks = []; + + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block$1(get_each_context$1(ctx, each_value, i)); + } + + const out = i => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + + return { + c() { + g = svg_element("g"); + + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + + attr(g, "transform", g_transform_value = `translate(${/*translation*/ ctx[5]}, ${/*monthLabelHeight*/ ctx[4]})`); + }, + m(target, anchor) { + insert(target, g, anchor); + + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(g, null); + } + + current = true; + }, + p(ctx, [dirty]) { + if (dirty & /*days, cellRadius, cellSize, cellRect*/ 15) { + each_value = /*days*/ ctx[3]; + let i; + + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context$1(ctx, each_value, i); + + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block$1(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(g, null); + } + } + + group_outros(); + + for (i = each_value.length; i < each_blocks.length; i += 1) { + out(i); + } + + check_outros(); + } + + if (!current || dirty & /*translation, monthLabelHeight*/ 48 && g_transform_value !== (g_transform_value = `translate(${/*translation*/ ctx[5]}, ${/*monthLabelHeight*/ ctx[4]})`)) { + attr(g, "transform", g_transform_value); + } + }, + i(local) { + if (current) return; + + for (let i = 0; i < each_value.length; i += 1) { + transition_in(each_blocks[i]); + } + + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + + current = false; + }, + d(detaching) { + if (detaching) detach(g); + destroy_each(each_blocks, detaching); + } + }; +} + +function instance$2($$self, $$props, $$invalidate) { + let translation; + let { cellRadius } = $$props; + let { cellRect } = $$props; + let { cellSize } = $$props; + let { days } = $$props; + let { index } = $$props; + let { monthLabelHeight } = $$props; + + $$self.$$set = $$props => { + if ("cellRadius" in $$props) $$invalidate(0, cellRadius = $$props.cellRadius); + if ("cellRect" in $$props) $$invalidate(1, cellRect = $$props.cellRect); + if ("cellSize" in $$props) $$invalidate(2, cellSize = $$props.cellSize); + if ("days" in $$props) $$invalidate(3, days = $$props.days); + if ("index" in $$props) $$invalidate(6, index = $$props.index); + if ("monthLabelHeight" in $$props) $$invalidate(4, monthLabelHeight = $$props.monthLabelHeight); + }; + + $$self.$$.update = () => { + if ($$self.$$.dirty & /*cellRect, index*/ 66) { + $$invalidate(5, translation = cellRect * index); + } + }; + + return [cellRadius, cellRect, cellSize, days, monthLabelHeight, translation, index]; +} + +class Week extends SvelteComponent { + constructor(options) { + super(); + + init(this, options, instance$2, create_fragment$2, safe_not_equal, { + cellRadius: 0, + cellRect: 1, + cellSize: 2, + days: 3, + index: 6, + monthLabelHeight: 4 + }); + } +} + +/* node_modules/svelte-heatmap/src/SvelteHeatmap.svelte generated by Svelte v3.32.3 */ + +function get_each_context_1(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[26] = list[i]; + child_ctx[28] = i; + return child_ctx; +} + +function get_each_context_2(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[30] = list[i]; + child_ctx[28] = i; + return child_ctx; +} + +function get_each_context$2(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[26] = list[i]; + child_ctx[28] = i; + return child_ctx; +} + +// (19:4) {:else} +function create_else_block(ctx) { + let g; + let g_transform_value; + let current; + let if_block = /*dayLabelWidth*/ ctx[3] > 0 && create_if_block_2(ctx); + let each_value_1 = /*chunks*/ ctx[13]; + let each_blocks = []; + + for (let i = 0; i < each_value_1.length; i += 1) { + each_blocks[i] = create_each_block_1(get_each_context_1(ctx, each_value_1, i)); + } + + const out = i => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + + return { + c() { + if (if_block) if_block.c(); + g = svg_element("g"); + + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + + attr(g, "transform", g_transform_value = `translate(${/*dayLabelWidth*/ ctx[3]})`); + }, + m(target, anchor) { + if (if_block) if_block.m(target, anchor); + insert(target, g, anchor); + + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(g, null); + } + + current = true; + }, + p(ctx, dirty) { + if (/*dayLabelWidth*/ ctx[3] > 0) { + if (if_block) { + if_block.p(ctx, dirty); + } else { + if_block = create_if_block_2(ctx); + if_block.c(); + if_block.m(g.parentNode, g); + } + } else if (if_block) { + if_block.d(1); + if_block = null; + } + + if (dirty[0] & /*fontColor, fontFamily, fontSize, cellRect, monthLabels, chunks, monthLabelHeight, isNewMonth, cellRadius, cellSize*/ 145126) { + each_value_1 = /*chunks*/ ctx[13]; + let i; + + for (i = 0; i < each_value_1.length; i += 1) { + const child_ctx = get_each_context_1(ctx, each_value_1, i); + + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block_1(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(g, null); + } + } + + group_outros(); + + for (i = each_value_1.length; i < each_blocks.length; i += 1) { + out(i); + } + + check_outros(); + } + + if (!current || dirty[0] & /*dayLabelWidth*/ 8 && g_transform_value !== (g_transform_value = `translate(${/*dayLabelWidth*/ ctx[3]})`)) { + attr(g, "transform", g_transform_value); + } + }, + i(local) { + if (current) return; + + for (let i = 0; i < each_value_1.length; i += 1) { + transition_in(each_blocks[i]); + } + + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + + current = false; + }, + d(detaching) { + if (if_block) if_block.d(detaching); + if (detaching) detach(g); + destroy_each(each_blocks, detaching); + } + }; +} + +// (2:4) {#if view === 'monthly'} +function create_if_block$1(ctx) { + let each_1_anchor; + let current; + let each_value = /*chunks*/ ctx[13]; + let each_blocks = []; + + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block$2(get_each_context$2(ctx, each_value, i)); + } + + const out = i => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + + return { + c() { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + + each_1_anchor = empty(); + }, + m(target, anchor) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(target, anchor); + } + + insert(target, each_1_anchor, anchor); + current = true; + }, + p(ctx, dirty) { + if (dirty[0] & /*cellGap, cellRadius, cellRect, cellSize, chunks, fontColor, fontFamily, fontSize, monthGap, monthLabelHeight, monthLabels*/ 14311) { + each_value = /*chunks*/ ctx[13]; + let i; + + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context$2(ctx, each_value, i); + + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block$2(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor); + } + } + + group_outros(); + + for (i = each_value.length; i < each_blocks.length; i += 1) { + out(i); + } + + check_outros(); + } + }, + i(local) { + if (current) return; + + for (let i = 0; i < each_value.length; i += 1) { + transition_in(each_blocks[i]); + } + + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + + current = false; + }, + d(detaching) { + destroy_each(each_blocks, detaching); + if (detaching) detach(each_1_anchor); + } + }; +} + +// (20:8) {#if dayLabelWidth > 0} +function create_if_block_2(ctx) { + let each_1_anchor; + let each_value_2 = /*dayLabels*/ ctx[4]; + let each_blocks = []; + + for (let i = 0; i < each_value_2.length; i += 1) { + each_blocks[i] = create_each_block_2(get_each_context_2(ctx, each_value_2, i)); + } + + return { + c() { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + + each_1_anchor = empty(); + }, + m(target, anchor) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(target, anchor); + } + + insert(target, each_1_anchor, anchor); + }, + p(ctx, dirty) { + if (dirty[0] & /*fontColor, fontFamily, fontSize, dayLabelPosition, dayLabels*/ 65776) { + each_value_2 = /*dayLabels*/ ctx[4]; + let i; + + for (i = 0; i < each_value_2.length; i += 1) { + const child_ctx = get_each_context_2(ctx, each_value_2, i); + + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + } else { + each_blocks[i] = create_each_block_2(child_ctx); + each_blocks[i].c(); + each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor); + } + } + + for (; i < each_blocks.length; i += 1) { + each_blocks[i].d(1); + } + + each_blocks.length = each_value_2.length; + } + }, + d(detaching) { + destroy_each(each_blocks, detaching); + if (detaching) detach(each_1_anchor); + } + }; +} + +// (21:12) {#each dayLabels as label, index} +function create_each_block_2(ctx) { + let text_1; + let t_value = /*label*/ ctx[30] + ""; + let t; + let text_1_y_value; + + return { + c() { + text_1 = svg_element("text"); + t = text(t_value); + attr(text_1, "alignment-baseline", "middle"); + attr(text_1, "fill", /*fontColor*/ ctx[5]); + attr(text_1, "font-family", /*fontFamily*/ ctx[6]); + attr(text_1, "font-size", /*fontSize*/ ctx[7]); + attr(text_1, "x", "0"); + attr(text_1, "y", text_1_y_value = /*dayLabelPosition*/ ctx[16](/*index*/ ctx[28])); + }, + m(target, anchor) { + insert(target, text_1, anchor); + append(text_1, t); + }, + p(ctx, dirty) { + if (dirty[0] & /*dayLabels*/ 16 && t_value !== (t_value = /*label*/ ctx[30] + "")) set_data(t, t_value); + + if (dirty[0] & /*fontColor*/ 32) { + attr(text_1, "fill", /*fontColor*/ ctx[5]); + } + + if (dirty[0] & /*fontFamily*/ 64) { + attr(text_1, "font-family", /*fontFamily*/ ctx[6]); + } + + if (dirty[0] & /*fontSize*/ 128) { + attr(text_1, "font-size", /*fontSize*/ ctx[7]); + } + + if (dirty[0] & /*dayLabelPosition*/ 65536 && text_1_y_value !== (text_1_y_value = /*dayLabelPosition*/ ctx[16](/*index*/ ctx[28]))) { + attr(text_1, "y", text_1_y_value); + } + }, + d(detaching) { + if (detaching) detach(text_1); + } + }; +} + +// (43:16) {#if monthLabelHeight > 0 && isNewMonth(chunks, index)} +function create_if_block_1(ctx) { + let text_1; + let t_value = /*monthLabels*/ ctx[10][/*chunk*/ ctx[26][0].date.getMonth()] + ""; + let t; + let text_1_x_value; + + return { + c() { + text_1 = svg_element("text"); + t = text(t_value); + attr(text_1, "alignment-baseline", "hanging"); + attr(text_1, "fill", /*fontColor*/ ctx[5]); + attr(text_1, "font-family", /*fontFamily*/ ctx[6]); + attr(text_1, "font-size", /*fontSize*/ ctx[7]); + attr(text_1, "x", text_1_x_value = /*cellRect*/ ctx[12] * /*index*/ ctx[28]); + }, + m(target, anchor) { + insert(target, text_1, anchor); + append(text_1, t); + }, + p(ctx, dirty) { + if (dirty[0] & /*monthLabels, chunks*/ 9216 && t_value !== (t_value = /*monthLabels*/ ctx[10][/*chunk*/ ctx[26][0].date.getMonth()] + "")) set_data(t, t_value); + + if (dirty[0] & /*fontColor*/ 32) { + attr(text_1, "fill", /*fontColor*/ ctx[5]); + } + + if (dirty[0] & /*fontFamily*/ 64) { + attr(text_1, "font-family", /*fontFamily*/ ctx[6]); + } + + if (dirty[0] & /*fontSize*/ 128) { + attr(text_1, "font-size", /*fontSize*/ ctx[7]); + } + + if (dirty[0] & /*cellRect*/ 4096 && text_1_x_value !== (text_1_x_value = /*cellRect*/ ctx[12] * /*index*/ ctx[28])) { + attr(text_1, "x", text_1_x_value); + } + }, + d(detaching) { + if (detaching) detach(text_1); + } + }; +} + +// (34:12) {#each chunks as chunk, index} +function create_each_block_1(ctx) { + let week; + let show_if = /*monthLabelHeight*/ ctx[9] > 0 && /*isNewMonth*/ ctx[17](/*chunks*/ ctx[13], /*index*/ ctx[28]); + let if_block_anchor; + let current; + + week = new Week({ + props: { + cellRadius: /*cellRadius*/ ctx[1], + cellRect: /*cellRect*/ ctx[12], + cellSize: /*cellSize*/ ctx[2], + days: /*chunk*/ ctx[26], + index: /*index*/ ctx[28], + monthLabelHeight: /*monthLabelHeight*/ ctx[9] + } + }); + + let if_block = show_if && create_if_block_1(ctx); + + return { + c() { + create_component(week.$$.fragment); + if (if_block) if_block.c(); + if_block_anchor = empty(); + }, + m(target, anchor) { + mount_component(week, target, anchor); + if (if_block) if_block.m(target, anchor); + insert(target, if_block_anchor, anchor); + current = true; + }, + p(ctx, dirty) { + const week_changes = {}; + if (dirty[0] & /*cellRadius*/ 2) week_changes.cellRadius = /*cellRadius*/ ctx[1]; + if (dirty[0] & /*cellRect*/ 4096) week_changes.cellRect = /*cellRect*/ ctx[12]; + if (dirty[0] & /*cellSize*/ 4) week_changes.cellSize = /*cellSize*/ ctx[2]; + if (dirty[0] & /*chunks*/ 8192) week_changes.days = /*chunk*/ ctx[26]; + if (dirty[0] & /*monthLabelHeight*/ 512) week_changes.monthLabelHeight = /*monthLabelHeight*/ ctx[9]; + week.$set(week_changes); + if (dirty[0] & /*monthLabelHeight, chunks*/ 8704) show_if = /*monthLabelHeight*/ ctx[9] > 0 && /*isNewMonth*/ ctx[17](/*chunks*/ ctx[13], /*index*/ ctx[28]); + + if (show_if) { + if (if_block) { + if_block.p(ctx, dirty); + } else { + if_block = create_if_block_1(ctx); + if_block.c(); + if_block.m(if_block_anchor.parentNode, if_block_anchor); + } + } else if (if_block) { + if_block.d(1); + if_block = null; + } + }, + i(local) { + if (current) return; + transition_in(week.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(week.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(week, detaching); + if (if_block) if_block.d(detaching); + if (detaching) detach(if_block_anchor); + } + }; +} + +// (3:8) {#each chunks as chunk, index} +function create_each_block$2(ctx) { + let month; + let current; + + month = new Month({ + props: { + cellGap: /*cellGap*/ ctx[0], + cellRadius: /*cellRadius*/ ctx[1], + cellRect: /*cellRect*/ ctx[12], + cellSize: /*cellSize*/ ctx[2], + days: /*chunk*/ ctx[26], + fontColor: /*fontColor*/ ctx[5], + fontFamily: /*fontFamily*/ ctx[6], + fontSize: /*fontSize*/ ctx[7], + index: /*index*/ ctx[28], + monthGap: /*monthGap*/ ctx[8], + monthLabelHeight: /*monthLabelHeight*/ ctx[9], + monthLabels: /*monthLabels*/ ctx[10] + } + }); + + return { + c() { + create_component(month.$$.fragment); + }, + m(target, anchor) { + mount_component(month, target, anchor); + current = true; + }, + p(ctx, dirty) { + const month_changes = {}; + if (dirty[0] & /*cellGap*/ 1) month_changes.cellGap = /*cellGap*/ ctx[0]; + if (dirty[0] & /*cellRadius*/ 2) month_changes.cellRadius = /*cellRadius*/ ctx[1]; + if (dirty[0] & /*cellRect*/ 4096) month_changes.cellRect = /*cellRect*/ ctx[12]; + if (dirty[0] & /*cellSize*/ 4) month_changes.cellSize = /*cellSize*/ ctx[2]; + if (dirty[0] & /*chunks*/ 8192) month_changes.days = /*chunk*/ ctx[26]; + if (dirty[0] & /*fontColor*/ 32) month_changes.fontColor = /*fontColor*/ ctx[5]; + if (dirty[0] & /*fontFamily*/ 64) month_changes.fontFamily = /*fontFamily*/ ctx[6]; + if (dirty[0] & /*fontSize*/ 128) month_changes.fontSize = /*fontSize*/ ctx[7]; + if (dirty[0] & /*monthGap*/ 256) month_changes.monthGap = /*monthGap*/ ctx[8]; + if (dirty[0] & /*monthLabelHeight*/ 512) month_changes.monthLabelHeight = /*monthLabelHeight*/ ctx[9]; + if (dirty[0] & /*monthLabels*/ 1024) month_changes.monthLabels = /*monthLabels*/ ctx[10]; + month.$set(month_changes); + }, + i(local) { + if (current) return; + transition_in(month.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(month.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(month, detaching); + } + }; +} + +function create_fragment$3(ctx) { + let svg; + let current_block_type_index; + let if_block; + let svg_viewBox_value; + let current; + const if_block_creators = [create_if_block$1, create_else_block]; + const if_blocks = []; + + function select_block_type(ctx, dirty) { + if (/*view*/ ctx[11] === "monthly") return 0; + return 1; + } + + current_block_type_index = select_block_type(ctx); + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + + return { + c() { + svg = svg_element("svg"); + if_block.c(); + attr(svg, "viewBox", svg_viewBox_value = `0 0 ${/*width*/ ctx[15]} ${/*height*/ ctx[14]}`); + }, + m(target, anchor) { + insert(target, svg, anchor); + if_blocks[current_block_type_index].m(svg, null); + current = true; + }, + p(ctx, dirty) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type(ctx); + + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx, dirty); + } else { + group_outros(); + + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + + check_outros(); + if_block = if_blocks[current_block_type_index]; + + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + if_block.c(); + } else { + if_block.p(ctx, dirty); + } + + transition_in(if_block, 1); + if_block.m(svg, null); + } + + if (!current || dirty[0] & /*width, height*/ 49152 && svg_viewBox_value !== (svg_viewBox_value = `0 0 ${/*width*/ ctx[15]} ${/*height*/ ctx[14]}`)) { + attr(svg, "viewBox", svg_viewBox_value); + } + }, + i(local) { + if (current) return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if (detaching) detach(svg); + if_blocks[current_block_type_index].d(); + } + }; +} + +function instance$3($$self, $$props, $$invalidate) { + let cellRect; + let calendar; + let chunks; + let weekRect; + let height; + let width; + let dayLabelPosition; + let { allowOverflow = false } = $$props; + let { cellGap = 2 } = $$props; + let { cellRadius = 0 } = $$props; + let { cellSize = 10 } = $$props; + let { colors = ["#c6e48b", "#7bc96f", "#239a3b", "#196127"] } = $$props; + let { data = [] } = $$props; + let { dayLabelWidth = 20 } = $$props; + let { dayLabels = ["", "Mon", "", "Wed", "", "Fri", ""] } = $$props; + let { emptyColor = "#ebedf0" } = $$props; + let { endDate = null } = $$props; + let { fontColor = "#333" } = $$props; + let { fontFamily = "sans-serif" } = $$props; + let { fontSize = 8 } = $$props; + let { monthGap = 2 } = $$props; + let { monthLabelHeight = 12 } = $$props; + + let { monthLabels = [ + "Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec" + ] } = $$props; + + let { startDate = null } = $$props; + let { view = "weekly" } = $$props; + + const isNewMonth = (chunks, index) => { + const chunk = chunks[index]; + const prev = chunks[index - 1]; + + if (!prev) { + return true; + } + + if (!prev.length || !chunk.length) { + return false; + } + + const currentIndex = chunk[0].date.getMonth(); + const prevIndex = prev[0].date.getMonth(); + return index < chunks.length && index < chunks.length - 1 && (currentIndex > prevIndex || currentIndex === 0 && prevIndex === 11); + }; + + $$self.$$set = $$props => { + if ("allowOverflow" in $$props) $$invalidate(18, allowOverflow = $$props.allowOverflow); + if ("cellGap" in $$props) $$invalidate(0, cellGap = $$props.cellGap); + if ("cellRadius" in $$props) $$invalidate(1, cellRadius = $$props.cellRadius); + if ("cellSize" in $$props) $$invalidate(2, cellSize = $$props.cellSize); + if ("colors" in $$props) $$invalidate(19, colors = $$props.colors); + if ("data" in $$props) $$invalidate(20, data = $$props.data); + if ("dayLabelWidth" in $$props) $$invalidate(3, dayLabelWidth = $$props.dayLabelWidth); + if ("dayLabels" in $$props) $$invalidate(4, dayLabels = $$props.dayLabels); + if ("emptyColor" in $$props) $$invalidate(21, emptyColor = $$props.emptyColor); + if ("endDate" in $$props) $$invalidate(22, endDate = $$props.endDate); + if ("fontColor" in $$props) $$invalidate(5, fontColor = $$props.fontColor); + if ("fontFamily" in $$props) $$invalidate(6, fontFamily = $$props.fontFamily); + if ("fontSize" in $$props) $$invalidate(7, fontSize = $$props.fontSize); + if ("monthGap" in $$props) $$invalidate(8, monthGap = $$props.monthGap); + if ("monthLabelHeight" in $$props) $$invalidate(9, monthLabelHeight = $$props.monthLabelHeight); + if ("monthLabels" in $$props) $$invalidate(10, monthLabels = $$props.monthLabels); + if ("startDate" in $$props) $$invalidate(23, startDate = $$props.startDate); + if ("view" in $$props) $$invalidate(11, view = $$props.view); + }; + + $$self.$$.update = () => { + if ($$self.$$.dirty[0] & /*cellSize, cellGap*/ 5) { + $$invalidate(12, cellRect = cellSize + cellGap); + } + + if ($$self.$$.dirty[0] & /*allowOverflow, colors, data, emptyColor, endDate, startDate, view*/ 16517120) { + $$invalidate(24, calendar = getCalendar({ + allowOverflow, + colors, + data, + emptyColor, + endDate, + startDate, + view + })); + } + + if ($$self.$$.dirty[0] & /*view, allowOverflow, calendar, endDate, startDate*/ 29624320) { + $$invalidate(13, chunks = view === "monthly" + ? chunkMonths({ + allowOverflow, + calendar, + endDate, + startDate + }) + : chunkWeeks({ + allowOverflow, + calendar, + endDate, + startDate + })); + } + + if ($$self.$$.dirty[0] & /*cellRect, cellGap*/ 4097) { + $$invalidate(25, weekRect = 7 * cellRect - cellGap); + } + + if ($$self.$$.dirty[0] & /*view, cellRect, cellGap, monthLabelHeight, weekRect*/ 33561089) { + $$invalidate(14, height = view === "monthly" + ? 6 * cellRect - cellGap + monthLabelHeight + : weekRect + monthLabelHeight); // <- max of 6 rows in monthly view + } + + if ($$self.$$.dirty[0] & /*view, weekRect, monthGap, chunks, cellRect, cellGap, dayLabelWidth*/ 33569033) { + $$invalidate(15, width = view === "monthly" + ? (weekRect + monthGap) * chunks.length - monthGap + : cellRect * chunks.length - cellGap + dayLabelWidth); + } + + if ($$self.$$.dirty[0] & /*cellRect, monthLabelHeight*/ 4608) { + $$invalidate(16, dayLabelPosition = index => { + return cellRect * index + cellRect / 2 + monthLabelHeight; + }); + } + }; + + return [ + cellGap, + cellRadius, + cellSize, + dayLabelWidth, + dayLabels, + fontColor, + fontFamily, + fontSize, + monthGap, + monthLabelHeight, + monthLabels, + view, + cellRect, + chunks, + height, + width, + dayLabelPosition, + isNewMonth, + allowOverflow, + colors, + data, + emptyColor, + endDate, + startDate, + calendar, + weekRect + ]; +} + +class SvelteHeatmap extends SvelteComponent { + constructor(options) { + super(); + + init( + this, + options, + instance$3, + create_fragment$3, + safe_not_equal, + { + allowOverflow: 18, + cellGap: 0, + cellRadius: 1, + cellSize: 2, + colors: 19, + data: 20, + dayLabelWidth: 3, + dayLabels: 4, + emptyColor: 21, + endDate: 22, + fontColor: 5, + fontFamily: 6, + fontSize: 7, + monthGap: 8, + monthLabelHeight: 9, + monthLabels: 10, + startDate: 23, + view: 11 + }, + [-1, -1] + ); + } +} + +SvelteHeatmap.VERSION = '1.0.2'; + +/* src/svelte/ActivityHeatmap.svelte generated by Svelte v3.32.3 */ + +function create_fragment$4(ctx) { + let svelteheatmap; + let current; + + svelteheatmap = new SvelteHeatmap({ + props: { + data: /*data*/ ctx[0], + view: /*type*/ ctx[5], + startDate: /*startDate*/ ctx[7], + endDate: /*endDate*/ ctx[8], + monthLabels: /*monthlabel*/ ctx[6], + allowOverflow: "true", + colors: /*colors*/ ctx[1], + fontColor: /*textColor*/ ctx[2], + emptyColor: /*emptyColor*/ ctx[3], + cellRadius: /*cellRadius*/ ctx[4] + } + }); + + return { + c() { + create_component(svelteheatmap.$$.fragment); + }, + m(target, anchor) { + mount_component(svelteheatmap, target, anchor); + current = true; + }, + p(ctx, [dirty]) { + const svelteheatmap_changes = {}; + if (dirty & /*data*/ 1) svelteheatmap_changes.data = /*data*/ ctx[0]; + if (dirty & /*type*/ 32) svelteheatmap_changes.view = /*type*/ ctx[5]; + if (dirty & /*monthlabel*/ 64) svelteheatmap_changes.monthLabels = /*monthlabel*/ ctx[6]; + if (dirty & /*colors*/ 2) svelteheatmap_changes.colors = /*colors*/ ctx[1]; + if (dirty & /*textColor*/ 4) svelteheatmap_changes.fontColor = /*textColor*/ ctx[2]; + if (dirty & /*emptyColor*/ 8) svelteheatmap_changes.emptyColor = /*emptyColor*/ ctx[3]; + if (dirty & /*cellRadius*/ 16) svelteheatmap_changes.cellRadius = /*cellRadius*/ ctx[4]; + svelteheatmap.$set(svelteheatmap_changes); + }, + i(local) { + if (current) return; + transition_in(svelteheatmap.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(svelteheatmap.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(svelteheatmap, detaching); + } + }; +} + +function instance$4($$self, $$props, $$invalidate) { + let { year } = $$props; + let { data } = $$props; + let { colors = ["#a1dab4", "#42b6c4", "#2c7fb9", "#263494"] } = $$props; + let { textColor } = $$props; + let { emptyColor = "#ecedf0" } = $$props; + let { cellRadius = 1 } = $$props; + let { type = "yearly" } = $$props; + let startDate = `${year}/01/01`; + let endDate = `${year}/12/31`; + + let monthlabel = [ + "", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec" + ]; + + if (type == "monthly") { + monthlabel = [ + "Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec" + ]; + } + + $$self.$$set = $$props => { + if ("year" in $$props) $$invalidate(9, year = $$props.year); + if ("data" in $$props) $$invalidate(0, data = $$props.data); + if ("colors" in $$props) $$invalidate(1, colors = $$props.colors); + if ("textColor" in $$props) $$invalidate(2, textColor = $$props.textColor); + if ("emptyColor" in $$props) $$invalidate(3, emptyColor = $$props.emptyColor); + if ("cellRadius" in $$props) $$invalidate(4, cellRadius = $$props.cellRadius); + if ("type" in $$props) $$invalidate(5, type = $$props.type); + }; + + return [ + data, + colors, + textColor, + emptyColor, + cellRadius, + type, + monthlabel, + startDate, + endDate, + year + ]; +} + +class ActivityHeatmap extends SvelteComponent { + constructor(options) { + super(); + + init(this, options, instance$4, create_fragment$4, safe_not_equal, { + year: 9, + data: 0, + colors: 1, + textColor: 2, + emptyColor: 3, + cellRadius: 4, + type: 5 + }); + } +} + +/* src/svelte/SelectYear.svelte generated by Svelte v3.32.3 */ + +function get_each_context$3(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[4] = list[i]; + child_ctx[6] = i; + return child_ctx; +} + +// (8:2) {#each options as option, i} +function create_each_block$3(ctx) { + let option; + let t_value = /*display_func*/ ctx[2](/*option*/ ctx[4]) + ""; + let t; + + return { + c() { + option = element("option"); + t = text(t_value); + option.__value = /*i*/ ctx[6]; + option.value = option.__value; + }, + m(target, anchor) { + insert(target, option, anchor); + append(option, t); + }, + p(ctx, dirty) { + if (dirty & /*display_func, options*/ 6 && t_value !== (t_value = /*display_func*/ ctx[2](/*option*/ ctx[4]) + "")) set_data(t, t_value); + }, + d(detaching) { + if (detaching) detach(option); + } + }; +} + +function create_fragment$5(ctx) { + let select; + let mounted; + let dispose; + let each_value = /*options*/ ctx[1]; + let each_blocks = []; + + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block$3(get_each_context$3(ctx, each_value, i)); + } + + return { + c() { + select = element("select"); + + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + + attr(select, "class", "selectYear"); + if (/*index*/ ctx[0] === void 0) add_render_callback(() => /*select_change_handler*/ ctx[3].call(select)); + }, + m(target, anchor) { + insert(target, select, anchor); + + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(select, null); + } + + select_option(select, /*index*/ ctx[0]); + + if (!mounted) { + dispose = listen(select, "change", /*select_change_handler*/ ctx[3]); + mounted = true; + } + }, + p(ctx, [dirty]) { + if (dirty & /*display_func, options*/ 6) { + each_value = /*options*/ ctx[1]; + let i; + + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context$3(ctx, each_value, i); + + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + } else { + each_blocks[i] = create_each_block$3(child_ctx); + each_blocks[i].c(); + each_blocks[i].m(select, null); + } + } + + for (; i < each_blocks.length; i += 1) { + each_blocks[i].d(1); + } + + each_blocks.length = each_value.length; + } + + if (dirty & /*index*/ 1) { + select_option(select, /*index*/ ctx[0]); + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) detach(select); + destroy_each(each_blocks, detaching); + mounted = false; + dispose(); + } + }; +} + +function instance$5($$self, $$props, $$invalidate) { + let { options = [] } = $$props; + let { display_func = value => value } = $$props; + let { index = 0 } = $$props; + + function select_change_handler() { + index = select_value(this); + $$invalidate(0, index); + } + + $$self.$$set = $$props => { + if ("options" in $$props) $$invalidate(1, options = $$props.options); + if ("display_func" in $$props) $$invalidate(2, display_func = $$props.display_func); + if ("index" in $$props) $$invalidate(0, index = $$props.index); + }; + + return [index, options, display_func, select_change_handler]; +} + +class SelectYear extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$5, create_fragment$5, safe_not_equal, { options: 1, display_func: 2, index: 0 }); + } +} + +/* src/svelte/Year.svelte generated by Svelte v3.32.3 */ + +function create_fragment$6(ctx) { + let div; + let selectyear; + let updating_value; + let current; + + function selectyear_value_binding(value) { + /*selectyear_value_binding*/ ctx[2](value); + } + + let selectyear_props = { + options: /*options*/ ctx[0], + display_func: func + }; + + if (/*selected*/ ctx[1] !== void 0) { + selectyear_props.value = /*selected*/ ctx[1]; + } + + selectyear = new SelectYear({ props: selectyear_props }); + binding_callbacks.push(() => bind(selectyear, "value", selectyear_value_binding)); + + return { + c() { + div = element("div"); + create_component(selectyear.$$.fragment); + }, + m(target, anchor) { + insert(target, div, anchor); + mount_component(selectyear, div, null); + current = true; + }, + p(ctx, [dirty]) { + const selectyear_changes = {}; + if (dirty & /*options*/ 1) selectyear_changes.options = /*options*/ ctx[0]; + + if (!updating_value && dirty & /*selected*/ 2) { + updating_value = true; + selectyear_changes.value = /*selected*/ ctx[1]; + add_flush_callback(() => updating_value = false); + } + + selectyear.$set(selectyear_changes); + }, + i(local) { + if (current) return; + transition_in(selectyear.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(selectyear.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) detach(div); + destroy_component(selectyear); + } + }; +} + +const func = o => o.year; + +function instance$6($$self, $$props, $$invalidate) { + let { options = [ + { + year: new Date().getFullYear().toString() + } + ] } = $$props; + + let selected; + + function selectyear_value_binding(value) { + selected = value; + $$invalidate(1, selected); + } + + $$self.$$set = $$props => { + if ("options" in $$props) $$invalidate(0, options = $$props.options); + }; + + return [options, selected, selectyear_value_binding]; +} + +class Year extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$6, create_fragment$6, safe_not_equal, { options: 0 }); + } +} + +class ActivityHistoryProcessor { + async run(source, el, settings) { + var _a; + source = source.trim(); + let currentYear = new Date().getFullYear().toString(); + let elCanvas = el.createDiv({ cls: 'ObsidianHistoryBlock' }); + let yearSelect = elCanvas.createDiv({ attr: { id: 'SelectYear' } }); + let boardEL = elCanvas.createDiv({ cls: 'HistoryBoard', attr: { id: 'HistoryBoard' } }); + // Check if project is being tracked + if (!isTracked(source, settings.trackedProjects)) { + // Show warning message + boardEL.setText(`Specified project ${source} is not a tracked project.`); + return; + } + // Valid project, add the different svelte component + // Get year ranges for the specified object + let yearRange = getYearRange(source, settings.activityHistory); + // Add current year to the selection + if (yearRange.every(x => x.year != currentYear)) { + yearRange.unshift({ year: currentYear }); + } + // Add svelte year selection element + new Year({ + props: { + options: yearRange, + }, + target: yearSelect + }); + // Get activity history for specified project + let activity = (_a = getProjectActivityHistory(source, settings.activityHistory)) === null || _a === void 0 ? void 0 : _a.size; + // if no activity history available add placeholder + if (!activity) { + activity = [{ date: `${currentYear}-01-01`, value: 0 }]; + } + // Add svelte activity heatmap element + new ActivityHeatmap({ + props: { + year: new Date().getFullYear().toString(), + data: activity, + colors: [settings.activityColor1, settings.activityColor2, settings.activityColor3, settings.activityColor4], + textColor: settings.textColor, + emptyColor: settings.emptyColor, + cellRadius: settings.cellRadius, + type: settings.type + }, + target: boardEL + }); + // Add listener to update heatmap on Year Selection change + yearSelect.addEventListener('change', (event) => { + // Get selected year + let selectOption = yearSelect.querySelectorAll('option:checked')[0].innerHTML; + // Update the activity heatmap + boardEL.empty(); + new ActivityHeatmap({ + props: { + year: selectOption, + data: activity, + colors: [settings.activityColor1, settings.activityColor2, settings.activityColor3, settings.activityColor4], + textColor: settings.textColor, + emptyColor: settings.emptyColor, + cellRadius: settings.cellRadius + }, + target: boardEL + }); + }); + el.appendChild(elCanvas); + } +} + +const DEFAULT_SETTINGS = { + firstRun: true, + initialized: [{ path: '/', initialized: false }], + trackedProjects: ['/'], + checkpointList: [{ path: '/', date: getTimestamp(), size: 0 }], + activityHistory: [{ path: '/', size: [{ date: getTimestamp(), value: 0 }] }], + activityColor1: '#c6e48b', + activityColor2: '#7bc96f', + activityColor3: '#239a3b', + activityColor4: '#196127', + textColor: '#000000', + emptyColor: '#ecedf0', + cellRadius: 1, + type: 'yearly' +}; + +class ActivityHistoryPlugin extends obsidian.Plugin { + async onload() { + // Load message + await this.loadSettings(); + console.log('Loaded Activity Plugin'); + // Register activity history block renderer + this.registerMarkdownCodeBlockProcessor('ActivityHistory', async (source, el, ctx) => { + const proc = new ActivityHistoryProcessor(); + await proc.run(source, el, this.settings); + }); + // Update all tracked projects on events + setInterval(() => { + if (this.settings.firstRun) { + removeProject('/', this.settings); + addProject('/', this.settings, this.app.vault.getMarkdownFiles()); + this.settings.firstRun = false; + this.saveSettings(); + } + updateActivityAll(this.settings, this.app.vault.getMarkdownFiles()); + this.saveSettings(); + }, 200000); + this.addSettingTab(new ActivityHistorySettingTab(this.app, this)); + } + onunload() { + console.log('unloading activity plugin'); + } + async loadSettings() { + this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); + } + async saveSettings() { + await this.saveData(this.settings); + } +} + +module.exports = ActivityHistoryPlugin; diff --git a/.obsidian/plugins/obsidian-activity-history/manifest.json b/.obsidian/plugins/obsidian-activity-history/manifest.json new file mode 100644 index 0000000..0fbc695 --- /dev/null +++ b/.obsidian/plugins/obsidian-activity-history/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "obsidian-activity-history", + "name": "Activity History", + "version": "0.1.4", + "minAppVersion": "0.10.11", + "description": "Track activity of specified projects, Github like activity board", + "author": "darakah", + "authorUrl": "https://github.com/Darakah/", + "isDesktopOnly": false +} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-activity-history/styles.css b/.obsidian/plugins/obsidian-activity-history/styles.css new file mode 100644 index 0000000..07a77d4 --- /dev/null +++ b/.obsidian/plugins/obsidian-activity-history/styles.css @@ -0,0 +1,30 @@ +.block-language-ActivityHistory { + margin: 1rem 0; +} + +.selectYear { + border-color: none; +} + +.HistoryBoard { + background-color: transparent !important; + padding: 10px; + border-radius: 14px; + width: auto; + height: auto; +} + +.ObsidianHistoryBlock { + background-color: transparent !important; + border-radius: 14px; + width: auto; + height: auto; +} + +.selectYear { + margin: 10px !important; + border-radius: 0 !important; + border-color: transparent !important; + background: #1b1b1b; + color: rgb(201, 201, 201); +} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-gist/main.js b/.obsidian/plugins/obsidian-gist/main.js new file mode 100644 index 0000000..f4e4873 --- /dev/null +++ b/.obsidian/plugins/obsidian-gist/main.js @@ -0,0 +1,237 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ROLLUP +if you want to view the source visit the plugins github repository +*/ + +'use strict'; + +var obsidian = require('obsidian'); + +/*! ***************************************************************************** +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. +***************************************************************************** */ + +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()); + }); +} + +// This file replaces `index.js` in bundlers like webpack or Rollup, + +if (process.env.NODE_ENV !== 'production') { + // All bundlers will remove this block in the production bundle. + if ( + typeof navigator !== 'undefined' && + navigator.product === 'ReactNative' && + typeof crypto === 'undefined' + ) { + throw new Error( + 'React Native does not have a built-in secure random generator. ' + + 'If you don’t need unpredictable IDs use `nanoid/non-secure`. ' + + 'For secure IDs, import `react-native-get-random-values` ' + + 'before Nano ID.' + ) + } + if (typeof msCrypto !== 'undefined' && typeof crypto === 'undefined') { + throw new Error( + 'Import file with `if (!window.crypto) window.crypto = window.msCrypto`' + + ' before importing Nano ID to fix IE 11 support' + ) + } + if (typeof crypto === 'undefined') { + throw new Error( + 'Your browser does not have secure random generator. ' + + 'If you don’t need unpredictable IDs, you can use nanoid/non-secure.' + ) + } +} + +let nanoid = (size = 21) => { + let id = ''; + let bytes = crypto.getRandomValues(new Uint8Array(size)); + + // A compact alternative for `for (var i = 0; i < step; i++)`. + while (size--) { + // It is incorrect to use bytes exceeding the alphabet size. + // The following mask reduces the random byte in the 0-255 value + // range to the 0-63 value range. Therefore, adding hacks, such + // as empty string fallback or magic numbers, is unneccessary because + // the bitmask trims bytes down to the alphabet size. + let byte = bytes[size] & 63; + if (byte < 36) { + // `0-9a-z` + id += byte.toString(36); + } else if (byte < 62) { + // `A-Z` + id += (byte - 26).toString(36).toUpperCase(); + } else if (byte < 63) { + id += '_'; + } else { + id += '-'; + } + } + return id +}; + +const pluginName = "obsidian-gist"; +const obsidianAppOrigin = 'app://obsidian.md'; +class GistProcessor { + constructor() { + this.messageEventHandler = (messageEvent) => { + if (messageEvent.origin !== 'null') { + // a message received from the iFrame with `srcdoc` attribute, the `origin` will be `null`. + return; + } + const sender = messageEvent.data.sender; + // only process message coming from this plugin + if (sender === pluginName) { + const gistUUID = messageEvent.data.gistUUID; + const contentHeight = messageEvent.data.contentHeight; + const gistContainer = document.querySelector('iframe#' + gistUUID); + gistContainer.setAttribute('height', contentHeight); + } + }; + this.processor = (sourceString, el) => __awaiter(this, void 0, void 0, function* () { + const gists = sourceString.trim().split("\n"); + return Promise.all(gists.map((gist) => __awaiter(this, void 0, void 0, function* () { + return this._processGist(el, gist); + }))); + }); + } + // private + _processGist(el, gistString) { + return __awaiter(this, void 0, void 0, function* () { + const pattern = /(?https?:\/\/)?(?gist\.github\.com\/)?((?\w+)\/)?(?\w+)(\#(?.+))?/; + const matchResult = gistString.match(pattern).groups; + const gistID = matchResult.gistID; + if (gistID === undefined) { + return this._showError(el, gistString, `Could not found a valid Gist ID, please make sure your content and format is correct.`); + } + let gistURL = `https://gist.github.com/${gistID}.json`; + if (matchResult.filename !== undefined) { + gistURL = `${gistURL}?file=${matchResult.filename}`; + } + try { + const response = yield fetch(gistURL); + if (response.ok) { + const gistJSON = yield response.json(); + return this._insertGistElement(el, gistID, gistJSON); + } + else { + return this._showError(el, gistString, `Could not fetch the Gist info from GitHub server. (Code: ${response.status})`); + } + } + catch (error) { + return this._showError(el, gistString, `Could not fetch the Gist from GitHub server. (Error: ${error})`); + } + }); + } + _insertGistElement(el, gistID, gistJSON) { + return __awaiter(this, void 0, void 0, function* () { + // generate an uuid for each gist element + const gistUUID = `${pluginName}-${gistID}-${nanoid()}`; + // container + const container = document.createElement('iframe'); + container.id = gistUUID; + container.classList.add(`${pluginName}-container`); + container.setAttribute('sandbox', 'allow-scripts allow-top-navigation-by-user-activation'); + container.setAttribute('loading', 'lazy'); + // reset the default things on HTML + const resetStylesheet = ` + + `; + // height adjustment script + const heightAdjustmentScript = ` + + `; + // build stylesheet link + const stylesheetLink = document.createElement('link'); + stylesheetLink.rel = "stylesheet"; + stylesheetLink.href = gistJSON.stylesheet; + // hack to make links open in the parent + const parentLinkHack = document.createElement('base'); + parentLinkHack.target = "_parent"; + // Inject content into the iframe + container.srcdoc = ` + + + + ${resetStylesheet} + ${parentLinkHack.outerHTML} + ${heightAdjustmentScript} + + + ${stylesheetLink.outerHTML} + + + + ${gistJSON.div} + + + `; + // insert container into the DOM + el.appendChild(container); + }); + } + _showError(el, gistIDAndFilename, errorMessage = '') { + return __awaiter(this, void 0, void 0, function* () { + const errorText = ` +Failed to load the Gist (${gistIDAndFilename}). + +Error: + + ${errorMessage} + `.trim(); + el.createEl('pre', { text: errorText }); + }); + } +} + +class GistPlugin extends obsidian.Plugin { + onload() { + return __awaiter(this, void 0, void 0, function* () { + const gistProcessor = new GistProcessor(); + this.registerDomEvent(window, "message", gistProcessor.messageEventHandler); + this.registerMarkdownCodeBlockProcessor("gist", gistProcessor.processor); + }); + } +} + +module.exports = GistPlugin; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 diff --git a/.obsidian/plugins/obsidian-gist/manifest.json b/.obsidian/plugins/obsidian-gist/manifest.json new file mode 100644 index 0000000..da87a74 --- /dev/null +++ b/.obsidian/plugins/obsidian-gist/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "obsidian-gist", + "name": "Gist", + "version": "0.7.0", + "minAppVersion": "0.9.12", + "description": "This is a plugin to display the GitHub Gist.", + "author": "Jun Lin", + "authorUrl": "https://github.com/linjunpop/obsidian-gist", + "isDesktopOnly": false +} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-gist/styles.css b/.obsidian/plugins/obsidian-gist/styles.css new file mode 100644 index 0000000..264801b --- /dev/null +++ b/.obsidian/plugins/obsidian-gist/styles.css @@ -0,0 +1,4 @@ +.block-language-gist > iframe { + width: 100%; + border: 0; +} diff --git a/.obsidian/plugins/obsidian-git/main.js b/.obsidian/plugins/obsidian-git/main.js new file mode 100644 index 0000000..6beca8f --- /dev/null +++ b/.obsidian/plugins/obsidian-git/main.js @@ -0,0 +1,6760 @@ +'use strict'; + +var obsidian = require('obsidian'); +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 }; } + +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(); + }); + }); + }; + 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 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) => 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.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; + +}); + +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 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(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 attempted = false; + let rejection; + function attemptClose(exitCode, event = 'retry') { + // closing when there is content, terminate immediately + if (attempted || stdErr.length || stdOut.length) { + logger.info(`exitCode=%s event=%s rejection=%o`, exitCode, event, rejection); + done({ + stdOut, + stdErr, + exitCode, + rejection, + }); + attempted = true; + } + // first attempt at closing but no content yet, wait briefly for the close/exit that may follow + if (!attempted) { + attempted = true; + setTimeout(() => attemptClose(exitCode, 'deferred'), 50); + logger('received %s event before content on stdOut/stdErr', event); + } + } + logger.info(`%s %o`, command, args); + logger('%O', spawnOptions); + const spawned = child_process_1__default['default'].spawn(command, args, spawnOptions); + spawned.stdout.on('data', onDataReceived(stdOut, 'stdOut', logger, outputLogger.step('stdOut'))); + spawned.stderr.on('data', onDataReceived(stdErr, 'stdErr', logger, outputLogger.step('stdErr'))); + spawned.on('error', onErrorReceived(stdErr, logger)); + spawned.on('close', (code) => attemptClose(code, 'close')); + spawned.on('exit', (code) => attemptClose(code, 'exit')); + if (outputHandler) { + logger(`Passing child process stdOut/stdErr to custom outputHandler`); + outputHandler(command, spawned.stdout, spawned.stderr, [...args]); + } + this._plugins.exec('spawn.after', undefined, Object.assign(Object.assign({}, pluginContext(task, args)), { spawned, kill(reason) { + if (spawned.killed) { + return; + } + rejection = reason; + spawned.kill('SIGINT'); + } })); + }); + }); + } +} +exports.GitExecutorChain = GitExecutorChain; +function pluginContext(task, commands) { + return { + method: utils.first(task.commands) || '', + commands, + }; +} +function onErrorReceived(target, logger) { + return (err) => { + logger(`[ERROR] child process exception %o`, err); + target.push(Buffer.from(String(err.stack), 'ascii')); + }; +} +function onDataReceived(target, name, logger, output) { + return (buffer) => { + logger(`%s received %L bytes`, name, buffer); + output(`%B`, buffer); + target.push(buffer); + }; +} + +}); + +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 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 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)); + } + 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(path); + } + return _this; + } + SimpleGit.prototype.status = function () { + return __awaiter(this, void 0, void 0, function () { + var status; + 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, + staged: status.staged, + conflicted: status.conflicted, + }]; + } + }); + }); + }; + 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 () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, this.git.init(false)]; + 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 () { + 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(function (err) { return _this.onError(err); })]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); + }; + 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, +}; +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: "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(); + 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"); + 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.pullChangesFromRemote = function () { + return __awaiter(this, void 0, void 0, function () { + var filesUpdated, status_1; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + if (!!this.gitReady) return [3 /*break*/, 2]; + return [4 /*yield*/, this.init()]; + case 1: + _a.sent(); + _a.label = 2; + case 2: + if (!this.gitReady) + return [2 /*return*/]; + return [4 /*yield*/, this.gitManager.pull()]; + case 3: + filesUpdated = _a.sent(); + if (filesUpdated > 0) { + this.displayMessage("Pulled new changes. " + filesUpdated + " files updated"); + } + else { + this.displayMessage("Everything is up-to-date"); + } + if (!(this.gitManager instanceof SimpleGit)) return [3 /*break*/, 5]; + return [4 /*yield*/, this.gitManager.status()]; + case 4: + status_1 = _a.sent(); + if (status_1.conflicted.length > 0) { + this.displayError("You have " + status_1.conflicted.length + " conflict files"); + } + _a.label = 5; + case 5: + 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, pulledFilesLength, status_3, _a, pushedFiles; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: + if (!!this.gitReady) return [3 /*break*/, 2]; + return [4 /*yield*/, this.init()]; + case 1: + _b.sent(); + _b.label = 2; + case 2: + if (!this.gitReady) + return [2 /*return*/]; + if (!!fromAutoBackup) return [3 /*break*/, 4]; + file = this.app.vault.getAbstractFileByPath(this.conflictOutputFile); + return [4 /*yield*/, this.app.vault.delete(file)]; + case 3: + _b.sent(); + _b.label = 4; + case 4: + if (!(this.gitManager instanceof SimpleGit)) return [3 /*break*/, 6]; + return [4 /*yield*/, this.gitManager.status()]; + case 5: + 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 = 6; + case 6: return [4 /*yield*/, this.gitManager.status()]; + case 7: + changedFiles = (_b.sent()).changed; + if (!(changedFiles.length !== 0)) return [3 /*break*/, 9]; + return [4 /*yield*/, this.gitManager.commitAll(commitMessage)]; + case 8: + commitedFiles = _b.sent(); + this.displayMessage("Committed " + commitedFiles + " files"); + return [3 /*break*/, 10]; + case 9: + this.displayMessage("No changes to commit"); + _b.label = 10; + case 10: + if (!!this.settings.disablePush) return [3 /*break*/, 21]; + return [4 /*yield*/, this.gitManager.branchInfo()]; + case 11: + if (!(_b.sent()).tracking) { + this.displayError("Did not push. No tracking branch is set! Please set one in the settings", 10000); + this.setState(PluginState.idle); + return [2 /*return*/]; + } + return [4 /*yield*/, this.gitManager.canPush()]; + case 12: + if (!_b.sent()) return [3 /*break*/, 20]; + if (!this.settings.pullBeforePush) return [3 /*break*/, 14]; + return [4 /*yield*/, this.gitManager.pull()]; + case 13: + pulledFilesLength = _b.sent(); + if (pulledFilesLength > 0) { + this.displayMessage("Pulled " + pulledFilesLength + " files from remote"); + } + _b.label = 14; + case 14: + _a = this.gitManager instanceof SimpleGit; + if (!_a) return [3 /*break*/, 16]; + return [4 /*yield*/, this.gitManager.status()]; + case 15: + _a = (status_3 = _b.sent()).conflicted.length > 0; + _b.label = 16; + case 16: + if (!_a) return [3 /*break*/, 17]; + this.displayError("Cannot push. You have " + status_3.conflicted.length + " conflict files"); + this.handleConflict(status_3.conflicted); + return [2 /*return*/]; + case 17: return [4 /*yield*/, this.gitManager.push()]; + case 18: + pushedFiles = _b.sent(); + this.lastUpdate = Date.now(); + this.displayMessage("Pushed " + pushedFiles + " files to remote"); + _b.label = 19; + case 19: return [3 /*break*/, 21]; + case 20: + this.displayMessage("No changes to push"); + _b.label = 21; + case 21: + 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.writeAndOpenFile = function (text) { + return __awaiter(this, void 0, void 0, function () { + var fileIsAlreadyOpened; + var _this = this; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, this.app.vault.adapter.write(this.conflictOutputFile, text)]; + case 1: + _a.sent(); + fileIsAlreadyOpened = false; + this.app.workspace.iterateAllLeaves(function (leaf) { + if (leaf.getDisplayText() != "" && _this.conflictOutputFile.startsWith(leaf.getDisplayText())) { + fileIsAlreadyOpened = true; + } + }); + if (!fileIsAlreadyOpened) { + this.app.workspace.openLinkText(this.conflictOutputFile, "/", true); + } + return [2 /*return*/]; + } + }); + }); + }; + // region: displaying / formatting messages + ObsidianGit.prototype.displayMessage = function (message, timeout) { + var _a; + if (timeout === void 0) { timeout = 4 * 1000; } + (_a = this.statusBar) === null || _a === void 0 ? void 0 : _a.displayMessage(message.toLowerCase(), timeout); + if (!this.settings.disablePopups) { + new obsidian.Notice(message); + } + console.log("git obsidian message: " + message); + }; + ObsidianGit.prototype.displayError = function (message, timeout) { + var _a; + if (timeout === void 0) { timeout = 0; } + new obsidian.Notice(message); + console.log("git obsidian error: " + message); + (_a = this.statusBar) === null || _a === void 0 ? void 0 : _a.displayMessage(message.toLowerCase(), timeout); + }; + 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","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/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/@kwsites/promise-deferred/dist/index.js","node_modules/simple-git/src/lib/runners/scheduler.js","node_modules/simple-git/src/lib/tasks/apply-patch.js","node_modules/simple-git/src/lib/responses/BranchDeleteSummary.js","node_modules/simple-git/src/lib/parsers/parse-branch-delete.js","node_modules/simple-git/src/lib/responses/BranchSummary.js","node_modules/simple-git/src/lib/parsers/parse-branch.js","node_modules/simple-git/src/lib/tasks/branch.js","node_modules/simple-git/src/lib/responses/CheckIgnore.js","node_modules/simple-git/src/lib/tasks/check-ignore.js","node_modules/simple-git/src/lib/tasks/clone.js","node_modules/simple-git/src/lib/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}","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}","\"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.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;\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.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(\"./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 attempted = false;\n                let rejection;\n                function attemptClose(exitCode, event = 'retry') {\n                    // closing when there is content, terminate immediately\n                    if (attempted || stdErr.length || stdOut.length) {\n                        logger.info(`exitCode=%s event=%s rejection=%o`, exitCode, event, rejection);\n                        done({\n                            stdOut,\n                            stdErr,\n                            exitCode,\n                            rejection,\n                        });\n                        attempted = true;\n                    }\n                    // first attempt at closing but no content yet, wait briefly for the close/exit that may follow\n                    if (!attempted) {\n                        attempted = true;\n                        setTimeout(() => attemptClose(exitCode, 'deferred'), 50);\n                        logger('received %s event before content on stdOut/stdErr', event);\n                    }\n                }\n                logger.info(`%s %o`, command, args);\n                logger('%O', spawnOptions);\n                const spawned = child_process_1.spawn(command, args, spawnOptions);\n                spawned.stdout.on('data', onDataReceived(stdOut, 'stdOut', logger, outputLogger.step('stdOut')));\n                spawned.stderr.on('data', onDataReceived(stdErr, 'stdErr', logger, outputLogger.step('stdErr')));\n                spawned.on('error', onErrorReceived(stdErr, logger));\n                spawned.on('close', (code) => attemptClose(code, 'close'));\n                spawned.on('exit', (code) => attemptClose(code, 'exit'));\n                if (outputHandler) {\n                    logger(`Passing child process stdOut/stdErr to custom outputHandler`);\n                    outputHandler(command, spawned.stdout, spawned.stderr, [...args]);\n                }\n                this._plugins.exec('spawn.after', undefined, Object.assign(Object.assign({}, pluginContext(task, args)), { spawned, kill(reason) {\n                        if (spawned.killed) {\n                            return;\n                        }\n                        rejection = reason;\n                        spawned.kill('SIGINT');\n                    } }));\n            });\n        });\n    }\n}\nexports.GitExecutorChain = GitExecutorChain;\nfunction pluginContext(task, commands) {\n    return {\n        method: utils_1.first(task.commands) || '',\n        commands,\n    };\n}\nfunction onErrorReceived(target, logger) {\n    return (err) => {\n        logger(`[ERROR] child process exception %o`, err);\n        target.push(Buffer.from(String(err.stack), 'ascii'));\n    };\n}\nfunction onDataReceived(target, name, logger, output) {\n    return (buffer) => {\n        logger(`%s received %L bytes`, name, buffer);\n        output(`%B`, buffer);\n        target.push(buffer);\n    };\n}\n//# sourceMappingURL=git-executor-chain.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GitExecutor = void 0;\nconst git_executor_chain_1 = require(\"./git-executor-chain\");\nclass GitExecutor {\n    constructor(binary = 'git', cwd, _scheduler, _plugins) {\n        this.binary = binary;\n        this.cwd = cwd;\n        this._scheduler = _scheduler;\n        this._plugins = _plugins;\n        this._chain = new git_executor_chain_1.GitExecutorChain(this, this._scheduler, this._plugins);\n    }\n    chain() {\n        return new git_executor_chain_1.GitExecutorChain(this, this._scheduler, this._plugins);\n    }\n    push(task) {\n        return this._chain.push(task);\n    }\n}\nexports.GitExecutor = GitExecutor;\n//# sourceMappingURL=git-executor.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.taskCallback = void 0;\nconst git_response_error_1 = require(\"./errors/git-response-error\");\nconst utils_1 = require(\"./utils\");\nfunction taskCallback(task, response, callback = utils_1.NOOP) {\n    const onSuccess = (data) => {\n        callback(null, data);\n    };\n    const onError = (err) => {\n        if ((err === null || err === void 0 ? void 0 : err.task) === task) {\n            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.createDeferred = exports.deferred = void 0;\n/**\n * Creates a new `DeferredPromise`\n *\n * ```typescript\n import {deferred} from '@kwsites/promise-deferred`;\n ```\n */\nfunction deferred() {\n    let done;\n    let fail;\n    let status = 'pending';\n    const promise = new Promise((_done, _fail) => {\n        done = _done;\n        fail = _fail;\n    });\n    return {\n        promise,\n        done(result) {\n            if (status === 'pending') {\n                status = 'resolved';\n                done(result);\n            }\n        },\n        fail(error) {\n            if (status === 'pending') {\n                status = 'rejected';\n                fail(error);\n            }\n        },\n        get fulfilled() {\n            return status !== 'pending';\n        },\n        get status() {\n            return status;\n        },\n    };\n}\nexports.deferred = deferred;\n/**\n * Alias of the exported `deferred` function, to help consumers wanting to use `deferred` as the\n * local variable name rather than the factory import name, without needing to rename on import.\n *\n * ```typescript\n import {createDeferred} from '@kwsites/promise-deferred`;\n ```\n */\nexports.createDeferred = deferred;\n/**\n * Default export allows use as:\n *\n * ```typescript\n import deferred from '@kwsites/promise-deferred`;\n ```\n */\nexports.default = deferred;\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Scheduler = void 0;\nconst utils_1 = require(\"../utils\");\nconst promise_deferred_1 = require(\"@kwsites/promise-deferred\");\nconst git_logger_1 = require(\"../git-logger\");\nconst createScheduledTask = (() => {\n    let id = 0;\n    return () => {\n        id++;\n        const { promise, done } = promise_deferred_1.createDeferred();\n        return {\n            promise,\n            done,\n            id,\n        };\n    };\n})();\nclass Scheduler {\n    constructor(concurrency = 2) {\n        this.concurrency = concurrency;\n        this.logger = git_logger_1.createLogger('', 'scheduler');\n        this.pending = [];\n        this.running = [];\n        this.logger(`Constructed, concurrency=%s`, concurrency);\n    }\n    schedule() {\n        if (!this.pending.length || this.running.length >= this.concurrency) {\n            this.logger(`Schedule attempt ignored, pending=%s running=%s concurrency=%s`, this.pending.length, this.running.length, this.concurrency);\n            return;\n        }\n        const task = utils_1.append(this.running, this.pending.shift());\n        this.logger(`Attempting id=%s`, task.id);\n        task.done(() => {\n            this.logger(`Completing id=`, task.id);\n            utils_1.remove(this.running, task);\n            this.schedule();\n        });\n    }\n    next() {\n        const { promise, id } = utils_1.append(this.pending, createScheduledTask());\n        this.logger(`Scheduling id=%s`, id);\n        this.schedule();\n        return promise;\n    }\n}\nexports.Scheduler = Scheduler;\n//# sourceMappingURL=scheduler.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.applyPatchTask = void 0;\nconst task_1 = require(\"./task\");\nfunction applyPatchTask(patches, customArgs) {\n    return task_1.straightThroughStringTask(['apply', ...customArgs, ...patches]);\n}\nexports.applyPatchTask = applyPatchTask;\n//# sourceMappingURL=apply-patch.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isSingleBranchDeleteFailure = exports.branchDeletionFailure = exports.branchDeletionSuccess = exports.BranchDeletionBatch = void 0;\nclass BranchDeletionBatch {\n    constructor() {\n        this.all = [];\n        this.branches = {};\n        this.errors = [];\n    }\n    get success() {\n        return !this.errors.length;\n    }\n}\nexports.BranchDeletionBatch = BranchDeletionBatch;\nfunction branchDeletionSuccess(branch, hash) {\n    return {\n        branch, hash, success: true,\n    };\n}\nexports.branchDeletionSuccess = branchDeletionSuccess;\nfunction branchDeletionFailure(branch) {\n    return {\n        branch, hash: null, success: false,\n    };\n}\nexports.branchDeletionFailure = branchDeletionFailure;\nfunction isSingleBranchDeleteFailure(test) {\n    return test.success;\n}\nexports.isSingleBranchDeleteFailure = isSingleBranchDeleteFailure;\n//# sourceMappingURL=BranchDeleteSummary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.hasBranchDeletionError = exports.parseBranchDeletions = void 0;\nconst BranchDeleteSummary_1 = require(\"../responses/BranchDeleteSummary\");\nconst utils_1 = require(\"../utils\");\nconst deleteSuccessRegex = /(\\S+)\\s+\\(\\S+\\s([^)]+)\\)/;\nconst deleteErrorRegex = /^error[^']+'([^']+)'/m;\nconst parsers = [\n    new utils_1.LineParser(deleteSuccessRegex, (result, [branch, hash]) => {\n        const deletion = BranchDeleteSummary_1.branchDeletionSuccess(branch, hash);\n        result.all.push(deletion);\n        result.branches[branch] = deletion;\n    }),\n    new utils_1.LineParser(deleteErrorRegex, (result, [branch]) => {\n        const deletion = BranchDeleteSummary_1.branchDeletionFailure(branch);\n        result.errors.push(deletion);\n        result.all.push(deletion);\n        result.branches[branch] = deletion;\n    }),\n];\nconst parseBranchDeletions = (stdOut, stdErr) => {\n    return utils_1.parseStringResponse(new BranchDeleteSummary_1.BranchDeletionBatch(), parsers, stdOut, stdErr);\n};\nexports.parseBranchDeletions = parseBranchDeletions;\nfunction hasBranchDeletionError(data, processExitCode) {\n    return processExitCode === utils_1.ExitCodes.ERROR && deleteErrorRegex.test(data);\n}\nexports.hasBranchDeletionError = hasBranchDeletionError;\n//# sourceMappingURL=parse-branch-delete.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.BranchSummaryResult = void 0;\nclass BranchSummaryResult {\n    constructor() {\n        this.all = [];\n        this.branches = {};\n        this.current = '';\n        this.detached = false;\n    }\n    push(current, detached, name, commit, label) {\n        if (current) {\n            this.detached = detached;\n            this.current = name;\n        }\n        this.all.push(name);\n        this.branches[name] = {\n            current: current,\n            name: name,\n            commit: commit,\n            label: label\n        };\n    }\n}\nexports.BranchSummaryResult = BranchSummaryResult;\n//# sourceMappingURL=BranchSummary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseBranchSummary = void 0;\nconst BranchSummary_1 = require(\"../responses/BranchSummary\");\nconst utils_1 = require(\"../utils\");\nconst parsers = [\n    new utils_1.LineParser(/^(\\*\\s)?\\((?:HEAD )?detached (?:from|at) (\\S+)\\)\\s+([a-z0-9]+)\\s(.*)$/, (result, [current, name, commit, label]) => {\n        result.push(!!current, true, name, commit, label);\n    }),\n    new utils_1.LineParser(/^(\\*\\s)?(\\S+)\\s+([a-z0-9]+)\\s(.*)$/s, (result, [current, name, commit, label]) => {\n        result.push(!!current, false, name, commit, label);\n    })\n];\nfunction parseBranchSummary(stdOut) {\n    return utils_1.parseStringResponse(new BranchSummary_1.BranchSummaryResult(), parsers, stdOut);\n}\nexports.parseBranchSummary = parseBranchSummary;\n//# sourceMappingURL=parse-branch.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.deleteBranchTask = exports.deleteBranchesTask = exports.branchLocalTask = exports.branchTask = exports.containsDeleteBranchCommand = void 0;\nconst git_response_error_1 = require(\"../errors/git-response-error\");\nconst parse_branch_delete_1 = require(\"../parsers/parse-branch-delete\");\nconst parse_branch_1 = require(\"../parsers/parse-branch\");\nconst utils_1 = require(\"../utils\");\nfunction containsDeleteBranchCommand(commands) {\n    const deleteCommands = ['-d', '-D', '--delete'];\n    return commands.some(command => deleteCommands.includes(command));\n}\nexports.containsDeleteBranchCommand = containsDeleteBranchCommand;\nfunction branchTask(customArgs) {\n    const isDelete = containsDeleteBranchCommand(customArgs);\n    const commands = ['branch', ...customArgs];\n    if (commands.length === 1) {\n        commands.push('-a');\n    }\n    if (!commands.includes('-v')) {\n        commands.splice(1, 0, '-v');\n    }\n    return {\n        format: 'utf-8',\n        commands,\n        parser(stdOut, stdErr) {\n            if (isDelete) {\n                return parse_branch_delete_1.parseBranchDeletions(stdOut, stdErr).all[0];\n            }\n            return parse_branch_1.parseBranchSummary(stdOut);\n        },\n    };\n}\nexports.branchTask = branchTask;\nfunction branchLocalTask() {\n    const parser = parse_branch_1.parseBranchSummary;\n    return {\n        format: 'utf-8',\n        commands: ['branch', '-v'],\n        parser,\n    };\n}\nexports.branchLocalTask = branchLocalTask;\nfunction deleteBranchesTask(branches, forceDelete = false) {\n    return {\n        format: 'utf-8',\n        commands: ['branch', '-v', forceDelete ? '-D' : '-d', ...branches],\n        parser(stdOut, stdErr) {\n            return parse_branch_delete_1.parseBranchDeletions(stdOut, stdErr);\n        },\n        onError({ exitCode, stdOut }, error, done, fail) {\n            if (!parse_branch_delete_1.hasBranchDeletionError(String(error), exitCode)) {\n                return fail(error);\n            }\n            done(stdOut);\n        },\n    };\n}\nexports.deleteBranchesTask = deleteBranchesTask;\nfunction deleteBranchTask(branch, forceDelete = false) {\n    const task = {\n        format: 'utf-8',\n        commands: ['branch', '-v', forceDelete ? '-D' : '-d', branch],\n        parser(stdOut, stdErr) {\n            return parse_branch_delete_1.parseBranchDeletions(stdOut, stdErr).branches[branch];\n        },\n        onError({ exitCode, stdErr, stdOut }, error, _, fail) {\n            if (!parse_branch_delete_1.hasBranchDeletionError(String(error), exitCode)) {\n                return fail(error);\n            }\n            throw new git_response_error_1.GitResponseError(task.parser(utils_1.bufferToString(stdOut), utils_1.bufferToString(stdErr)), String(error));\n        },\n    };\n    return task;\n}\nexports.deleteBranchTask = deleteBranchTask;\n//# sourceMappingURL=branch.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseCheckIgnore = void 0;\n/**\n * Parser for the `check-ignore` command - returns each file as a string array\n */\nconst parseCheckIgnore = (text) => {\n    return text.split(/\\n/g)\n        .map(line => line.trim())\n        .filter(file => !!file);\n};\nexports.parseCheckIgnore = parseCheckIgnore;\n//# sourceMappingURL=CheckIgnore.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.checkIgnoreTask = void 0;\nconst CheckIgnore_1 = require(\"../responses/CheckIgnore\");\nfunction checkIgnoreTask(paths) {\n    return {\n        commands: ['check-ignore', ...paths],\n        format: 'utf-8',\n        parser: CheckIgnore_1.parseCheckIgnore,\n    };\n}\nexports.checkIgnoreTask = checkIgnoreTask;\n//# sourceMappingURL=check-ignore.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.cloneMirrorTask = exports.cloneTask = void 0;\nconst task_1 = require(\"./task\");\nconst utils_1 = require(\"../utils\");\nfunction cloneTask(repo, directory, customArgs) {\n    const commands = ['clone', ...customArgs];\n    if (typeof repo === 'string') {\n        commands.push(repo);\n    }\n    if (typeof directory === 'string') {\n        commands.push(directory);\n    }\n    return task_1.straightThroughStringTask(commands);\n}\nexports.cloneTask = cloneTask;\nfunction cloneMirrorTask(repo, directory, customArgs) {\n    utils_1.append(customArgs, '--mirror');\n    return cloneTask(repo, directory, customArgs);\n}\nexports.cloneMirrorTask = cloneMirrorTask;\n//# sourceMappingURL=clone.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.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    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 setConfig(path: string, value: any): Promise<void>;\n\n    abstract getConfig(path: string): Promise<any>;\n\n    abstract fetch(): Promise<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 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(path);\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,\n            staged: status.staged,\n            conflicted: status.conflicted,\n        };\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);\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(): Promise<void> {\n        await this.git.fetch((err: any) => this.onError(err));\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 { 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 { 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}\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};\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: \"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                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\");\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 pullChangesFromRemote(): Promise<void> {\n\n        if (!this.gitReady) {\n            await this.init();\n        }\n\n        if (!this.gitReady) return;\n\n        const filesUpdated = await this.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 (!this.gitReady) {\n            await this.init();\n        }\n        if (!this.gitReady) return;\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                this.displayError(\"Did not push. No tracking branch is set! Please set one in the settings\", 10000);\n                this.setState(PluginState.idle);\n                return;\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 writeAndOpenFile(text: string) {\n        await this.app.vault.adapter.write(this.conflictOutputFile, text);\n\n        let fileIsAlreadyOpened = false;\n        this.app.workspace.iterateAllLeaves(leaf => {\n            if (leaf.getDisplayText() != \"\" && this.conflictOutputFile.startsWith(leaf.getDisplayText())) {\n                fileIsAlreadyOpened = true;\n            }\n        });\n        if (!fileIsAlreadyOpened) {\n            this.app.workspace.openLinkText(this.conflictOutputFile, \"/\", true);\n        }\n    }\n\n    // region: displaying / formatting messages\n    displayMessage(message: string, timeout: number = 4 * 1000): void {\n        this.statusBar?.displayMessage(message.toLowerCase(), timeout);\n\n        if (!this.settings.disablePopups) {\n            new Notice(message);\n        }\n\n        console.log(`git obsidian message: ${message}`);\n    }\n    displayError(message: string, timeout: number = 0): void {\n        new Notice(message);\n        console.log(`git obsidian error: ${message}`);\n        this.statusBar?.displayMessage(message.toLowerCase(), timeout);\n    }\n}"],"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","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","promise_deferred_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","spawnSync","TFile","Plugin"],"mappings":"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CjB,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,SAAS;AACV,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A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"} diff --git a/.obsidian/plugins/obsidian-git/manifest.json b/.obsidian/plugins/obsidian-git/manifest.json new file mode 100644 index 0000000..2d71413 --- /dev/null +++ b/.obsidian/plugins/obsidian-git/manifest.json @@ -0,0 +1,8 @@ +{ + "id": "obsidian-git", + "name": "Obsidian Git", + "description": "Backup your vault with git.", + "isDesktopOnly": true, + "js": "main.js", + "version": "1.10.2" +} diff --git a/README.md.md b/README.md.md new file mode 100644 index 0000000..2ab33fe --- /dev/null +++ b/README.md.md @@ -0,0 +1,2 @@ +# Poznámky +Tenhle repositář (a web) slouží pro ukládání mých školních poznámek (od SSPŠ). Pokud se mnou chodíte do třídy a chtěli by jste poznámky vylepšit, napište mi na třídním discordu. \ No newline at end of file diff --git a/pdv/30let linuxu.md b/pdv/30let linuxu.md index 2602cf2..b2d7511 100644 --- a/pdv/30let linuxu.md +++ b/pdv/30let linuxu.md @@ -6,4 +6,4 @@ Necelé 2 týdny zpátky (v době psaní) bylo výročí 30 let od oznámení li ## První verze Nejstarší verzi kterou jsem našel bylo 0.01 (ono podle čísla stejně starší verze nebyla nahraná), která sama o sobě stejně nefungovala - byli to jen zdrojové kódy pro ty, co se o Linux zajímali v době oznámení Linusem. První verze která byla spustitelná byla 0.02, vydaná 5. října 1991, na které šel spustit bash (terminál) 1.08 a GCC (na kompilaci) 1.40, společně se základníma utilitama na správu souborů (cp, sed, cat a pod.). V té době ještě stále vyžadoval minix ke kompilaci, jelikož používal knihovny od minixu. ## Linux není samostatný operační systém -Jeden z emailů taky zmiňoval, že Linux není samostatný operační systém, a že to je pro lidi co se chtějí naučit více o 386 procesorech a o tom, jak může OS vypadat. Také se tam psalo o tom, že GNU Hurd, operační systém od GNU, by mohl vyjít do pár let (nebo měsíců). GNU Hurd již vyšel, avšak je daleko za Linuxem, jelikož se většina GNU vývojářů přesunula na Linux od GNU Hurd. \ No newline at end of file +Jeden z emailů taky zmiňoval, že Linux není samostatný operační systém, a že to je pro lidi co se chtějí naučit více o 386 procesorech a o tom, jak může OS vypadat. Také se tam psalo o tom, že GNU Hurd, operační systém od GNU, by mohl vyjít do pár let (nebo měsíců). GNU Hurd již vyšel, avšak je daleko za Linuxem, jelikož se většina GNU vývojářů přesunula na Linux od GNU Hurd. Dle Wikipedie není považovaný za dostatečně stabilní pro produkční server.