");
+ t.b("\n" + i);
+ t.b(' ');
+ t.b("\n" + i);
+ t.b(" ");
+ t.b(t.t(t.f("lineNumber", c, p, 0)));
+ t.b("\n" + i);
+ t.b(" | ");
+ t.b("\n" + i);
+ t.b(' ');
+ t.b("\n" + i);
+ t.b(' ');
+ t.b("\n" + i);
+ if (t.s(t.f("prefix", c, p, 1), c, p, 0, 162, 238, "{{ }}")) {
+ t.rs(c, p, function(c2, p2, t2) {
+ t2.b(' ');
+ t2.b(t2.t(t2.f("prefix", c2, p2, 0)));
+ t2.b("");
+ t2.b("\n" + i);
+ });
+ c.pop();
+ }
+ if (!t.s(t.f("prefix", c, p, 1), c, p, 1, 0, 0, "")) {
+ t.b(' ');
+ t.b("\n" + i);
+ }
+ ;
+ if (t.s(t.f("content", c, p, 1), c, p, 0, 371, 445, "{{ }}")) {
+ t.rs(c, p, function(c2, p2, t2) {
+ t2.b(' ');
+ t2.b(t2.t(t2.f("content", c2, p2, 0)));
+ t2.b("");
+ t2.b("\n" + i);
+ });
+ c.pop();
+ }
+ if (!t.s(t.f("content", c, p, 1), c, p, 1, 0, 0, "")) {
+ t.b(' ');
+ t.b("\n" + i);
+ }
+ ;
+ t.b(" ");
+ t.b("\n" + i);
+ t.b(" | ");
+ t.b("\n" + i);
+ t.b("");
+ return t.fl();
+ }, partials: {}, subs: {} });
+ exports.defaultTemplates["generic-wrapper"] = new Hogan2.Template({ code: function(c, p, i) {
+ var t = this;
+ t.b(i = i || "");
+ t.b('');
+ t.b("\n" + i);
+ t.b(" ");
+ t.b(t.t(t.f("content", c, p, 0)));
+ t.b("\n" + i);
+ t.b("
");
+ return t.fl();
+ }, partials: {}, subs: {} });
+ exports.defaultTemplates["icon-file-added"] = new Hogan2.Template({ code: function(c, p, i) {
+ var t = this;
+ t.b(i = i || "");
+ t.b('");
+ return t.fl();
+ }, partials: {}, subs: {} });
+ exports.defaultTemplates["icon-file-changed"] = new Hogan2.Template({ code: function(c, p, i) {
+ var t = this;
+ t.b(i = i || "");
+ t.b('");
+ return t.fl();
+ }, partials: {}, subs: {} });
+ exports.defaultTemplates["icon-file-deleted"] = new Hogan2.Template({ code: function(c, p, i) {
+ var t = this;
+ t.b(i = i || "");
+ t.b('");
+ return t.fl();
+ }, partials: {}, subs: {} });
+ exports.defaultTemplates["icon-file-renamed"] = new Hogan2.Template({ code: function(c, p, i) {
+ var t = this;
+ t.b(i = i || "");
+ t.b('");
+ return t.fl();
+ }, partials: {}, subs: {} });
+ exports.defaultTemplates["icon-file"] = new Hogan2.Template({ code: function(c, p, i) {
+ var t = this;
+ t.b(i = i || "");
+ t.b('");
+ return t.fl();
+ }, partials: {}, subs: {} });
+ exports.defaultTemplates["line-by-line-file-diff"] = new Hogan2.Template({ code: function(c, p, i) {
+ var t = this;
+ t.b(i = i || "");
+ t.b('');
+ t.b("\n" + i);
+ t.b(' ");
+ t.b("\n" + i);
+ t.b('
');
+ t.b("\n" + i);
+ t.b('
');
+ t.b("\n" + i);
+ t.b('
');
+ t.b("\n" + i);
+ t.b(' ');
+ t.b("\n" + i);
+ t.b(" ");
+ t.b(t.t(t.f("diffs", c, p, 0)));
+ t.b("\n" + i);
+ t.b(" ");
+ t.b("\n" + i);
+ t.b("
");
+ t.b("\n" + i);
+ t.b("
");
+ t.b("\n" + i);
+ t.b("
");
+ t.b("\n" + i);
+ t.b("
");
+ return t.fl();
+ }, partials: {}, subs: {} });
+ exports.defaultTemplates["line-by-line-numbers"] = new Hogan2.Template({ code: function(c, p, i) {
+ var t = this;
+ t.b(i = i || "");
+ t.b('');
+ t.b(t.v(t.f("oldNumber", c, p, 0)));
+ t.b("
");
+ t.b("\n" + i);
+ t.b('');
+ t.b(t.v(t.f("newNumber", c, p, 0)));
+ t.b("
");
+ return t.fl();
+ }, partials: {}, subs: {} });
+ exports.defaultTemplates["side-by-side-file-diff"] = new Hogan2.Template({ code: function(c, p, i) {
+ var t = this;
+ t.b(i = i || "");
+ t.b('');
+ t.b("\n" + i);
+ t.b(' ");
+ t.b("\n" + i);
+ t.b('
');
+ t.b("\n" + i);
+ t.b('
');
+ t.b("\n" + i);
+ t.b('
');
+ t.b("\n" + i);
+ t.b('
');
+ t.b("\n" + i);
+ t.b(' ');
+ t.b("\n" + i);
+ t.b(" ");
+ t.b(t.t(t.d("diffs.left", c, p, 0)));
+ t.b("\n" + i);
+ t.b(" ");
+ t.b("\n" + i);
+ t.b("
");
+ t.b("\n" + i);
+ t.b("
");
+ t.b("\n" + i);
+ t.b("
");
+ t.b("\n" + i);
+ t.b('
');
+ t.b("\n" + i);
+ t.b('
');
+ t.b("\n" + i);
+ t.b('
');
+ t.b("\n" + i);
+ t.b(' ');
+ t.b("\n" + i);
+ t.b(" ");
+ t.b(t.t(t.d("diffs.right", c, p, 0)));
+ t.b("\n" + i);
+ t.b(" ");
+ t.b("\n" + i);
+ t.b("
");
+ t.b("\n" + i);
+ t.b("
");
+ t.b("\n" + i);
+ t.b("
");
+ t.b("\n" + i);
+ t.b("
");
+ t.b("\n" + i);
+ t.b("
");
+ return t.fl();
+ }, partials: {}, subs: {} });
+ exports.defaultTemplates["tag-file-added"] = new Hogan2.Template({ code: function(c, p, i) {
+ var t = this;
+ t.b(i = i || "");
+ t.b('ADDED');
+ return t.fl();
+ }, partials: {}, subs: {} });
+ exports.defaultTemplates["tag-file-changed"] = new Hogan2.Template({ code: function(c, p, i) {
+ var t = this;
+ t.b(i = i || "");
+ t.b('CHANGED');
+ return t.fl();
+ }, partials: {}, subs: {} });
+ exports.defaultTemplates["tag-file-deleted"] = new Hogan2.Template({ code: function(c, p, i) {
+ var t = this;
+ t.b(i = i || "");
+ t.b('DELETED');
+ return t.fl();
+ }, partials: {}, subs: {} });
+ exports.defaultTemplates["tag-file-renamed"] = new Hogan2.Template({ code: function(c, p, i) {
+ var t = this;
+ t.b(i = i || "");
+ t.b('RENAMED');
+ return t.fl();
+ }, partials: {}, subs: {} });
+ }
+});
+
+// node_modules/diff2html/lib/hoganjs-utils.js
+var require_hoganjs_utils = __commonJS({
+ "node_modules/diff2html/lib/hoganjs-utils.js"(exports) {
+ "use strict";
+ var __assign2 = exports && exports.__assign || function() {
+ __assign2 = Object.assign || function(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 __assign2.apply(this, arguments);
+ };
+ var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ var desc = Object.getOwnPropertyDescriptor(m, k);
+ if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+ desc = { enumerable: true, get: function() {
+ return m[k];
+ } };
+ }
+ Object.defineProperty(o, k2, desc);
+ } : function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ o[k2] = m[k];
+ });
+ var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+ } : function(o, v) {
+ o["default"] = v;
+ });
+ var __importStar2 = exports && exports.__importStar || function(mod) {
+ if (mod && mod.__esModule)
+ return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k in mod)
+ if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+ __createBinding2(result, mod, k);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var Hogan2 = __importStar2(require_hogan());
+ var diff2html_templates_1 = require_diff2html_templates();
+ var HoganJsUtils = function() {
+ function HoganJsUtils2(_a2) {
+ var _b = _a2.compiledTemplates, compiledTemplates = _b === void 0 ? {} : _b, _c = _a2.rawTemplates, rawTemplates = _c === void 0 ? {} : _c;
+ var compiledRawTemplates = Object.entries(rawTemplates).reduce(function(previousTemplates, _a3) {
+ var _b2;
+ var name = _a3[0], templateString = _a3[1];
+ var compiledTemplate = Hogan2.compile(templateString, { asString: false });
+ return __assign2(__assign2({}, previousTemplates), (_b2 = {}, _b2[name] = compiledTemplate, _b2));
+ }, {});
+ this.preCompiledTemplates = __assign2(__assign2(__assign2({}, diff2html_templates_1.defaultTemplates), compiledTemplates), compiledRawTemplates);
+ }
+ HoganJsUtils2.compile = function(templateString) {
+ return Hogan2.compile(templateString, { asString: false });
+ };
+ HoganJsUtils2.prototype.render = function(namespace, view, params, partials, indent) {
+ var templateKey = this.templateKey(namespace, view);
+ try {
+ var template = this.preCompiledTemplates[templateKey];
+ return template.render(params, partials, indent);
+ } catch (e) {
+ throw new Error("Could not find template to render '".concat(templateKey, "'"));
+ }
+ };
+ HoganJsUtils2.prototype.template = function(namespace, view) {
+ return this.preCompiledTemplates[this.templateKey(namespace, view)];
+ };
+ HoganJsUtils2.prototype.templateKey = function(namespace, view) {
+ return "".concat(namespace, "-").concat(view);
+ };
+ return HoganJsUtils2;
+ }();
+ exports.default = HoganJsUtils;
+ }
+});
+
+// node_modules/diff2html/lib/diff2html.js
+var require_diff2html = __commonJS({
+ "node_modules/diff2html/lib/diff2html.js"(exports) {
+ "use strict";
+ var __assign2 = exports && exports.__assign || function() {
+ __assign2 = Object.assign || function(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 __assign2.apply(this, arguments);
+ };
+ var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ var desc = Object.getOwnPropertyDescriptor(m, k);
+ if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+ desc = { enumerable: true, get: function() {
+ return m[k];
+ } };
+ }
+ Object.defineProperty(o, k2, desc);
+ } : function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ o[k2] = m[k];
+ });
+ var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+ } : function(o, v) {
+ o["default"] = v;
+ });
+ var __importStar2 = exports && exports.__importStar || function(mod) {
+ if (mod && mod.__esModule)
+ return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k in mod)
+ if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+ __createBinding2(result, mod, k);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ var __importDefault2 = exports && exports.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.html = exports.parse = exports.defaultDiff2HtmlConfig = void 0;
+ var DiffParser = __importStar2(require_diff_parser());
+ var fileListPrinter = __importStar2(require_file_list_renderer());
+ var line_by_line_renderer_1 = __importStar2(require_line_by_line_renderer());
+ var side_by_side_renderer_1 = __importStar2(require_side_by_side_renderer());
+ var types_1 = require_types();
+ var hoganjs_utils_1 = __importDefault2(require_hoganjs_utils());
+ exports.defaultDiff2HtmlConfig = __assign2(__assign2(__assign2({}, line_by_line_renderer_1.defaultLineByLineRendererConfig), side_by_side_renderer_1.defaultSideBySideRendererConfig), { outputFormat: types_1.OutputFormatType.LINE_BY_LINE, drawFileList: true });
+ function parse(diffInput, configuration) {
+ if (configuration === void 0) {
+ configuration = {};
+ }
+ return DiffParser.parse(diffInput, __assign2(__assign2({}, exports.defaultDiff2HtmlConfig), configuration));
+ }
+ exports.parse = parse;
+ function html2(diffInput, configuration) {
+ if (configuration === void 0) {
+ configuration = {};
+ }
+ var config = __assign2(__assign2({}, exports.defaultDiff2HtmlConfig), configuration);
+ var diffJson = typeof diffInput === "string" ? DiffParser.parse(diffInput, config) : diffInput;
+ var hoganUtils = new hoganjs_utils_1.default(config);
+ var fileList = config.drawFileList ? fileListPrinter.render(diffJson, hoganUtils) : "";
+ var diffOutput = config.outputFormat === "side-by-side" ? new side_by_side_renderer_1.default(hoganUtils, config).render(diffJson) : new line_by_line_renderer_1.default(hoganUtils, config).render(diffJson);
+ return fileList + diffOutput;
+ }
+ exports.html = html2;
+ }
+});
+
+// node_modules/tslib/tslib.js
+var require_tslib = __commonJS({
+ "node_modules/tslib/tslib.js"(exports, module2) {
+ var __extends2;
+ var __assign2;
+ var __rest2;
+ var __decorate2;
+ var __param2;
+ var __metadata2;
+ var __awaiter2;
+ var __generator2;
+ var __exportStar2;
+ var __values2;
+ var __read2;
+ var __spread2;
+ var __spreadArrays2;
+ var __spreadArray2;
+ var __await2;
+ var __asyncGenerator2;
+ var __asyncDelegator2;
+ var __asyncValues2;
+ var __makeTemplateObject2;
+ var __importStar2;
+ var __importDefault2;
+ var __classPrivateFieldGet2;
+ var __classPrivateFieldSet2;
+ var __classPrivateFieldIn2;
+ var __createBinding2;
+ (function(factory) {
+ var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
+ if (typeof define === "function" && define.amd) {
+ define("tslib", ["exports"], function(exports2) {
+ factory(createExporter(root, createExporter(exports2)));
+ });
+ } else if (typeof module2 === "object" && typeof module2.exports === "object") {
+ factory(createExporter(root, createExporter(module2.exports)));
+ } else {
+ factory(createExporter(root));
+ }
+ function createExporter(exports2, previous) {
+ if (exports2 !== root) {
+ if (typeof Object.create === "function") {
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ } else {
+ exports2.__esModule = true;
+ }
+ }
+ return function(id, v) {
+ return exports2[id] = previous ? previous(id, v) : v;
+ };
+ }
+ })(function(exporter) {
+ var 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];
+ };
+ __extends2 = function(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 __());
+ };
+ __assign2 = Object.assign || function(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;
+ };
+ __rest2 = function(s, e) {
+ var t = {};
+ for (var p in s)
+ if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+ t[p] = s[p];
+ if (s != null && typeof Object.getOwnPropertySymbols === "function")
+ for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+ if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+ t[p[i]] = s[p[i]];
+ }
+ return t;
+ };
+ __decorate2 = function(decorators, target, key2, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key2) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+ r = Reflect.decorate(decorators, target, key2, desc);
+ else
+ for (var i = decorators.length - 1; i >= 0; i--)
+ if (d = decorators[i])
+ r = (c < 3 ? d(r) : c > 3 ? d(target, key2, r) : d(target, key2)) || r;
+ return c > 3 && r && Object.defineProperty(target, key2, r), r;
+ };
+ __param2 = function(paramIndex, decorator) {
+ return function(target, key2) {
+ decorator(target, key2, paramIndex);
+ };
+ };
+ __metadata2 = function(metadataKey, metadataValue) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+ return Reflect.metadata(metadataKey, metadataValue);
+ };
+ __awaiter2 = 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());
+ });
+ };
+ __generator2 = function(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 };
+ }
+ };
+ __exportStar2 = function(m, o) {
+ for (var p in m)
+ if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
+ __createBinding2(o, m, p);
+ };
+ __createBinding2 = Object.create ? function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ var desc = Object.getOwnPropertyDescriptor(m, k);
+ if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+ desc = { enumerable: true, get: function() {
+ return m[k];
+ } };
+ }
+ Object.defineProperty(o, k2, desc);
+ } : function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ o[k2] = m[k];
+ };
+ __values2 = function(o) {
+ var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+ if (m)
+ return m.call(o);
+ if (o && typeof o.length === "number")
+ return {
+ next: function() {
+ if (o && i >= o.length)
+ o = void 0;
+ return { value: o && o[i++], done: !o };
+ }
+ };
+ throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+ };
+ __read2 = function(o, n) {
+ var m = typeof Symbol === "function" && o[Symbol.iterator];
+ if (!m)
+ return o;
+ var i = m.call(o), r, ar = [], e;
+ try {
+ while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+ ar.push(r.value);
+ } catch (error) {
+ e = { error };
+ } finally {
+ try {
+ if (r && !r.done && (m = i["return"]))
+ m.call(i);
+ } finally {
+ if (e)
+ throw e.error;
+ }
+ }
+ return ar;
+ };
+ __spread2 = function() {
+ for (var ar = [], i = 0; i < arguments.length; i++)
+ ar = ar.concat(__read2(arguments[i]));
+ return ar;
+ };
+ __spreadArrays2 = function() {
+ for (var s = 0, i = 0, il = arguments.length; i < il; i++)
+ s += arguments[i].length;
+ for (var r = Array(s), k = 0, i = 0; i < il; i++)
+ for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+ r[k] = a[j];
+ return r;
+ };
+ __spreadArray2 = function(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));
+ };
+ __await2 = function(v) {
+ return this instanceof __await2 ? (this.v = v, this) : new __await2(v);
+ };
+ __asyncGenerator2 = function(thisArg, _arguments, generator) {
+ if (!Symbol.asyncIterator)
+ throw new TypeError("Symbol.asyncIterator is not defined.");
+ var g = generator.apply(thisArg, _arguments || []), i, q = [];
+ return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+ return this;
+ }, i;
+ 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);
+ });
+ };
+ }
+ function resume(n, v) {
+ try {
+ step(g[n](v));
+ } catch (e) {
+ settle(q[0][3], e);
+ }
+ }
+ function step(r) {
+ r.value instanceof __await2 ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+ }
+ function fulfill(value) {
+ resume("next", value);
+ }
+ function reject(value) {
+ resume("throw", value);
+ }
+ function settle(f, v) {
+ if (f(v), q.shift(), q.length)
+ resume(q[0][0], q[0][1]);
+ }
+ };
+ __asyncDelegator2 = function(o) {
+ var i, p;
+ return i = {}, verb("next"), verb("throw", function(e) {
+ throw e;
+ }), verb("return"), i[Symbol.iterator] = function() {
+ return this;
+ }, i;
+ function verb(n, f) {
+ i[n] = o[n] ? function(v) {
+ return (p = !p) ? { value: __await2(o[n](v)), done: n === "return" } : f ? f(v) : v;
+ } : f;
+ }
+ };
+ __asyncValues2 = function(o) {
+ if (!Symbol.asyncIterator)
+ throw new TypeError("Symbol.asyncIterator is not defined.");
+ var m = o[Symbol.asyncIterator], i;
+ return m ? m.call(o) : (o = typeof __values2 === "function" ? __values2(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+ return this;
+ }, i);
+ 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);
+ });
+ };
+ }
+ function settle(resolve, reject, d, v) {
+ Promise.resolve(v).then(function(v2) {
+ resolve({ value: v2, done: d });
+ }, reject);
+ }
+ };
+ __makeTemplateObject2 = function(cooked, raw) {
+ if (Object.defineProperty) {
+ Object.defineProperty(cooked, "raw", { value: raw });
+ } else {
+ cooked.raw = raw;
+ }
+ return cooked;
+ };
+ var __setModuleDefault = Object.create ? function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+ } : function(o, v) {
+ o["default"] = v;
+ };
+ __importStar2 = function(mod) {
+ if (mod && mod.__esModule)
+ return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k in mod)
+ if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+ __createBinding2(result, mod, k);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ __importDefault2 = function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ __classPrivateFieldGet2 = function(receiver, state, kind, f) {
+ if (kind === "a" && !f)
+ throw new TypeError("Private accessor was defined without a getter");
+ 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");
+ return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+ };
+ __classPrivateFieldSet2 = function(receiver, state, value, kind, f) {
+ if (kind === "m")
+ throw new TypeError("Private method is not writable");
+ if (kind === "a" && !f)
+ throw new TypeError("Private accessor was defined without a setter");
+ 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");
+ return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+ };
+ __classPrivateFieldIn2 = function(state, receiver) {
+ if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function")
+ throw new TypeError("Cannot use 'in' operator on non-object");
+ return typeof state === "function" ? receiver === state : state.has(receiver);
+ };
+ exporter("__extends", __extends2);
+ exporter("__assign", __assign2);
+ exporter("__rest", __rest2);
+ exporter("__decorate", __decorate2);
+ exporter("__param", __param2);
+ exporter("__metadata", __metadata2);
+ exporter("__awaiter", __awaiter2);
+ exporter("__generator", __generator2);
+ exporter("__exportStar", __exportStar2);
+ exporter("__createBinding", __createBinding2);
+ exporter("__values", __values2);
+ exporter("__read", __read2);
+ exporter("__spread", __spread2);
+ exporter("__spreadArrays", __spreadArrays2);
+ exporter("__spreadArray", __spreadArray2);
+ exporter("__await", __await2);
+ exporter("__asyncGenerator", __asyncGenerator2);
+ exporter("__asyncDelegator", __asyncDelegator2);
+ exporter("__asyncValues", __asyncValues2);
+ exporter("__makeTemplateObject", __makeTemplateObject2);
+ exporter("__importStar", __importStar2);
+ exporter("__importDefault", __importDefault2);
+ exporter("__classPrivateFieldGet", __classPrivateFieldGet2);
+ exporter("__classPrivateFieldSet", __classPrivateFieldSet2);
+ exporter("__classPrivateFieldIn", __classPrivateFieldIn2);
+ });
+ }
+});
+
+// node_modules/feather-icons/dist/feather.js
+var require_feather = __commonJS({
+ "node_modules/feather-icons/dist/feather.js"(exports, module2) {
+ (function webpackUniversalModuleDefinition(root, factory) {
+ if (typeof exports === "object" && typeof module2 === "object")
+ module2.exports = factory();
+ else if (typeof define === "function" && define.amd)
+ define([], factory);
+ else if (typeof exports === "object")
+ exports["feather"] = factory();
+ else
+ root["feather"] = factory();
+ })(typeof self !== "undefined" ? self : exports, function() {
+ return function(modules) {
+ var installedModules = {};
+ function __webpack_require__(moduleId) {
+ if (installedModules[moduleId]) {
+ return installedModules[moduleId].exports;
+ }
+ var module3 = installedModules[moduleId] = {
+ i: moduleId,
+ l: false,
+ exports: {}
+ };
+ modules[moduleId].call(module3.exports, module3, module3.exports, __webpack_require__);
+ module3.l = true;
+ return module3.exports;
+ }
+ __webpack_require__.m = modules;
+ __webpack_require__.c = installedModules;
+ __webpack_require__.d = function(exports2, name, getter) {
+ if (!__webpack_require__.o(exports2, name)) {
+ Object.defineProperty(exports2, name, {
+ configurable: false,
+ enumerable: true,
+ get: getter
+ });
+ }
+ };
+ __webpack_require__.r = function(exports2) {
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ };
+ __webpack_require__.n = function(module3) {
+ var getter = module3 && module3.__esModule ? function getDefault() {
+ return module3["default"];
+ } : function getModuleExports() {
+ return module3;
+ };
+ __webpack_require__.d(getter, "a", getter);
+ return getter;
+ };
+ __webpack_require__.o = function(object, property) {
+ return Object.prototype.hasOwnProperty.call(object, property);
+ };
+ __webpack_require__.p = "";
+ return __webpack_require__(__webpack_require__.s = 0);
+ }({
+ "./dist/icons.json": function(module3) {
+ module3.exports = { "activity": '', "airplay": '', "alert-circle": '', "alert-octagon": '', "alert-triangle": '', "align-center": '', "align-justify": '', "align-left": '', "align-right": '', "anchor": '', "aperture": '', "archive": '', "arrow-down-circle": '', "arrow-down-left": '', "arrow-down-right": '', "arrow-down": '', "arrow-left-circle": '', "arrow-left": '', "arrow-right-circle": '', "arrow-right": '', "arrow-up-circle": '', "arrow-up-left": '', "arrow-up-right": '', "arrow-up": '', "at-sign": '', "award": '', "bar-chart-2": '', "bar-chart": '', "battery-charging": '', "battery": '', "bell-off": '', "bell": '', "bluetooth": '', "bold": '', "book-open": '', "book": '', "bookmark": '', "box": '', "briefcase": '', "calendar": '', "camera-off": '', "camera": '', "cast": '', "check-circle": '', "check-square": '', "check": '', "chevron-down": '', "chevron-left": '', "chevron-right": '', "chevron-up": '', "chevrons-down": '', "chevrons-left": '', "chevrons-right": '', "chevrons-up": '', "chrome": '', "circle": '', "clipboard": '', "clock": '', "cloud-drizzle": '', "cloud-lightning": '', "cloud-off": '', "cloud-rain": '', "cloud-snow": '', "cloud": '', "code": '', "codepen": '', "codesandbox": '', "coffee": '', "columns": '', "command": '', "compass": '', "copy": '', "corner-down-left": '', "corner-down-right": '', "corner-left-down": '', "corner-left-up": '', "corner-right-down": '', "corner-right-up": '', "corner-up-left": '', "corner-up-right": '', "cpu": '', "credit-card": '', "crop": '', "crosshair": '', "database": '', "delete": '', "disc": '', "divide-circle": '', "divide-square": '', "divide": '', "dollar-sign": '', "download-cloud": '', "download": '', "dribbble": '', "droplet": '', "edit-2": '', "edit-3": '', "edit": '', "external-link": '', "eye-off": '', "eye": '', "facebook": '', "fast-forward": '', "feather": '', "figma": '', "file-minus": '', "file-plus": '', "file-text": '', "file": '', "film": '', "filter": '', "flag": '', "folder-minus": '', "folder-plus": '', "folder": '', "framer": '', "frown": '', "gift": '', "git-branch": '', "git-commit": '', "git-merge": '', "git-pull-request": '', "github": '', "gitlab": '', "globe": '', "grid": '', "hard-drive": '', "hash": '', "headphones": '', "heart": '', "help-circle": '', "hexagon": '', "home": '', "image": '', "inbox": '', "info": '', "instagram": '', "italic": '', "key": '', "layers": '', "layout": '', "life-buoy": '', "link-2": '', "link": '', "linkedin": '', "list": '', "loader": '', "lock": '', "log-in": '', "log-out": '', "mail": '', "map-pin": '', "map": '', "maximize-2": '', "maximize": '', "meh": '', "menu": '', "message-circle": '', "message-square": '', "mic-off": '', "mic": '', "minimize-2": '', "minimize": '', "minus-circle": '', "minus-square": '', "minus": '', "monitor": '', "moon": '', "more-horizontal": '', "more-vertical": '', "mouse-pointer": '', "move": '', "music": '', "navigation-2": '', "navigation": '', "octagon": '', "package": '', "paperclip": '', "pause-circle": '', "pause": '', "pen-tool": '', "percent": '', "phone-call": '', "phone-forwarded": '', "phone-incoming": '', "phone-missed": '', "phone-off": '', "phone-outgoing": '', "phone": '', "pie-chart": '', "play-circle": '', "play": '', "plus-circle": '', "plus-square": '', "plus": '', "pocket": '', "power": '', "printer": '', "radio": '', "refresh-ccw": '', "refresh-cw": '', "repeat": '', "rewind": '', "rotate-ccw": '', "rotate-cw": '', "rss": '', "save": '', "scissors": '', "search": '', "send": '', "server": '', "settings": '', "share-2": '', "share": '', "shield-off": '', "shield": '', "shopping-bag": '', "shopping-cart": '', "shuffle": '', "sidebar": '', "skip-back": '', "skip-forward": '', "slack": '', "slash": '', "sliders": '', "smartphone": '', "smile": '', "speaker": '', "square": '', "star": '', "stop-circle": '', "sun": '', "sunrise": '', "sunset": '', "table": '', "tablet": '', "tag": '', "target": '', "terminal": '', "thermometer": '', "thumbs-down": '', "thumbs-up": '', "toggle-left": '', "toggle-right": '', "tool": '', "trash-2": '', "trash": '', "trello": '', "trending-down": '', "trending-up": '', "triangle": '', "truck": '', "tv": '', "twitch": '', "twitter": '', "type": '', "umbrella": '', "underline": '', "unlock": '', "upload-cloud": '', "upload": '', "user-check": '', "user-minus": '', "user-plus": '', "user-x": '', "user": '', "users": '', "video-off": '', "video": '', "voicemail": '', "volume-1": '', "volume-2": '', "volume-x": '', "volume": '', "watch": '', "wifi-off": '', "wifi": '', "wind": '', "x-circle": '', "x-octagon": '', "x-square": '', "x": '', "youtube": '', "zap-off": '', "zap": '', "zoom-in": '', "zoom-out": '' };
+ },
+ "./node_modules/classnames/dedupe.js": function(module3, exports2, __webpack_require__) {
+ var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;
+ (function() {
+ "use strict";
+ var classNames = function() {
+ function StorageObject() {
+ }
+ StorageObject.prototype = Object.create(null);
+ function _parseArray(resultSet, array) {
+ var length = array.length;
+ for (var i = 0; i < length; ++i) {
+ _parse(resultSet, array[i]);
+ }
+ }
+ var hasOwn = {}.hasOwnProperty;
+ function _parseNumber(resultSet, num) {
+ resultSet[num] = true;
+ }
+ function _parseObject(resultSet, object) {
+ for (var k in object) {
+ if (hasOwn.call(object, k)) {
+ resultSet[k] = !!object[k];
+ }
+ }
+ }
+ var SPACE = /\s+/;
+ function _parseString(resultSet, str) {
+ var array = str.split(SPACE);
+ var length = array.length;
+ for (var i = 0; i < length; ++i) {
+ resultSet[array[i]] = true;
+ }
+ }
+ function _parse(resultSet, arg) {
+ if (!arg)
+ return;
+ var argType = typeof arg;
+ if (argType === "string") {
+ _parseString(resultSet, arg);
+ } else if (Array.isArray(arg)) {
+ _parseArray(resultSet, arg);
+ } else if (argType === "object") {
+ _parseObject(resultSet, arg);
+ } else if (argType === "number") {
+ _parseNumber(resultSet, arg);
+ }
+ }
+ function _classNames() {
+ var len = arguments.length;
+ var args = Array(len);
+ for (var i = 0; i < len; i++) {
+ args[i] = arguments[i];
+ }
+ var classSet = new StorageObject();
+ _parseArray(classSet, args);
+ var list = [];
+ for (var k in classSet) {
+ if (classSet[k]) {
+ list.push(k);
+ }
+ }
+ return list.join(" ");
+ }
+ return _classNames;
+ }();
+ if (typeof module3 !== "undefined" && module3.exports) {
+ module3.exports = classNames;
+ } else if (true) {
+ !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() {
+ return classNames;
+ }.apply(exports2, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== void 0 && (module3.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+ } else {
+ }
+ })();
+ },
+ "./node_modules/core-js/es/array/from.js": function(module3, exports2, __webpack_require__) {
+ __webpack_require__("./node_modules/core-js/modules/es.string.iterator.js");
+ __webpack_require__("./node_modules/core-js/modules/es.array.from.js");
+ var path3 = __webpack_require__("./node_modules/core-js/internals/path.js");
+ module3.exports = path3.Array.from;
+ },
+ "./node_modules/core-js/internals/a-function.js": function(module3, exports2) {
+ module3.exports = function(it) {
+ if (typeof it != "function") {
+ throw TypeError(String(it) + " is not a function");
+ }
+ return it;
+ };
+ },
+ "./node_modules/core-js/internals/an-object.js": function(module3, exports2, __webpack_require__) {
+ var isObject = __webpack_require__("./node_modules/core-js/internals/is-object.js");
+ module3.exports = function(it) {
+ if (!isObject(it)) {
+ throw TypeError(String(it) + " is not an object");
+ }
+ return it;
+ };
+ },
+ "./node_modules/core-js/internals/array-from.js": function(module3, exports2, __webpack_require__) {
+ "use strict";
+ var bind = __webpack_require__("./node_modules/core-js/internals/bind-context.js");
+ var toObject = __webpack_require__("./node_modules/core-js/internals/to-object.js");
+ var callWithSafeIterationClosing = __webpack_require__("./node_modules/core-js/internals/call-with-safe-iteration-closing.js");
+ var isArrayIteratorMethod = __webpack_require__("./node_modules/core-js/internals/is-array-iterator-method.js");
+ var toLength = __webpack_require__("./node_modules/core-js/internals/to-length.js");
+ var createProperty = __webpack_require__("./node_modules/core-js/internals/create-property.js");
+ var getIteratorMethod = __webpack_require__("./node_modules/core-js/internals/get-iterator-method.js");
+ module3.exports = function from(arrayLike) {
+ var O = toObject(arrayLike);
+ var C = typeof this == "function" ? this : Array;
+ var argumentsLength = arguments.length;
+ var mapfn = argumentsLength > 1 ? arguments[1] : void 0;
+ var mapping = mapfn !== void 0;
+ var index = 0;
+ var iteratorMethod = getIteratorMethod(O);
+ var length, result, step, iterator;
+ if (mapping)
+ mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : void 0, 2);
+ if (iteratorMethod != void 0 && !(C == Array && isArrayIteratorMethod(iteratorMethod))) {
+ iterator = iteratorMethod.call(O);
+ result = new C();
+ for (; !(step = iterator.next()).done; index++) {
+ createProperty(result, index, mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value);
+ }
+ } else {
+ length = toLength(O.length);
+ result = new C(length);
+ for (; length > index; index++) {
+ createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
+ }
+ }
+ result.length = index;
+ return result;
+ };
+ },
+ "./node_modules/core-js/internals/array-includes.js": function(module3, exports2, __webpack_require__) {
+ var toIndexedObject = __webpack_require__("./node_modules/core-js/internals/to-indexed-object.js");
+ var toLength = __webpack_require__("./node_modules/core-js/internals/to-length.js");
+ var toAbsoluteIndex = __webpack_require__("./node_modules/core-js/internals/to-absolute-index.js");
+ module3.exports = function(IS_INCLUDES) {
+ return function($this, el, fromIndex) {
+ var O = toIndexedObject($this);
+ var length = toLength(O.length);
+ var index = toAbsoluteIndex(fromIndex, length);
+ var value;
+ if (IS_INCLUDES && el != el)
+ while (length > index) {
+ value = O[index++];
+ if (value != value)
+ return true;
+ }
+ else
+ for (; length > index; index++)
+ if (IS_INCLUDES || index in O) {
+ if (O[index] === el)
+ return IS_INCLUDES || index || 0;
+ }
+ return !IS_INCLUDES && -1;
+ };
+ };
+ },
+ "./node_modules/core-js/internals/bind-context.js": function(module3, exports2, __webpack_require__) {
+ var aFunction = __webpack_require__("./node_modules/core-js/internals/a-function.js");
+ module3.exports = function(fn, that, length) {
+ aFunction(fn);
+ if (that === void 0)
+ return fn;
+ switch (length) {
+ case 0:
+ return function() {
+ return fn.call(that);
+ };
+ case 1:
+ return function(a) {
+ return fn.call(that, a);
+ };
+ case 2:
+ return function(a, b) {
+ return fn.call(that, a, b);
+ };
+ case 3:
+ return function(a, b, c) {
+ return fn.call(that, a, b, c);
+ };
+ }
+ return function() {
+ return fn.apply(that, arguments);
+ };
+ };
+ },
+ "./node_modules/core-js/internals/call-with-safe-iteration-closing.js": function(module3, exports2, __webpack_require__) {
+ var anObject = __webpack_require__("./node_modules/core-js/internals/an-object.js");
+ module3.exports = function(iterator, fn, value, ENTRIES) {
+ try {
+ return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
+ } catch (error) {
+ var returnMethod = iterator["return"];
+ if (returnMethod !== void 0)
+ anObject(returnMethod.call(iterator));
+ throw error;
+ }
+ };
+ },
+ "./node_modules/core-js/internals/check-correctness-of-iteration.js": function(module3, exports2, __webpack_require__) {
+ var wellKnownSymbol = __webpack_require__("./node_modules/core-js/internals/well-known-symbol.js");
+ var ITERATOR = wellKnownSymbol("iterator");
+ var SAFE_CLOSING = false;
+ try {
+ var called = 0;
+ var iteratorWithReturn = {
+ next: function() {
+ return { done: !!called++ };
+ },
+ "return": function() {
+ SAFE_CLOSING = true;
+ }
+ };
+ iteratorWithReturn[ITERATOR] = function() {
+ return this;
+ };
+ Array.from(iteratorWithReturn, function() {
+ throw 2;
+ });
+ } catch (error) {
+ }
+ module3.exports = function(exec, SKIP_CLOSING) {
+ if (!SKIP_CLOSING && !SAFE_CLOSING)
+ return false;
+ var ITERATION_SUPPORT = false;
+ try {
+ var object = {};
+ object[ITERATOR] = function() {
+ return {
+ next: function() {
+ return { done: ITERATION_SUPPORT = true };
+ }
+ };
+ };
+ exec(object);
+ } catch (error) {
+ }
+ return ITERATION_SUPPORT;
+ };
+ },
+ "./node_modules/core-js/internals/classof-raw.js": function(module3, exports2) {
+ var toString = {}.toString;
+ module3.exports = function(it) {
+ return toString.call(it).slice(8, -1);
+ };
+ },
+ "./node_modules/core-js/internals/classof.js": function(module3, exports2, __webpack_require__) {
+ var classofRaw = __webpack_require__("./node_modules/core-js/internals/classof-raw.js");
+ var wellKnownSymbol = __webpack_require__("./node_modules/core-js/internals/well-known-symbol.js");
+ var TO_STRING_TAG = wellKnownSymbol("toStringTag");
+ var CORRECT_ARGUMENTS = classofRaw(function() {
+ return arguments;
+ }()) == "Arguments";
+ var tryGet = function(it, key2) {
+ try {
+ return it[key2];
+ } catch (error) {
+ }
+ };
+ module3.exports = function(it) {
+ var O, tag, result;
+ return it === void 0 ? "Undefined" : it === null ? "Null" : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == "string" ? tag : CORRECT_ARGUMENTS ? classofRaw(O) : (result = classofRaw(O)) == "Object" && typeof O.callee == "function" ? "Arguments" : result;
+ };
+ },
+ "./node_modules/core-js/internals/copy-constructor-properties.js": function(module3, exports2, __webpack_require__) {
+ var has = __webpack_require__("./node_modules/core-js/internals/has.js");
+ var ownKeys = __webpack_require__("./node_modules/core-js/internals/own-keys.js");
+ var getOwnPropertyDescriptorModule = __webpack_require__("./node_modules/core-js/internals/object-get-own-property-descriptor.js");
+ var definePropertyModule = __webpack_require__("./node_modules/core-js/internals/object-define-property.js");
+ module3.exports = function(target, source) {
+ var keys = ownKeys(source);
+ var defineProperty = definePropertyModule.f;
+ var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
+ for (var i = 0; i < keys.length; i++) {
+ var key2 = keys[i];
+ if (!has(target, key2))
+ defineProperty(target, key2, getOwnPropertyDescriptor(source, key2));
+ }
+ };
+ },
+ "./node_modules/core-js/internals/correct-prototype-getter.js": function(module3, exports2, __webpack_require__) {
+ var fails = __webpack_require__("./node_modules/core-js/internals/fails.js");
+ module3.exports = !fails(function() {
+ function F() {
+ }
+ F.prototype.constructor = null;
+ return Object.getPrototypeOf(new F()) !== F.prototype;
+ });
+ },
+ "./node_modules/core-js/internals/create-iterator-constructor.js": function(module3, exports2, __webpack_require__) {
+ "use strict";
+ var IteratorPrototype = __webpack_require__("./node_modules/core-js/internals/iterators-core.js").IteratorPrototype;
+ var create = __webpack_require__("./node_modules/core-js/internals/object-create.js");
+ var createPropertyDescriptor = __webpack_require__("./node_modules/core-js/internals/create-property-descriptor.js");
+ var setToStringTag = __webpack_require__("./node_modules/core-js/internals/set-to-string-tag.js");
+ var Iterators = __webpack_require__("./node_modules/core-js/internals/iterators.js");
+ var returnThis = function() {
+ return this;
+ };
+ module3.exports = function(IteratorConstructor, NAME, next) {
+ var TO_STRING_TAG = NAME + " Iterator";
+ IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });
+ setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
+ Iterators[TO_STRING_TAG] = returnThis;
+ return IteratorConstructor;
+ };
+ },
+ "./node_modules/core-js/internals/create-property-descriptor.js": function(module3, exports2) {
+ module3.exports = function(bitmap, value) {
+ return {
+ enumerable: !(bitmap & 1),
+ configurable: !(bitmap & 2),
+ writable: !(bitmap & 4),
+ value
+ };
+ };
+ },
+ "./node_modules/core-js/internals/create-property.js": function(module3, exports2, __webpack_require__) {
+ "use strict";
+ var toPrimitive = __webpack_require__("./node_modules/core-js/internals/to-primitive.js");
+ var definePropertyModule = __webpack_require__("./node_modules/core-js/internals/object-define-property.js");
+ var createPropertyDescriptor = __webpack_require__("./node_modules/core-js/internals/create-property-descriptor.js");
+ module3.exports = function(object, key2, value) {
+ var propertyKey = toPrimitive(key2);
+ if (propertyKey in object)
+ definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
+ else
+ object[propertyKey] = value;
+ };
+ },
+ "./node_modules/core-js/internals/define-iterator.js": function(module3, exports2, __webpack_require__) {
+ "use strict";
+ var $ = __webpack_require__("./node_modules/core-js/internals/export.js");
+ var createIteratorConstructor = __webpack_require__("./node_modules/core-js/internals/create-iterator-constructor.js");
+ var getPrototypeOf = __webpack_require__("./node_modules/core-js/internals/object-get-prototype-of.js");
+ var setPrototypeOf = __webpack_require__("./node_modules/core-js/internals/object-set-prototype-of.js");
+ var setToStringTag = __webpack_require__("./node_modules/core-js/internals/set-to-string-tag.js");
+ var hide = __webpack_require__("./node_modules/core-js/internals/hide.js");
+ var redefine = __webpack_require__("./node_modules/core-js/internals/redefine.js");
+ var wellKnownSymbol = __webpack_require__("./node_modules/core-js/internals/well-known-symbol.js");
+ var IS_PURE = __webpack_require__("./node_modules/core-js/internals/is-pure.js");
+ var Iterators = __webpack_require__("./node_modules/core-js/internals/iterators.js");
+ var IteratorsCore = __webpack_require__("./node_modules/core-js/internals/iterators-core.js");
+ var IteratorPrototype = IteratorsCore.IteratorPrototype;
+ var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
+ var ITERATOR = wellKnownSymbol("iterator");
+ var KEYS = "keys";
+ var VALUES = "values";
+ var ENTRIES = "entries";
+ var returnThis = function() {
+ return this;
+ };
+ module3.exports = function(Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
+ createIteratorConstructor(IteratorConstructor, NAME, next);
+ var getIterationMethod = function(KIND) {
+ if (KIND === DEFAULT && defaultIterator)
+ return defaultIterator;
+ if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype)
+ return IterablePrototype[KIND];
+ switch (KIND) {
+ case KEYS:
+ return function keys() {
+ return new IteratorConstructor(this, KIND);
+ };
+ case VALUES:
+ return function values() {
+ return new IteratorConstructor(this, KIND);
+ };
+ case ENTRIES:
+ return function entries() {
+ return new IteratorConstructor(this, KIND);
+ };
+ }
+ return function() {
+ return new IteratorConstructor(this);
+ };
+ };
+ var TO_STRING_TAG = NAME + " Iterator";
+ var INCORRECT_VALUES_NAME = false;
+ var IterablePrototype = Iterable.prototype;
+ var nativeIterator = IterablePrototype[ITERATOR] || IterablePrototype["@@iterator"] || DEFAULT && IterablePrototype[DEFAULT];
+ var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
+ var anyNativeIterator = NAME == "Array" ? IterablePrototype.entries || nativeIterator : nativeIterator;
+ var CurrentIteratorPrototype, methods, KEY;
+ if (anyNativeIterator) {
+ CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
+ if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
+ if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
+ if (setPrototypeOf) {
+ setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
+ } else if (typeof CurrentIteratorPrototype[ITERATOR] != "function") {
+ hide(CurrentIteratorPrototype, ITERATOR, returnThis);
+ }
+ }
+ setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
+ if (IS_PURE)
+ Iterators[TO_STRING_TAG] = returnThis;
+ }
+ }
+ if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
+ INCORRECT_VALUES_NAME = true;
+ defaultIterator = function values() {
+ return nativeIterator.call(this);
+ };
+ }
+ if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
+ hide(IterablePrototype, ITERATOR, defaultIterator);
+ }
+ Iterators[NAME] = defaultIterator;
+ if (DEFAULT) {
+ methods = {
+ values: getIterationMethod(VALUES),
+ keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
+ entries: getIterationMethod(ENTRIES)
+ };
+ if (FORCED)
+ for (KEY in methods) {
+ if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
+ redefine(IterablePrototype, KEY, methods[KEY]);
+ }
+ }
+ else
+ $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
+ }
+ return methods;
+ };
+ },
+ "./node_modules/core-js/internals/descriptors.js": function(module3, exports2, __webpack_require__) {
+ var fails = __webpack_require__("./node_modules/core-js/internals/fails.js");
+ module3.exports = !fails(function() {
+ return Object.defineProperty({}, "a", { get: function() {
+ return 7;
+ } }).a != 7;
+ });
+ },
+ "./node_modules/core-js/internals/document-create-element.js": function(module3, exports2, __webpack_require__) {
+ var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
+ var isObject = __webpack_require__("./node_modules/core-js/internals/is-object.js");
+ var document2 = global2.document;
+ var exist = isObject(document2) && isObject(document2.createElement);
+ module3.exports = function(it) {
+ return exist ? document2.createElement(it) : {};
+ };
+ },
+ "./node_modules/core-js/internals/enum-bug-keys.js": function(module3, exports2) {
+ module3.exports = [
+ "constructor",
+ "hasOwnProperty",
+ "isPrototypeOf",
+ "propertyIsEnumerable",
+ "toLocaleString",
+ "toString",
+ "valueOf"
+ ];
+ },
+ "./node_modules/core-js/internals/export.js": function(module3, exports2, __webpack_require__) {
+ var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
+ var getOwnPropertyDescriptor = __webpack_require__("./node_modules/core-js/internals/object-get-own-property-descriptor.js").f;
+ var hide = __webpack_require__("./node_modules/core-js/internals/hide.js");
+ var redefine = __webpack_require__("./node_modules/core-js/internals/redefine.js");
+ var setGlobal = __webpack_require__("./node_modules/core-js/internals/set-global.js");
+ var copyConstructorProperties = __webpack_require__("./node_modules/core-js/internals/copy-constructor-properties.js");
+ var isForced = __webpack_require__("./node_modules/core-js/internals/is-forced.js");
+ module3.exports = function(options, source) {
+ var TARGET = options.target;
+ var GLOBAL = options.global;
+ var STATIC = options.stat;
+ var FORCED, target, key2, targetProperty, sourceProperty, descriptor;
+ if (GLOBAL) {
+ target = global2;
+ } else if (STATIC) {
+ target = global2[TARGET] || setGlobal(TARGET, {});
+ } else {
+ target = (global2[TARGET] || {}).prototype;
+ }
+ if (target)
+ for (key2 in source) {
+ sourceProperty = source[key2];
+ if (options.noTargetGet) {
+ descriptor = getOwnPropertyDescriptor(target, key2);
+ targetProperty = descriptor && descriptor.value;
+ } else
+ targetProperty = target[key2];
+ FORCED = isForced(GLOBAL ? key2 : TARGET + (STATIC ? "." : "#") + key2, options.forced);
+ if (!FORCED && targetProperty !== void 0) {
+ if (typeof sourceProperty === typeof targetProperty)
+ continue;
+ copyConstructorProperties(sourceProperty, targetProperty);
+ }
+ if (options.sham || targetProperty && targetProperty.sham) {
+ hide(sourceProperty, "sham", true);
+ }
+ redefine(target, key2, sourceProperty, options);
+ }
+ };
+ },
+ "./node_modules/core-js/internals/fails.js": function(module3, exports2) {
+ module3.exports = function(exec) {
+ try {
+ return !!exec();
+ } catch (error) {
+ return true;
+ }
+ };
+ },
+ "./node_modules/core-js/internals/function-to-string.js": function(module3, exports2, __webpack_require__) {
+ var shared = __webpack_require__("./node_modules/core-js/internals/shared.js");
+ module3.exports = shared("native-function-to-string", Function.toString);
+ },
+ "./node_modules/core-js/internals/get-iterator-method.js": function(module3, exports2, __webpack_require__) {
+ var classof = __webpack_require__("./node_modules/core-js/internals/classof.js");
+ var Iterators = __webpack_require__("./node_modules/core-js/internals/iterators.js");
+ var wellKnownSymbol = __webpack_require__("./node_modules/core-js/internals/well-known-symbol.js");
+ var ITERATOR = wellKnownSymbol("iterator");
+ module3.exports = function(it) {
+ if (it != void 0)
+ return it[ITERATOR] || it["@@iterator"] || Iterators[classof(it)];
+ };
+ },
+ "./node_modules/core-js/internals/global.js": function(module3, exports2, __webpack_require__) {
+ (function(global2) {
+ var O = "object";
+ var check = function(it) {
+ return it && it.Math == Math && it;
+ };
+ module3.exports = check(typeof globalThis == O && globalThis) || check(typeof window == O && window) || check(typeof self == O && self) || check(typeof global2 == O && global2) || Function("return this")();
+ }).call(this, __webpack_require__("./node_modules/webpack/buildin/global.js"));
+ },
+ "./node_modules/core-js/internals/has.js": function(module3, exports2) {
+ var hasOwnProperty = {}.hasOwnProperty;
+ module3.exports = function(it, key2) {
+ return hasOwnProperty.call(it, key2);
+ };
+ },
+ "./node_modules/core-js/internals/hidden-keys.js": function(module3, exports2) {
+ module3.exports = {};
+ },
+ "./node_modules/core-js/internals/hide.js": function(module3, exports2, __webpack_require__) {
+ var DESCRIPTORS = __webpack_require__("./node_modules/core-js/internals/descriptors.js");
+ var definePropertyModule = __webpack_require__("./node_modules/core-js/internals/object-define-property.js");
+ var createPropertyDescriptor = __webpack_require__("./node_modules/core-js/internals/create-property-descriptor.js");
+ module3.exports = DESCRIPTORS ? function(object, key2, value) {
+ return definePropertyModule.f(object, key2, createPropertyDescriptor(1, value));
+ } : function(object, key2, value) {
+ object[key2] = value;
+ return object;
+ };
+ },
+ "./node_modules/core-js/internals/html.js": function(module3, exports2, __webpack_require__) {
+ var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
+ var document2 = global2.document;
+ module3.exports = document2 && document2.documentElement;
+ },
+ "./node_modules/core-js/internals/ie8-dom-define.js": function(module3, exports2, __webpack_require__) {
+ var DESCRIPTORS = __webpack_require__("./node_modules/core-js/internals/descriptors.js");
+ var fails = __webpack_require__("./node_modules/core-js/internals/fails.js");
+ var createElement = __webpack_require__("./node_modules/core-js/internals/document-create-element.js");
+ module3.exports = !DESCRIPTORS && !fails(function() {
+ return Object.defineProperty(createElement("div"), "a", {
+ get: function() {
+ return 7;
+ }
+ }).a != 7;
+ });
+ },
+ "./node_modules/core-js/internals/indexed-object.js": function(module3, exports2, __webpack_require__) {
+ var fails = __webpack_require__("./node_modules/core-js/internals/fails.js");
+ var classof = __webpack_require__("./node_modules/core-js/internals/classof-raw.js");
+ var split = "".split;
+ module3.exports = fails(function() {
+ return !Object("z").propertyIsEnumerable(0);
+ }) ? function(it) {
+ return classof(it) == "String" ? split.call(it, "") : Object(it);
+ } : Object;
+ },
+ "./node_modules/core-js/internals/internal-state.js": function(module3, exports2, __webpack_require__) {
+ var NATIVE_WEAK_MAP = __webpack_require__("./node_modules/core-js/internals/native-weak-map.js");
+ var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
+ var isObject = __webpack_require__("./node_modules/core-js/internals/is-object.js");
+ var hide = __webpack_require__("./node_modules/core-js/internals/hide.js");
+ var objectHas = __webpack_require__("./node_modules/core-js/internals/has.js");
+ var sharedKey = __webpack_require__("./node_modules/core-js/internals/shared-key.js");
+ var hiddenKeys = __webpack_require__("./node_modules/core-js/internals/hidden-keys.js");
+ var WeakMap2 = global2.WeakMap;
+ var set, get, has;
+ var enforce = function(it) {
+ return has(it) ? get(it) : set(it, {});
+ };
+ var getterFor = function(TYPE) {
+ return function(it) {
+ var state;
+ if (!isObject(it) || (state = get(it)).type !== TYPE) {
+ throw TypeError("Incompatible receiver, " + TYPE + " required");
+ }
+ return state;
+ };
+ };
+ if (NATIVE_WEAK_MAP) {
+ var store = new WeakMap2();
+ var wmget = store.get;
+ var wmhas = store.has;
+ var wmset = store.set;
+ set = function(it, metadata) {
+ wmset.call(store, it, metadata);
+ return metadata;
+ };
+ get = function(it) {
+ return wmget.call(store, it) || {};
+ };
+ has = function(it) {
+ return wmhas.call(store, it);
+ };
+ } else {
+ var STATE = sharedKey("state");
+ hiddenKeys[STATE] = true;
+ set = function(it, metadata) {
+ hide(it, STATE, metadata);
+ return metadata;
+ };
+ get = function(it) {
+ return objectHas(it, STATE) ? it[STATE] : {};
+ };
+ has = function(it) {
+ return objectHas(it, STATE);
+ };
+ }
+ module3.exports = {
+ set,
+ get,
+ has,
+ enforce,
+ getterFor
+ };
+ },
+ "./node_modules/core-js/internals/is-array-iterator-method.js": function(module3, exports2, __webpack_require__) {
+ var wellKnownSymbol = __webpack_require__("./node_modules/core-js/internals/well-known-symbol.js");
+ var Iterators = __webpack_require__("./node_modules/core-js/internals/iterators.js");
+ var ITERATOR = wellKnownSymbol("iterator");
+ var ArrayPrototype = Array.prototype;
+ module3.exports = function(it) {
+ return it !== void 0 && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
+ };
+ },
+ "./node_modules/core-js/internals/is-forced.js": function(module3, exports2, __webpack_require__) {
+ var fails = __webpack_require__("./node_modules/core-js/internals/fails.js");
+ var replacement = /#|\.prototype\./;
+ var isForced = function(feature, detection) {
+ var value = data[normalize2(feature)];
+ return value == POLYFILL ? true : value == NATIVE ? false : typeof detection == "function" ? fails(detection) : !!detection;
+ };
+ var normalize2 = isForced.normalize = function(string) {
+ return String(string).replace(replacement, ".").toLowerCase();
+ };
+ var data = isForced.data = {};
+ var NATIVE = isForced.NATIVE = "N";
+ var POLYFILL = isForced.POLYFILL = "P";
+ module3.exports = isForced;
+ },
+ "./node_modules/core-js/internals/is-object.js": function(module3, exports2) {
+ module3.exports = function(it) {
+ return typeof it === "object" ? it !== null : typeof it === "function";
+ };
+ },
+ "./node_modules/core-js/internals/is-pure.js": function(module3, exports2) {
+ module3.exports = false;
+ },
+ "./node_modules/core-js/internals/iterators-core.js": function(module3, exports2, __webpack_require__) {
+ "use strict";
+ var getPrototypeOf = __webpack_require__("./node_modules/core-js/internals/object-get-prototype-of.js");
+ var hide = __webpack_require__("./node_modules/core-js/internals/hide.js");
+ var has = __webpack_require__("./node_modules/core-js/internals/has.js");
+ var wellKnownSymbol = __webpack_require__("./node_modules/core-js/internals/well-known-symbol.js");
+ var IS_PURE = __webpack_require__("./node_modules/core-js/internals/is-pure.js");
+ var ITERATOR = wellKnownSymbol("iterator");
+ var BUGGY_SAFARI_ITERATORS = false;
+ var returnThis = function() {
+ return this;
+ };
+ var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
+ if ([].keys) {
+ arrayIterator = [].keys();
+ if (!("next" in arrayIterator))
+ BUGGY_SAFARI_ITERATORS = true;
+ else {
+ PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
+ if (PrototypeOfArrayIteratorPrototype !== Object.prototype)
+ IteratorPrototype = PrototypeOfArrayIteratorPrototype;
+ }
+ }
+ if (IteratorPrototype == void 0)
+ IteratorPrototype = {};
+ if (!IS_PURE && !has(IteratorPrototype, ITERATOR))
+ hide(IteratorPrototype, ITERATOR, returnThis);
+ module3.exports = {
+ IteratorPrototype,
+ BUGGY_SAFARI_ITERATORS
+ };
+ },
+ "./node_modules/core-js/internals/iterators.js": function(module3, exports2) {
+ module3.exports = {};
+ },
+ "./node_modules/core-js/internals/native-symbol.js": function(module3, exports2, __webpack_require__) {
+ var fails = __webpack_require__("./node_modules/core-js/internals/fails.js");
+ module3.exports = !!Object.getOwnPropertySymbols && !fails(function() {
+ return !String(Symbol());
+ });
+ },
+ "./node_modules/core-js/internals/native-weak-map.js": function(module3, exports2, __webpack_require__) {
+ var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
+ var nativeFunctionToString = __webpack_require__("./node_modules/core-js/internals/function-to-string.js");
+ var WeakMap2 = global2.WeakMap;
+ module3.exports = typeof WeakMap2 === "function" && /native code/.test(nativeFunctionToString.call(WeakMap2));
+ },
+ "./node_modules/core-js/internals/object-create.js": function(module3, exports2, __webpack_require__) {
+ var anObject = __webpack_require__("./node_modules/core-js/internals/an-object.js");
+ var defineProperties = __webpack_require__("./node_modules/core-js/internals/object-define-properties.js");
+ var enumBugKeys = __webpack_require__("./node_modules/core-js/internals/enum-bug-keys.js");
+ var hiddenKeys = __webpack_require__("./node_modules/core-js/internals/hidden-keys.js");
+ var html2 = __webpack_require__("./node_modules/core-js/internals/html.js");
+ var documentCreateElement = __webpack_require__("./node_modules/core-js/internals/document-create-element.js");
+ var sharedKey = __webpack_require__("./node_modules/core-js/internals/shared-key.js");
+ var IE_PROTO = sharedKey("IE_PROTO");
+ var PROTOTYPE = "prototype";
+ var Empty = function() {
+ };
+ var createDict = function() {
+ var iframe = documentCreateElement("iframe");
+ var length = enumBugKeys.length;
+ var lt = "<";
+ var script = "script";
+ var gt = ">";
+ var js = "java" + script + ":";
+ var iframeDocument;
+ iframe.style.display = "none";
+ html2.appendChild(iframe);
+ iframe.src = String(js);
+ iframeDocument = iframe.contentWindow.document;
+ iframeDocument.open();
+ iframeDocument.write(lt + script + gt + "document.F=Object" + lt + "/" + script + gt);
+ iframeDocument.close();
+ createDict = iframeDocument.F;
+ while (length--)
+ delete createDict[PROTOTYPE][enumBugKeys[length]];
+ return createDict();
+ };
+ module3.exports = Object.create || function create(O, Properties) {
+ var result;
+ if (O !== null) {
+ Empty[PROTOTYPE] = anObject(O);
+ result = new Empty();
+ Empty[PROTOTYPE] = null;
+ result[IE_PROTO] = O;
+ } else
+ result = createDict();
+ return Properties === void 0 ? result : defineProperties(result, Properties);
+ };
+ hiddenKeys[IE_PROTO] = true;
+ },
+ "./node_modules/core-js/internals/object-define-properties.js": function(module3, exports2, __webpack_require__) {
+ var DESCRIPTORS = __webpack_require__("./node_modules/core-js/internals/descriptors.js");
+ var definePropertyModule = __webpack_require__("./node_modules/core-js/internals/object-define-property.js");
+ var anObject = __webpack_require__("./node_modules/core-js/internals/an-object.js");
+ var objectKeys = __webpack_require__("./node_modules/core-js/internals/object-keys.js");
+ module3.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {
+ anObject(O);
+ var keys = objectKeys(Properties);
+ var length = keys.length;
+ var i = 0;
+ var key2;
+ while (length > i)
+ definePropertyModule.f(O, key2 = keys[i++], Properties[key2]);
+ return O;
+ };
+ },
+ "./node_modules/core-js/internals/object-define-property.js": function(module3, exports2, __webpack_require__) {
+ var DESCRIPTORS = __webpack_require__("./node_modules/core-js/internals/descriptors.js");
+ var IE8_DOM_DEFINE = __webpack_require__("./node_modules/core-js/internals/ie8-dom-define.js");
+ var anObject = __webpack_require__("./node_modules/core-js/internals/an-object.js");
+ var toPrimitive = __webpack_require__("./node_modules/core-js/internals/to-primitive.js");
+ var nativeDefineProperty = Object.defineProperty;
+ exports2.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
+ anObject(O);
+ P = toPrimitive(P, true);
+ anObject(Attributes);
+ if (IE8_DOM_DEFINE)
+ try {
+ return nativeDefineProperty(O, P, Attributes);
+ } catch (error) {
+ }
+ if ("get" in Attributes || "set" in Attributes)
+ throw TypeError("Accessors not supported");
+ if ("value" in Attributes)
+ O[P] = Attributes.value;
+ return O;
+ };
+ },
+ "./node_modules/core-js/internals/object-get-own-property-descriptor.js": function(module3, exports2, __webpack_require__) {
+ var DESCRIPTORS = __webpack_require__("./node_modules/core-js/internals/descriptors.js");
+ var propertyIsEnumerableModule = __webpack_require__("./node_modules/core-js/internals/object-property-is-enumerable.js");
+ var createPropertyDescriptor = __webpack_require__("./node_modules/core-js/internals/create-property-descriptor.js");
+ var toIndexedObject = __webpack_require__("./node_modules/core-js/internals/to-indexed-object.js");
+ var toPrimitive = __webpack_require__("./node_modules/core-js/internals/to-primitive.js");
+ var has = __webpack_require__("./node_modules/core-js/internals/has.js");
+ var IE8_DOM_DEFINE = __webpack_require__("./node_modules/core-js/internals/ie8-dom-define.js");
+ var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+ exports2.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
+ O = toIndexedObject(O);
+ P = toPrimitive(P, true);
+ if (IE8_DOM_DEFINE)
+ try {
+ return nativeGetOwnPropertyDescriptor(O, P);
+ } catch (error) {
+ }
+ if (has(O, P))
+ return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);
+ };
+ },
+ "./node_modules/core-js/internals/object-get-own-property-names.js": function(module3, exports2, __webpack_require__) {
+ var internalObjectKeys = __webpack_require__("./node_modules/core-js/internals/object-keys-internal.js");
+ var enumBugKeys = __webpack_require__("./node_modules/core-js/internals/enum-bug-keys.js");
+ var hiddenKeys = enumBugKeys.concat("length", "prototype");
+ exports2.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+ return internalObjectKeys(O, hiddenKeys);
+ };
+ },
+ "./node_modules/core-js/internals/object-get-own-property-symbols.js": function(module3, exports2) {
+ exports2.f = Object.getOwnPropertySymbols;
+ },
+ "./node_modules/core-js/internals/object-get-prototype-of.js": function(module3, exports2, __webpack_require__) {
+ var has = __webpack_require__("./node_modules/core-js/internals/has.js");
+ var toObject = __webpack_require__("./node_modules/core-js/internals/to-object.js");
+ var sharedKey = __webpack_require__("./node_modules/core-js/internals/shared-key.js");
+ var CORRECT_PROTOTYPE_GETTER = __webpack_require__("./node_modules/core-js/internals/correct-prototype-getter.js");
+ var IE_PROTO = sharedKey("IE_PROTO");
+ var ObjectPrototype = Object.prototype;
+ module3.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function(O) {
+ O = toObject(O);
+ if (has(O, IE_PROTO))
+ return O[IE_PROTO];
+ if (typeof O.constructor == "function" && O instanceof O.constructor) {
+ return O.constructor.prototype;
+ }
+ return O instanceof Object ? ObjectPrototype : null;
+ };
+ },
+ "./node_modules/core-js/internals/object-keys-internal.js": function(module3, exports2, __webpack_require__) {
+ var has = __webpack_require__("./node_modules/core-js/internals/has.js");
+ var toIndexedObject = __webpack_require__("./node_modules/core-js/internals/to-indexed-object.js");
+ var arrayIncludes = __webpack_require__("./node_modules/core-js/internals/array-includes.js");
+ var hiddenKeys = __webpack_require__("./node_modules/core-js/internals/hidden-keys.js");
+ var arrayIndexOf = arrayIncludes(false);
+ module3.exports = function(object, names) {
+ var O = toIndexedObject(object);
+ var i = 0;
+ var result = [];
+ var key2;
+ for (key2 in O)
+ !has(hiddenKeys, key2) && has(O, key2) && result.push(key2);
+ while (names.length > i)
+ if (has(O, key2 = names[i++])) {
+ ~arrayIndexOf(result, key2) || result.push(key2);
+ }
+ return result;
+ };
+ },
+ "./node_modules/core-js/internals/object-keys.js": function(module3, exports2, __webpack_require__) {
+ var internalObjectKeys = __webpack_require__("./node_modules/core-js/internals/object-keys-internal.js");
+ var enumBugKeys = __webpack_require__("./node_modules/core-js/internals/enum-bug-keys.js");
+ module3.exports = Object.keys || function keys(O) {
+ return internalObjectKeys(O, enumBugKeys);
+ };
+ },
+ "./node_modules/core-js/internals/object-property-is-enumerable.js": function(module3, exports2, __webpack_require__) {
+ "use strict";
+ var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
+ var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+ var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);
+ exports2.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+ var descriptor = getOwnPropertyDescriptor(this, V);
+ return !!descriptor && descriptor.enumerable;
+ } : nativePropertyIsEnumerable;
+ },
+ "./node_modules/core-js/internals/object-set-prototype-of.js": function(module3, exports2, __webpack_require__) {
+ var validateSetPrototypeOfArguments = __webpack_require__("./node_modules/core-js/internals/validate-set-prototype-of-arguments.js");
+ module3.exports = Object.setPrototypeOf || ("__proto__" in {} ? function() {
+ var correctSetter = false;
+ var test = {};
+ var setter;
+ try {
+ setter = Object.getOwnPropertyDescriptor(Object.prototype, "__proto__").set;
+ setter.call(test, []);
+ correctSetter = test instanceof Array;
+ } catch (error) {
+ }
+ return function setPrototypeOf(O, proto) {
+ validateSetPrototypeOfArguments(O, proto);
+ if (correctSetter)
+ setter.call(O, proto);
+ else
+ O.__proto__ = proto;
+ return O;
+ };
+ }() : void 0);
+ },
+ "./node_modules/core-js/internals/own-keys.js": function(module3, exports2, __webpack_require__) {
+ var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
+ var getOwnPropertyNamesModule = __webpack_require__("./node_modules/core-js/internals/object-get-own-property-names.js");
+ var getOwnPropertySymbolsModule = __webpack_require__("./node_modules/core-js/internals/object-get-own-property-symbols.js");
+ var anObject = __webpack_require__("./node_modules/core-js/internals/an-object.js");
+ var Reflect2 = global2.Reflect;
+ module3.exports = Reflect2 && Reflect2.ownKeys || function ownKeys(it) {
+ var keys = getOwnPropertyNamesModule.f(anObject(it));
+ var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+ return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
+ };
+ },
+ "./node_modules/core-js/internals/path.js": function(module3, exports2, __webpack_require__) {
+ module3.exports = __webpack_require__("./node_modules/core-js/internals/global.js");
+ },
+ "./node_modules/core-js/internals/redefine.js": function(module3, exports2, __webpack_require__) {
+ var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
+ var shared = __webpack_require__("./node_modules/core-js/internals/shared.js");
+ var hide = __webpack_require__("./node_modules/core-js/internals/hide.js");
+ var has = __webpack_require__("./node_modules/core-js/internals/has.js");
+ var setGlobal = __webpack_require__("./node_modules/core-js/internals/set-global.js");
+ var nativeFunctionToString = __webpack_require__("./node_modules/core-js/internals/function-to-string.js");
+ var InternalStateModule = __webpack_require__("./node_modules/core-js/internals/internal-state.js");
+ var getInternalState = InternalStateModule.get;
+ var enforceInternalState = InternalStateModule.enforce;
+ var TEMPLATE = String(nativeFunctionToString).split("toString");
+ shared("inspectSource", function(it) {
+ return nativeFunctionToString.call(it);
+ });
+ (module3.exports = function(O, key2, value, options) {
+ var unsafe = options ? !!options.unsafe : false;
+ var simple = options ? !!options.enumerable : false;
+ var noTargetGet = options ? !!options.noTargetGet : false;
+ if (typeof value == "function") {
+ if (typeof key2 == "string" && !has(value, "name"))
+ hide(value, "name", key2);
+ enforceInternalState(value).source = TEMPLATE.join(typeof key2 == "string" ? key2 : "");
+ }
+ if (O === global2) {
+ if (simple)
+ O[key2] = value;
+ else
+ setGlobal(key2, value);
+ return;
+ } else if (!unsafe) {
+ delete O[key2];
+ } else if (!noTargetGet && O[key2]) {
+ simple = true;
+ }
+ if (simple)
+ O[key2] = value;
+ else
+ hide(O, key2, value);
+ })(Function.prototype, "toString", function toString() {
+ return typeof this == "function" && getInternalState(this).source || nativeFunctionToString.call(this);
+ });
+ },
+ "./node_modules/core-js/internals/require-object-coercible.js": function(module3, exports2) {
+ module3.exports = function(it) {
+ if (it == void 0)
+ throw TypeError("Can't call method on " + it);
+ return it;
+ };
+ },
+ "./node_modules/core-js/internals/set-global.js": function(module3, exports2, __webpack_require__) {
+ var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
+ var hide = __webpack_require__("./node_modules/core-js/internals/hide.js");
+ module3.exports = function(key2, value) {
+ try {
+ hide(global2, key2, value);
+ } catch (error) {
+ global2[key2] = value;
+ }
+ return value;
+ };
+ },
+ "./node_modules/core-js/internals/set-to-string-tag.js": function(module3, exports2, __webpack_require__) {
+ var defineProperty = __webpack_require__("./node_modules/core-js/internals/object-define-property.js").f;
+ var has = __webpack_require__("./node_modules/core-js/internals/has.js");
+ var wellKnownSymbol = __webpack_require__("./node_modules/core-js/internals/well-known-symbol.js");
+ var TO_STRING_TAG = wellKnownSymbol("toStringTag");
+ module3.exports = function(it, TAG, STATIC) {
+ if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {
+ defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });
+ }
+ };
+ },
+ "./node_modules/core-js/internals/shared-key.js": function(module3, exports2, __webpack_require__) {
+ var shared = __webpack_require__("./node_modules/core-js/internals/shared.js");
+ var uid = __webpack_require__("./node_modules/core-js/internals/uid.js");
+ var keys = shared("keys");
+ module3.exports = function(key2) {
+ return keys[key2] || (keys[key2] = uid(key2));
+ };
+ },
+ "./node_modules/core-js/internals/shared.js": function(module3, exports2, __webpack_require__) {
+ var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
+ var setGlobal = __webpack_require__("./node_modules/core-js/internals/set-global.js");
+ var IS_PURE = __webpack_require__("./node_modules/core-js/internals/is-pure.js");
+ var SHARED = "__core-js_shared__";
+ var store = global2[SHARED] || setGlobal(SHARED, {});
+ (module3.exports = function(key2, value) {
+ return store[key2] || (store[key2] = value !== void 0 ? value : {});
+ })("versions", []).push({
+ version: "3.1.3",
+ mode: IS_PURE ? "pure" : "global",
+ copyright: "\xA9 2019 Denis Pushkarev (zloirock.ru)"
+ });
+ },
+ "./node_modules/core-js/internals/string-at.js": function(module3, exports2, __webpack_require__) {
+ var toInteger = __webpack_require__("./node_modules/core-js/internals/to-integer.js");
+ var requireObjectCoercible = __webpack_require__("./node_modules/core-js/internals/require-object-coercible.js");
+ module3.exports = function(that, pos, CONVERT_TO_STRING) {
+ var S = String(requireObjectCoercible(that));
+ var position = toInteger(pos);
+ var size = S.length;
+ var first2, second;
+ if (position < 0 || position >= size)
+ return CONVERT_TO_STRING ? "" : void 0;
+ first2 = S.charCodeAt(position);
+ return first2 < 55296 || first2 > 56319 || position + 1 === size || (second = S.charCodeAt(position + 1)) < 56320 || second > 57343 ? CONVERT_TO_STRING ? S.charAt(position) : first2 : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first2 - 55296 << 10) + (second - 56320) + 65536;
+ };
+ },
+ "./node_modules/core-js/internals/to-absolute-index.js": function(module3, exports2, __webpack_require__) {
+ var toInteger = __webpack_require__("./node_modules/core-js/internals/to-integer.js");
+ var max = Math.max;
+ var min = Math.min;
+ module3.exports = function(index, length) {
+ var integer = toInteger(index);
+ return integer < 0 ? max(integer + length, 0) : min(integer, length);
+ };
+ },
+ "./node_modules/core-js/internals/to-indexed-object.js": function(module3, exports2, __webpack_require__) {
+ var IndexedObject = __webpack_require__("./node_modules/core-js/internals/indexed-object.js");
+ var requireObjectCoercible = __webpack_require__("./node_modules/core-js/internals/require-object-coercible.js");
+ module3.exports = function(it) {
+ return IndexedObject(requireObjectCoercible(it));
+ };
+ },
+ "./node_modules/core-js/internals/to-integer.js": function(module3, exports2) {
+ var ceil = Math.ceil;
+ var floor = Math.floor;
+ module3.exports = function(argument) {
+ return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
+ };
+ },
+ "./node_modules/core-js/internals/to-length.js": function(module3, exports2, __webpack_require__) {
+ var toInteger = __webpack_require__("./node_modules/core-js/internals/to-integer.js");
+ var min = Math.min;
+ module3.exports = function(argument) {
+ return argument > 0 ? min(toInteger(argument), 9007199254740991) : 0;
+ };
+ },
+ "./node_modules/core-js/internals/to-object.js": function(module3, exports2, __webpack_require__) {
+ var requireObjectCoercible = __webpack_require__("./node_modules/core-js/internals/require-object-coercible.js");
+ module3.exports = function(argument) {
+ return Object(requireObjectCoercible(argument));
+ };
+ },
+ "./node_modules/core-js/internals/to-primitive.js": function(module3, exports2, __webpack_require__) {
+ var isObject = __webpack_require__("./node_modules/core-js/internals/is-object.js");
+ module3.exports = function(it, S) {
+ if (!isObject(it))
+ return it;
+ var fn, val;
+ if (S && typeof (fn = it.toString) == "function" && !isObject(val = fn.call(it)))
+ return val;
+ if (typeof (fn = it.valueOf) == "function" && !isObject(val = fn.call(it)))
+ return val;
+ if (!S && typeof (fn = it.toString) == "function" && !isObject(val = fn.call(it)))
+ return val;
+ throw TypeError("Can't convert object to primitive value");
+ };
+ },
+ "./node_modules/core-js/internals/uid.js": function(module3, exports2) {
+ var id = 0;
+ var postfix = Math.random();
+ module3.exports = function(key2) {
+ return "Symbol(".concat(key2 === void 0 ? "" : key2, ")_", (++id + postfix).toString(36));
+ };
+ },
+ "./node_modules/core-js/internals/validate-set-prototype-of-arguments.js": function(module3, exports2, __webpack_require__) {
+ var isObject = __webpack_require__("./node_modules/core-js/internals/is-object.js");
+ var anObject = __webpack_require__("./node_modules/core-js/internals/an-object.js");
+ module3.exports = function(O, proto) {
+ anObject(O);
+ if (!isObject(proto) && proto !== null) {
+ throw TypeError("Can't set " + String(proto) + " as a prototype");
+ }
+ };
+ },
+ "./node_modules/core-js/internals/well-known-symbol.js": function(module3, exports2, __webpack_require__) {
+ var global2 = __webpack_require__("./node_modules/core-js/internals/global.js");
+ var shared = __webpack_require__("./node_modules/core-js/internals/shared.js");
+ var uid = __webpack_require__("./node_modules/core-js/internals/uid.js");
+ var NATIVE_SYMBOL = __webpack_require__("./node_modules/core-js/internals/native-symbol.js");
+ var Symbol2 = global2.Symbol;
+ var store = shared("wks");
+ module3.exports = function(name) {
+ return store[name] || (store[name] = NATIVE_SYMBOL && Symbol2[name] || (NATIVE_SYMBOL ? Symbol2 : uid)("Symbol." + name));
+ };
+ },
+ "./node_modules/core-js/modules/es.array.from.js": function(module3, exports2, __webpack_require__) {
+ var $ = __webpack_require__("./node_modules/core-js/internals/export.js");
+ var from = __webpack_require__("./node_modules/core-js/internals/array-from.js");
+ var checkCorrectnessOfIteration = __webpack_require__("./node_modules/core-js/internals/check-correctness-of-iteration.js");
+ var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function(iterable) {
+ Array.from(iterable);
+ });
+ $({ target: "Array", stat: true, forced: INCORRECT_ITERATION }, {
+ from
+ });
+ },
+ "./node_modules/core-js/modules/es.string.iterator.js": function(module3, exports2, __webpack_require__) {
+ "use strict";
+ var codePointAt = __webpack_require__("./node_modules/core-js/internals/string-at.js");
+ var InternalStateModule = __webpack_require__("./node_modules/core-js/internals/internal-state.js");
+ var defineIterator = __webpack_require__("./node_modules/core-js/internals/define-iterator.js");
+ var STRING_ITERATOR = "String Iterator";
+ var setInternalState = InternalStateModule.set;
+ var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
+ defineIterator(String, "String", function(iterated) {
+ setInternalState(this, {
+ type: STRING_ITERATOR,
+ string: String(iterated),
+ index: 0
+ });
+ }, function next() {
+ var state = getInternalState(this);
+ var string = state.string;
+ var index = state.index;
+ var point;
+ if (index >= string.length)
+ return { value: void 0, done: true };
+ point = codePointAt(string, index, true);
+ state.index += point.length;
+ return { value: point, done: false };
+ });
+ },
+ "./node_modules/webpack/buildin/global.js": function(module3, exports2) {
+ var g;
+ g = function() {
+ return this;
+ }();
+ try {
+ g = g || Function("return this")() || (1, eval)("this");
+ } catch (e) {
+ if (typeof window === "object")
+ g = window;
+ }
+ module3.exports = g;
+ },
+ "./src/default-attrs.json": function(module3) {
+ module3.exports = { "xmlns": "http://www.w3.org/2000/svg", "width": 24, "height": 24, "viewBox": "0 0 24 24", "fill": "none", "stroke": "currentColor", "stroke-width": 2, "stroke-linecap": "round", "stroke-linejoin": "round" };
+ },
+ "./src/icon.js": function(module3, exports2, __webpack_require__) {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {
+ value: true
+ });
+ var _extends = Object.assign || function(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i];
+ for (var key2 in source) {
+ if (Object.prototype.hasOwnProperty.call(source, key2)) {
+ target[key2] = source[key2];
+ }
+ }
+ }
+ return target;
+ };
+ var _createClass = function() {
+ function defineProperties(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor = props[i];
+ descriptor.enumerable = descriptor.enumerable || false;
+ descriptor.configurable = true;
+ if ("value" in descriptor)
+ descriptor.writable = true;
+ Object.defineProperty(target, descriptor.key, descriptor);
+ }
+ }
+ return function(Constructor, protoProps, staticProps) {
+ if (protoProps)
+ defineProperties(Constructor.prototype, protoProps);
+ if (staticProps)
+ defineProperties(Constructor, staticProps);
+ return Constructor;
+ };
+ }();
+ var _dedupe = __webpack_require__("./node_modules/classnames/dedupe.js");
+ var _dedupe2 = _interopRequireDefault(_dedupe);
+ var _defaultAttrs = __webpack_require__("./src/default-attrs.json");
+ var _defaultAttrs2 = _interopRequireDefault(_defaultAttrs);
+ function _interopRequireDefault(obj) {
+ return obj && obj.__esModule ? obj : { default: obj };
+ }
+ function _classCallCheck(instance5, Constructor) {
+ if (!(instance5 instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+ }
+ var Icon = function() {
+ function Icon2(name, contents) {
+ var tags = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
+ _classCallCheck(this, Icon2);
+ this.name = name;
+ this.contents = contents;
+ this.tags = tags;
+ this.attrs = _extends({}, _defaultAttrs2.default, { class: "feather feather-" + name });
+ }
+ _createClass(Icon2, [{
+ key: "toSvg",
+ value: function toSvg() {
+ var attrs = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+ var combinedAttrs = _extends({}, this.attrs, attrs, { class: (0, _dedupe2.default)(this.attrs.class, attrs.class) });
+ return "";
+ }
+ }, {
+ key: "toString",
+ value: function toString() {
+ return this.contents;
+ }
+ }]);
+ return Icon2;
+ }();
+ function attrsToString(attrs) {
+ return Object.keys(attrs).map(function(key2) {
+ return key2 + '="' + attrs[key2] + '"';
+ }).join(" ");
+ }
+ exports2.default = Icon;
+ },
+ "./src/icons.js": function(module3, exports2, __webpack_require__) {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {
+ value: true
+ });
+ var _icon = __webpack_require__("./src/icon.js");
+ var _icon2 = _interopRequireDefault(_icon);
+ var _icons = __webpack_require__("./dist/icons.json");
+ var _icons2 = _interopRequireDefault(_icons);
+ var _tags = __webpack_require__("./src/tags.json");
+ var _tags2 = _interopRequireDefault(_tags);
+ function _interopRequireDefault(obj) {
+ return obj && obj.__esModule ? obj : { default: obj };
+ }
+ exports2.default = Object.keys(_icons2.default).map(function(key2) {
+ return new _icon2.default(key2, _icons2.default[key2], _tags2.default[key2]);
+ }).reduce(function(object, icon) {
+ object[icon.name] = icon;
+ return object;
+ }, {});
+ },
+ "./src/index.js": function(module3, exports2, __webpack_require__) {
+ "use strict";
+ var _icons = __webpack_require__("./src/icons.js");
+ var _icons2 = _interopRequireDefault(_icons);
+ var _toSvg = __webpack_require__("./src/to-svg.js");
+ var _toSvg2 = _interopRequireDefault(_toSvg);
+ var _replace = __webpack_require__("./src/replace.js");
+ var _replace2 = _interopRequireDefault(_replace);
+ function _interopRequireDefault(obj) {
+ return obj && obj.__esModule ? obj : { default: obj };
+ }
+ module3.exports = { icons: _icons2.default, toSvg: _toSvg2.default, replace: _replace2.default };
+ },
+ "./src/replace.js": function(module3, exports2, __webpack_require__) {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {
+ value: true
+ });
+ var _extends = Object.assign || function(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i];
+ for (var key2 in source) {
+ if (Object.prototype.hasOwnProperty.call(source, key2)) {
+ target[key2] = source[key2];
+ }
+ }
+ }
+ return target;
+ };
+ var _dedupe = __webpack_require__("./node_modules/classnames/dedupe.js");
+ var _dedupe2 = _interopRequireDefault(_dedupe);
+ var _icons = __webpack_require__("./src/icons.js");
+ var _icons2 = _interopRequireDefault(_icons);
+ function _interopRequireDefault(obj) {
+ return obj && obj.__esModule ? obj : { default: obj };
+ }
+ function replace() {
+ var attrs = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+ if (typeof document === "undefined") {
+ throw new Error("`feather.replace()` only works in a browser environment.");
+ }
+ var elementsToReplace = document.querySelectorAll("[data-feather]");
+ Array.from(elementsToReplace).forEach(function(element2) {
+ return replaceElement(element2, attrs);
+ });
+ }
+ function replaceElement(element2) {
+ var attrs = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+ var elementAttrs = getAttrs(element2);
+ var name = elementAttrs["data-feather"];
+ delete elementAttrs["data-feather"];
+ var svgString = _icons2.default[name].toSvg(_extends({}, attrs, elementAttrs, { class: (0, _dedupe2.default)(attrs.class, elementAttrs.class) }));
+ var svgDocument = new DOMParser().parseFromString(svgString, "image/svg+xml");
+ var svgElement = svgDocument.querySelector("svg");
+ element2.parentNode.replaceChild(svgElement, element2);
+ }
+ function getAttrs(element2) {
+ return Array.from(element2.attributes).reduce(function(attrs, attr2) {
+ attrs[attr2.name] = attr2.value;
+ return attrs;
+ }, {});
+ }
+ exports2.default = replace;
+ },
+ "./src/tags.json": function(module3) {
+ module3.exports = { "activity": ["pulse", "health", "action", "motion"], "airplay": ["stream", "cast", "mirroring"], "alert-circle": ["warning", "alert", "danger"], "alert-octagon": ["warning", "alert", "danger"], "alert-triangle": ["warning", "alert", "danger"], "align-center": ["text alignment", "center"], "align-justify": ["text alignment", "justified"], "align-left": ["text alignment", "left"], "align-right": ["text alignment", "right"], "anchor": [], "archive": ["index", "box"], "at-sign": ["mention", "at", "email", "message"], "award": ["achievement", "badge"], "aperture": ["camera", "photo"], "bar-chart": ["statistics", "diagram", "graph"], "bar-chart-2": ["statistics", "diagram", "graph"], "battery": ["power", "electricity"], "battery-charging": ["power", "electricity"], "bell": ["alarm", "notification", "sound"], "bell-off": ["alarm", "notification", "silent"], "bluetooth": ["wireless"], "book-open": ["read", "library"], "book": ["read", "dictionary", "booklet", "magazine", "library"], "bookmark": ["read", "clip", "marker", "tag"], "box": ["cube"], "briefcase": ["work", "bag", "baggage", "folder"], "calendar": ["date"], "camera": ["photo"], "cast": ["chromecast", "airplay"], "chevron-down": ["expand"], "chevron-up": ["collapse"], "circle": ["off", "zero", "record"], "clipboard": ["copy"], "clock": ["time", "watch", "alarm"], "cloud-drizzle": ["weather", "shower"], "cloud-lightning": ["weather", "bolt"], "cloud-rain": ["weather"], "cloud-snow": ["weather", "blizzard"], "cloud": ["weather"], "codepen": ["logo"], "codesandbox": ["logo"], "code": ["source", "programming"], "coffee": ["drink", "cup", "mug", "tea", "cafe", "hot", "beverage"], "columns": ["layout"], "command": ["keyboard", "cmd", "terminal", "prompt"], "compass": ["navigation", "safari", "travel", "direction"], "copy": ["clone", "duplicate"], "corner-down-left": ["arrow", "return"], "corner-down-right": ["arrow"], "corner-left-down": ["arrow"], "corner-left-up": ["arrow"], "corner-right-down": ["arrow"], "corner-right-up": ["arrow"], "corner-up-left": ["arrow"], "corner-up-right": ["arrow"], "cpu": ["processor", "technology"], "credit-card": ["purchase", "payment", "cc"], "crop": ["photo", "image"], "crosshair": ["aim", "target"], "database": ["storage", "memory"], "delete": ["remove"], "disc": ["album", "cd", "dvd", "music"], "dollar-sign": ["currency", "money", "payment"], "droplet": ["water"], "edit": ["pencil", "change"], "edit-2": ["pencil", "change"], "edit-3": ["pencil", "change"], "eye": ["view", "watch"], "eye-off": ["view", "watch", "hide", "hidden"], "external-link": ["outbound"], "facebook": ["logo", "social"], "fast-forward": ["music"], "figma": ["logo", "design", "tool"], "file-minus": ["delete", "remove", "erase"], "file-plus": ["add", "create", "new"], "file-text": ["data", "txt", "pdf"], "film": ["movie", "video"], "filter": ["funnel", "hopper"], "flag": ["report"], "folder-minus": ["directory"], "folder-plus": ["directory"], "folder": ["directory"], "framer": ["logo", "design", "tool"], "frown": ["emoji", "face", "bad", "sad", "emotion"], "gift": ["present", "box", "birthday", "party"], "git-branch": ["code", "version control"], "git-commit": ["code", "version control"], "git-merge": ["code", "version control"], "git-pull-request": ["code", "version control"], "github": ["logo", "version control"], "gitlab": ["logo", "version control"], "globe": ["world", "browser", "language", "translate"], "hard-drive": ["computer", "server", "memory", "data"], "hash": ["hashtag", "number", "pound"], "headphones": ["music", "audio", "sound"], "heart": ["like", "love", "emotion"], "help-circle": ["question mark"], "hexagon": ["shape", "node.js", "logo"], "home": ["house", "living"], "image": ["picture"], "inbox": ["email"], "instagram": ["logo", "camera"], "key": ["password", "login", "authentication", "secure"], "layers": ["stack"], "layout": ["window", "webpage"], "life-bouy": ["help", "life ring", "support"], "link": ["chain", "url"], "link-2": ["chain", "url"], "linkedin": ["logo", "social media"], "list": ["options"], "lock": ["security", "password", "secure"], "log-in": ["sign in", "arrow", "enter"], "log-out": ["sign out", "arrow", "exit"], "mail": ["email", "message"], "map-pin": ["location", "navigation", "travel", "marker"], "map": ["location", "navigation", "travel"], "maximize": ["fullscreen"], "maximize-2": ["fullscreen", "arrows", "expand"], "meh": ["emoji", "face", "neutral", "emotion"], "menu": ["bars", "navigation", "hamburger"], "message-circle": ["comment", "chat"], "message-square": ["comment", "chat"], "mic-off": ["record", "sound", "mute"], "mic": ["record", "sound", "listen"], "minimize": ["exit fullscreen", "close"], "minimize-2": ["exit fullscreen", "arrows", "close"], "minus": ["subtract"], "monitor": ["tv", "screen", "display"], "moon": ["dark", "night"], "more-horizontal": ["ellipsis"], "more-vertical": ["ellipsis"], "mouse-pointer": ["arrow", "cursor"], "move": ["arrows"], "music": ["note"], "navigation": ["location", "travel"], "navigation-2": ["location", "travel"], "octagon": ["stop"], "package": ["box", "container"], "paperclip": ["attachment"], "pause": ["music", "stop"], "pause-circle": ["music", "audio", "stop"], "pen-tool": ["vector", "drawing"], "percent": ["discount"], "phone-call": ["ring"], "phone-forwarded": ["call"], "phone-incoming": ["call"], "phone-missed": ["call"], "phone-off": ["call", "mute"], "phone-outgoing": ["call"], "phone": ["call"], "play": ["music", "start"], "pie-chart": ["statistics", "diagram"], "play-circle": ["music", "start"], "plus": ["add", "new"], "plus-circle": ["add", "new"], "plus-square": ["add", "new"], "pocket": ["logo", "save"], "power": ["on", "off"], "printer": ["fax", "office", "device"], "radio": ["signal"], "refresh-cw": ["synchronise", "arrows"], "refresh-ccw": ["arrows"], "repeat": ["loop", "arrows"], "rewind": ["music"], "rotate-ccw": ["arrow"], "rotate-cw": ["arrow"], "rss": ["feed", "subscribe"], "save": ["floppy disk"], "scissors": ["cut"], "search": ["find", "magnifier", "magnifying glass"], "send": ["message", "mail", "email", "paper airplane", "paper aeroplane"], "settings": ["cog", "edit", "gear", "preferences"], "share-2": ["network", "connections"], "shield": ["security", "secure"], "shield-off": ["security", "insecure"], "shopping-bag": ["ecommerce", "cart", "purchase", "store"], "shopping-cart": ["ecommerce", "cart", "purchase", "store"], "shuffle": ["music"], "skip-back": ["music"], "skip-forward": ["music"], "slack": ["logo"], "slash": ["ban", "no"], "sliders": ["settings", "controls"], "smartphone": ["cellphone", "device"], "smile": ["emoji", "face", "happy", "good", "emotion"], "speaker": ["audio", "music"], "star": ["bookmark", "favorite", "like"], "stop-circle": ["media", "music"], "sun": ["brightness", "weather", "light"], "sunrise": ["weather", "time", "morning", "day"], "sunset": ["weather", "time", "evening", "night"], "tablet": ["device"], "tag": ["label"], "target": ["logo", "bullseye"], "terminal": ["code", "command line", "prompt"], "thermometer": ["temperature", "celsius", "fahrenheit", "weather"], "thumbs-down": ["dislike", "bad", "emotion"], "thumbs-up": ["like", "good", "emotion"], "toggle-left": ["on", "off", "switch"], "toggle-right": ["on", "off", "switch"], "tool": ["settings", "spanner"], "trash": ["garbage", "delete", "remove", "bin"], "trash-2": ["garbage", "delete", "remove", "bin"], "triangle": ["delta"], "truck": ["delivery", "van", "shipping", "transport", "lorry"], "tv": ["television", "stream"], "twitch": ["logo"], "twitter": ["logo", "social"], "type": ["text"], "umbrella": ["rain", "weather"], "unlock": ["security"], "user-check": ["followed", "subscribed"], "user-minus": ["delete", "remove", "unfollow", "unsubscribe"], "user-plus": ["new", "add", "create", "follow", "subscribe"], "user-x": ["delete", "remove", "unfollow", "unsubscribe", "unavailable"], "user": ["person", "account"], "users": ["group"], "video-off": ["camera", "movie", "film"], "video": ["camera", "movie", "film"], "voicemail": ["phone"], "volume": ["music", "sound", "mute"], "volume-1": ["music", "sound"], "volume-2": ["music", "sound"], "volume-x": ["music", "sound", "mute"], "watch": ["clock", "time"], "wifi-off": ["disabled"], "wifi": ["connection", "signal", "wireless"], "wind": ["weather", "air"], "x-circle": ["cancel", "close", "delete", "remove", "times", "clear"], "x-octagon": ["delete", "stop", "alert", "warning", "times", "clear"], "x-square": ["cancel", "close", "delete", "remove", "times", "clear"], "x": ["cancel", "close", "delete", "remove", "times", "clear"], "youtube": ["logo", "video", "play"], "zap-off": ["flash", "camera", "lightning"], "zap": ["flash", "camera", "lightning"], "zoom-in": ["magnifying glass"], "zoom-out": ["magnifying glass"] };
+ },
+ "./src/to-svg.js": function(module3, exports2, __webpack_require__) {
+ "use strict";
+ Object.defineProperty(exports2, "__esModule", {
+ value: true
+ });
+ var _icons = __webpack_require__("./src/icons.js");
+ var _icons2 = _interopRequireDefault(_icons);
+ function _interopRequireDefault(obj) {
+ return obj && obj.__esModule ? obj : { default: obj };
+ }
+ function toSvg(name) {
+ var attrs = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+ console.warn("feather.toSvg() is deprecated. Please use feather.icons[name].toSvg() instead.");
+ if (!name) {
+ throw new Error("The required `key` (icon name) parameter is missing.");
+ }
+ if (!_icons2.default[name]) {
+ throw new Error("No icon matching '" + name + "'. See the complete list of icons at https://feathericons.com");
+ }
+ return _icons2.default[name].toSvg(attrs);
+ }
+ exports2.default = toSvg;
+ },
+ 0: function(module3, exports2, __webpack_require__) {
+ __webpack_require__("./node_modules/core-js/es/array/from.js");
+ module3.exports = __webpack_require__("./src/index.js");
+ }
+ });
+ });
+ }
+});
+
+// src/main.ts
+__export(exports, {
+ default: () => ObsidianGit
+});
+var import_obsidian15 = __toModule(require("obsidian"));
+var path2 = __toModule(require("path"));
+
+// src/promiseQueue.ts
+var PromiseQueue = class {
+ constructor() {
+ this.tasks = [];
+ }
+ addTask(task) {
+ this.tasks.push(task);
+ if (this.tasks.length === 1) {
+ this.handleTask();
+ }
+ }
+ handleTask() {
+ return __async(this, null, function* () {
+ if (this.tasks.length > 0) {
+ this.tasks[0]().finally(() => {
+ this.tasks.shift();
+ this.handleTask();
+ });
+ }
+ });
+ }
+};
+
+// src/settings.ts
+var import_obsidian = __toModule(require("obsidian"));
+var ObsidianGitSettingsTab = class extends import_obsidian.PluginSettingTab {
+ display() {
+ let { containerEl } = this;
+ const plugin = this.plugin;
+ containerEl.empty();
+ containerEl.createEl("h2", { text: "Git Backup settings" });
+ containerEl.createEl("br");
+ containerEl.createEl("h3", { text: "Automatic" });
+ const commitOrBackup = plugin.settings.differentIntervalCommitAndPush ? "commit" : "backup";
+ new import_obsidian.Setting(containerEl).setName("Split automatic commit and push").setDesc("Enable to use separate timer for commit and push").addToggle((toggle) => toggle.setValue(plugin.settings.differentIntervalCommitAndPush).onChange((value) => {
+ plugin.settings.differentIntervalCommitAndPush = value;
+ plugin.saveSettings();
+ plugin.clearAutoBackup();
+ plugin.clearAutoPush();
+ if (plugin.settings.autoSaveInterval > 0) {
+ plugin.startAutoBackup(plugin.settings.autoSaveInterval);
+ }
+ if (value && plugin.settings.autoPushInterval > 0) {
+ plugin.startAutoPush(plugin.settings.autoPushInterval);
+ }
+ this.display();
+ }));
+ new import_obsidian.Setting(containerEl).setName(`Vault ${commitOrBackup} interval (minutes)`).setDesc(`${plugin.settings.differentIntervalCommitAndPush ? "Commit" : "Commit and push"} changes every X minutes. Set to 0 (default) to disable. (See below setting for further configuration!)`).addText((text2) => text2.setValue(String(plugin.settings.autoSaveInterval)).onChange((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 import_obsidian.Notice(`Automatic ${commitOrBackup} enabled! Every ${plugin.settings.autoSaveInterval} minutes.`);
+ } else if (plugin.settings.autoSaveInterval <= 0) {
+ plugin.clearAutoBackup() && new import_obsidian.Notice(`Automatic ${commitOrBackup} disabled!`);
+ }
+ } else {
+ new import_obsidian.Notice("Please specify a valid number.");
+ }
+ }));
+ new import_obsidian.Setting(containerEl).setName(`If turned on, do auto ${commitOrBackup} every X minutes after last change. Prevents auto ${commitOrBackup} while editing a file. If turned off, do auto ${commitOrBackup} every X minutes. It's independent from last change.`).addToggle((toggle) => toggle.setValue(plugin.settings.autoBackupAfterFileChange).onChange((value) => {
+ plugin.settings.autoBackupAfterFileChange = value;
+ plugin.saveSettings();
+ plugin.clearAutoBackup();
+ if (plugin.settings.autoSaveInterval > 0) {
+ plugin.startAutoBackup(plugin.settings.autoSaveInterval);
+ }
+ }));
+ if (plugin.settings.differentIntervalCommitAndPush) {
+ new import_obsidian.Setting(containerEl).setName(`Vault push interval (minutes)`).setDesc("Push changes every X minutes. Set to 0 (default) to disable.").addText((text2) => text2.setValue(String(plugin.settings.autoPushInterval)).onChange((value) => {
+ if (!isNaN(Number(value))) {
+ plugin.settings.autoPushInterval = Number(value);
+ plugin.saveSettings();
+ if (plugin.settings.autoPushInterval > 0) {
+ plugin.clearAutoPush();
+ plugin.startAutoPush(plugin.settings.autoPushInterval);
+ new import_obsidian.Notice(`Automatic push enabled! Every ${plugin.settings.autoPushInterval} minutes.`);
+ } else if (plugin.settings.autoPushInterval <= 0) {
+ plugin.clearAutoPush() && new import_obsidian.Notice("Automatic push disabled!");
+ }
+ } else {
+ new import_obsidian.Notice("Please specify a valid number.");
+ }
+ }));
+ }
+ new import_obsidian.Setting(containerEl).setName("Auto pull interval (minutes)").setDesc("Pull changes every X minutes. Set to 0 (default) to disable.").addText((text2) => text2.setValue(String(plugin.settings.autoPullInterval)).onChange((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 import_obsidian.Notice(`Automatic pull enabled! Every ${plugin.settings.autoPullInterval} minutes.`);
+ } else if (plugin.settings.autoPullInterval <= 0) {
+ plugin.clearAutoPull() && new import_obsidian.Notice("Automatic pull disabled!");
+ }
+ } else {
+ new import_obsidian.Notice("Please specify a valid number.");
+ }
+ }));
+ new import_obsidian.Setting(containerEl).setName("Commit message on manual backup/commit").setDesc("Available placeholders: {{date}} (see below), {{hostname}} (see below) and {{numFiles}} (number of changed files in the commit)").addText((text2) => text2.setPlaceholder("vault backup: {{date}}").setValue(plugin.settings.commitMessage ? plugin.settings.commitMessage : "").onChange((value) => {
+ plugin.settings.commitMessage = value;
+ plugin.saveSettings();
+ }));
+ new import_obsidian.Setting(containerEl).setName("Specify custom commit message on auto backup").setDesc("You will get a pop up to specify your message").addToggle((toggle) => toggle.setValue(plugin.settings.customMessageOnAutoBackup).onChange((value) => {
+ plugin.settings.customMessageOnAutoBackup = value;
+ plugin.saveSettings();
+ }));
+ new import_obsidian.Setting(containerEl).setName("Commit message on auto backup/commit").setDesc("Available placeholders: {{date}} (see below), {{hostname}} (see below) and {{numFiles}} (number of changed files in the commit)").addText((text2) => text2.setPlaceholder("vault backup: {{date}}").setValue(plugin.settings.autoCommitMessage).onChange((value) => {
+ plugin.settings.autoCommitMessage = value;
+ plugin.saveSettings();
+ }));
+ containerEl.createEl("br");
+ containerEl.createEl("h3", { text: "Commit message" });
+ new import_obsidian.Setting(containerEl).setName("{{date}} placeholder format").setDesc('Specify custom date format. E.g. "YYYY-MM-DD HH:mm:ss"').addText((text2) => text2.setPlaceholder(plugin.settings.commitDateFormat).setValue(plugin.settings.commitDateFormat).onChange((value) => __async(this, null, function* () {
+ plugin.settings.commitDateFormat = value;
+ yield plugin.saveSettings();
+ })));
+ new import_obsidian.Setting(containerEl).setName("{{hostname}} placeholder replacement").setDesc("Specify custom hostname for every device.").addText((text2) => text2.setValue(localStorage.getItem(plugin.manifest.id + ":hostname")).onChange((value) => __async(this, null, function* () {
+ localStorage.setItem(plugin.manifest.id + ":hostname", value);
+ })));
+ new import_obsidian.Setting(containerEl).setName("Preview commit message").addButton((button) => button.setButtonText("Preview").onClick(() => __async(this, null, function* () {
+ let commitMessagePreview = yield plugin.gitManager.formatCommitMessage(plugin.settings.commitMessage);
+ new import_obsidian.Notice(`${commitMessagePreview}`);
+ })));
+ new import_obsidian.Setting(containerEl).setName("List filenames affected by commit in the commit body").addToggle((toggle) => toggle.setValue(plugin.settings.listChangedFilesInMessageBody).onChange((value) => {
+ plugin.settings.listChangedFilesInMessageBody = value;
+ plugin.saveSettings();
+ }));
+ containerEl.createEl("br");
+ containerEl.createEl("h3", { text: "Backup" });
+ new import_obsidian.Setting(containerEl).setName("Sync Method").setDesc("Selects the method used for handling new changes found in your remote git repository.").addDropdown((dropdown) => {
+ const options = {
+ "merge": "Merge",
+ "rebase": "Rebase",
+ "reset": "Other sync service (Only updates the HEAD without touching the working directory)"
+ };
+ dropdown.addOptions(options);
+ dropdown.setValue(plugin.settings.syncMethod);
+ dropdown.onChange((option) => __async(this, null, function* () {
+ plugin.settings.syncMethod = option;
+ plugin.saveSettings();
+ }));
+ });
+ new import_obsidian.Setting(containerEl).setName("Pull updates on startup").setDesc("Automatically pull updates when Obsidian starts").addToggle((toggle) => toggle.setValue(plugin.settings.autoPullOnBoot).onChange((value) => {
+ plugin.settings.autoPullOnBoot = value;
+ plugin.saveSettings();
+ }));
+ new import_obsidian.Setting(containerEl).setName("Push on backup").setDesc("Disable to only commit changes").addToggle((toggle) => toggle.setValue(!plugin.settings.disablePush).onChange((value) => {
+ plugin.settings.disablePush = !value;
+ plugin.saveSettings();
+ }));
+ new import_obsidian.Setting(containerEl).setName("Pull changes before push").setDesc("Commit -> pull -> push (Only if pushing is enabled)").addToggle((toggle) => toggle.setValue(plugin.settings.pullBeforePush).onChange((value) => {
+ plugin.settings.pullBeforePush = value;
+ plugin.saveSettings();
+ }));
+ containerEl.createEl("br");
+ containerEl.createEl("h3", { text: "Miscellaneous" });
+ new import_obsidian.Setting(containerEl).setName("Current branch").setDesc("Switch to a different branch").addDropdown((dropdown) => __async(this, null, function* () {
+ const branchInfo = yield plugin.gitManager.branchInfo();
+ for (const branch of branchInfo.branches) {
+ dropdown.addOption(branch, branch);
+ }
+ dropdown.setValue(branchInfo.current);
+ dropdown.onChange((option) => __async(this, null, function* () {
+ yield plugin.gitManager.checkout(option);
+ new import_obsidian.Notice(`Checked out to ${option}`);
+ }));
+ }));
+ new import_obsidian.Setting(containerEl).setName("Automatically refresh Source Control View on file changes").setDesc("On slower machines this may cause lags. If so, just disable this option").addToggle((toggle) => toggle.setValue(plugin.settings.refreshSourceControl).onChange((value) => {
+ plugin.settings.refreshSourceControl = value;
+ plugin.saveSettings();
+ }));
+ new import_obsidian.Setting(containerEl).setName("Disable notifications").setDesc("Disable notifications for git operations to minimize distraction (refer to status bar for updates)").addToggle((toggle) => toggle.setValue(plugin.settings.disablePopups).onChange((value) => {
+ plugin.settings.disablePopups = value;
+ plugin.saveSettings();
+ }));
+ new import_obsidian.Setting(containerEl).setName("Show status bar").setDesc("Obsidian must be restarted for the changes to take affect").addToggle((toggle) => toggle.setValue(plugin.settings.showStatusBar).onChange((value) => {
+ plugin.settings.showStatusBar = value;
+ plugin.saveSettings();
+ }));
+ new import_obsidian.Setting(containerEl).setName("Show changes files count in status bar").addToggle((toggle) => toggle.setValue(plugin.settings.changedFilesInStatusBar).onChange((value) => {
+ plugin.settings.changedFilesInStatusBar = value;
+ plugin.saveSettings();
+ }));
+ containerEl.createEl("br");
+ containerEl.createEl("h3", { text: "Advanced" });
+ new import_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((toggle) => toggle.setValue(plugin.settings.updateSubmodules).onChange((value) => {
+ plugin.settings.updateSubmodules = value;
+ plugin.saveSettings();
+ }));
+ new import_obsidian.Setting(containerEl).setName("Custom Git binary path").addText((cb) => {
+ cb.setValue(plugin.settings.gitPath);
+ cb.setPlaceholder("git");
+ cb.onChange((value) => {
+ plugin.settings.gitPath = value;
+ plugin.saveSettings();
+ plugin.gitManager.updateGitPath(value || "git");
+ });
+ });
+ new import_obsidian.Setting(containerEl).setName("Custom base path (Git repository path)").setDesc(`
+ Sets the relative path to the vault from which the Git binary should be executed.
+ Mostly used to set the path to the Git repository, which is only required if the Git repository is below the vault root directory. Use "\\" instead of "/" on Windows.
+ `).addText((cb) => {
+ cb.setValue(plugin.settings.basePath);
+ cb.setPlaceholder("directory/directory-with-git-repo");
+ cb.onChange((value) => {
+ plugin.settings.basePath = value;
+ plugin.saveSettings();
+ plugin.gitManager.updateBasePath(value || "");
+ });
+ });
+ const info = containerEl.createDiv();
+ info.setAttr("align", "center");
+ info.setText("Debugging and logging:\nYou can always see the logs of this and every other plugin by opening the console with");
+ const keys = containerEl.createDiv();
+ keys.setAttr("align", "center");
+ keys.addClass("obsidian-git-shortcuts");
+ if (import_obsidian.Platform.isMacOS === true) {
+ keys.createEl("kbd", { text: "CMD (\u2318) + OPTION (\u2325) + I" });
+ } else {
+ keys.createEl("kbd", { text: "CTRL + SHIFT + I" });
+ }
+ }
+};
+
+// src/statusBar.ts
+var import_obsidian2 = __toModule(require("obsidian"));
+
+// src/types.ts
+var PluginState;
+(function(PluginState2) {
+ PluginState2[PluginState2["idle"] = 0] = "idle";
+ PluginState2[PluginState2["status"] = 1] = "status";
+ PluginState2[PluginState2["pull"] = 2] = "pull";
+ PluginState2[PluginState2["add"] = 3] = "add";
+ PluginState2[PluginState2["commit"] = 4] = "commit";
+ PluginState2[PluginState2["push"] = 5] = "push";
+ PluginState2[PluginState2["conflicted"] = 6] = "conflicted";
+})(PluginState || (PluginState = {}));
+
+// src/statusBar.ts
+var StatusBar = class {
+ constructor(statusBarEl, plugin) {
+ this.statusBarEl = statusBarEl;
+ this.plugin = plugin;
+ this.messages = [];
+ this.base = "obsidian-git-statusbar-";
+ this.statusBarEl.setAttribute("aria-label-position", "top");
+ }
+ displayMessage(message, timeout) {
+ this.messages.push({
+ message: `Git: ${message.slice(0, 100)}`,
+ timeout
+ });
+ this.display();
+ }
+ display() {
+ if (this.messages.length > 0 && !this.currentMessage) {
+ this.currentMessage = this.messages.shift();
+ this.statusBarEl.addClass(this.base + "message");
+ this.statusBarEl.ariaLabel = "";
+ this.statusBarEl.setText(this.currentMessage.message);
+ this.lastMessageTimestamp = Date.now();
+ } else if (this.currentMessage) {
+ const messageAge = Date.now() - this.lastMessageTimestamp;
+ if (messageAge >= this.currentMessage.timeout) {
+ this.currentMessage = null;
+ this.lastMessageTimestamp = null;
+ }
+ } else {
+ this.displayState();
+ }
+ }
+ displayState() {
+ if (this.statusBarEl.getText().length > 3 || !this.statusBarEl.hasChildNodes()) {
+ this.statusBarEl.empty();
+ this.iconEl = this.statusBarEl.createDiv();
+ this.textEl = this.statusBarEl.createDiv();
+ this.textEl.style.float = "right";
+ this.textEl.style.marginLeft = "5px";
+ this.iconEl.style.float = "left";
+ }
+ switch (this.plugin.state) {
+ case PluginState.idle:
+ this.displayFromNow(this.plugin.lastUpdate);
+ break;
+ case PluginState.status:
+ this.statusBarEl.ariaLabel = "Checking repository status...";
+ (0, import_obsidian2.setIcon)(this.iconEl, "refresh-cw");
+ this.statusBarEl.addClass(this.base + "status");
+ break;
+ case PluginState.add:
+ this.statusBarEl.ariaLabel = "Adding files...";
+ (0, import_obsidian2.setIcon)(this.iconEl, "refresh-w");
+ this.statusBarEl.addClass(this.base + "add");
+ break;
+ case PluginState.commit:
+ this.statusBarEl.ariaLabel = "Committing changes...";
+ (0, import_obsidian2.setIcon)(this.iconEl, "git-commit");
+ this.statusBarEl.addClass(this.base + "commit");
+ break;
+ case PluginState.push:
+ this.statusBarEl.ariaLabel = "Pushing changes...";
+ (0, import_obsidian2.setIcon)(this.iconEl, "upload");
+ this.statusBarEl.addClass(this.base + "push");
+ break;
+ case PluginState.pull:
+ this.statusBarEl.ariaLabel = "Pulling changes...";
+ (0, import_obsidian2.setIcon)(this.iconEl, "download");
+ this.statusBarEl.addClass(this.base + "pull");
+ break;
+ case PluginState.conflicted:
+ this.statusBarEl.ariaLabel = "You have conflict files...";
+ (0, import_obsidian2.setIcon)(this.iconEl, "alert-circle");
+ this.statusBarEl.addClass(this.base + "conflict");
+ break;
+ default:
+ this.statusBarEl.ariaLabel = "Failed on initialization!";
+ (0, import_obsidian2.setIcon)(this.iconEl, "alert-triangle");
+ this.statusBarEl.addClass(this.base + "failed-init");
+ break;
+ }
+ }
+ displayFromNow(timestamp) {
+ if (timestamp) {
+ const moment = window.moment;
+ const fromNow = moment(timestamp).fromNow();
+ this.statusBarEl.ariaLabel = `${this.plugin.offlineMode ? "Offline: " : ""}Last Git update: ${fromNow}`;
+ } else {
+ this.statusBarEl.ariaLabel = this.plugin.offlineMode ? "Git is offline" : "Git is ready";
+ }
+ if (this.plugin.offlineMode) {
+ (0, import_obsidian2.setIcon)(this.iconEl, "globe");
+ } else {
+ (0, import_obsidian2.setIcon)(this.iconEl, "check");
+ }
+ if (this.plugin.settings.changedFilesInStatusBar && this.plugin.cachedStatus) {
+ this.textEl.setText(this.plugin.cachedStatus.changed.length.toString());
+ }
+ this.statusBarEl.addClass(this.base + "idle");
+ }
+};
+
+// src/ui/modals/changedFilesModal.ts
+var import_obsidian3 = __toModule(require("obsidian"));
+var ChangedFilesModal = class extends import_obsidian3.FuzzySuggestModal {
+ constructor(plugin, changedFiles) {
+ super(plugin.app);
+ this.plugin = plugin;
+ this.changedFiles = changedFiles;
+ this.setPlaceholder("Not supported files will be opened by default app!");
+ }
+ getItems() {
+ return this.changedFiles;
+ }
+ getItemText(item) {
+ if (item.index == "?" && item.working_dir == "U") {
+ return `Untracked | ${item.vault_path}`;
+ }
+ let working_dir = "";
+ let index = "";
+ if (item.working_dir != " ")
+ working_dir = `Working dir: ${item.working_dir} `;
+ if (item.index != " ")
+ index = `Index: ${item.index}`;
+ return `${working_dir}${index} | ${item.vault_path}`;
+ }
+ onChooseItem(item, _) {
+ if (this.plugin.app.metadataCache.getFirstLinkpathDest(item.vault_path, "") == null) {
+ this.app.openWithDefaultApp(item.vault_path);
+ } else {
+ this.plugin.app.workspace.openLinkText(item.vault_path, "/");
+ }
+ }
+};
+
+// src/ui/modals/customMessageModal.ts
+var import_obsidian4 = __toModule(require("obsidian"));
+var CustomMessageModal = class extends import_obsidian4.SuggestModal {
+ constructor(plugin, fromAutoBackup) {
+ super(plugin.app);
+ this.fromAutoBackup = fromAutoBackup;
+ this.resolve = null;
+ this.plugin = plugin;
+ this.setPlaceholder("Type your message and select optional the version with the added date.");
+ }
+ open() {
+ super.open();
+ return new Promise((resolve) => {
+ this.resolve = resolve;
+ });
+ }
+ onClose() {
+ if (this.resolve)
+ this.resolve(void 0);
+ }
+ selectSuggestion(value, evt) {
+ if (this.resolve)
+ this.resolve(value);
+ super.selectSuggestion(value, evt);
+ }
+ getSuggestions(query) {
+ const date = window.moment().format(this.plugin.settings.commitDateFormat);
+ if (query == "")
+ query = "...";
+ return [query, `${date}: ${query}`, `${query}: ${date}`];
+ }
+ renderSuggestion(value, el) {
+ el.innerText = value;
+ }
+ onChooseSuggestion(item, _) {
+ }
+};
+
+// src/constants.ts
+var DEFAULT_SETTINGS = {
+ commitMessage: "vault backup: {{date}}",
+ autoCommitMessage: void 0,
+ commitDateFormat: "YYYY-MM-DD HH:mm:ss",
+ autoSaveInterval: 0,
+ autoPushInterval: 0,
+ autoPullInterval: 0,
+ autoPullOnBoot: false,
+ disablePush: false,
+ pullBeforePush: true,
+ disablePopups: false,
+ listChangedFilesInMessageBody: false,
+ showStatusBar: true,
+ updateSubmodules: false,
+ syncMethod: "merge",
+ gitPath: "",
+ customMessageOnAutoBackup: false,
+ autoBackupAfterFileChange: false,
+ treeStructure: false,
+ refreshSourceControl: true,
+ basePath: "",
+ differentIntervalCommitAndPush: false,
+ changedFilesInStatusBar: false
+};
+var GIT_VIEW_CONFIG = {
+ type: "git-view",
+ name: "Source Control",
+ icon: "git-pull-request"
+};
+var DIFF_VIEW_CONFIG = {
+ type: "diff-view",
+ name: "Diff View",
+ icon: "git-pull-request"
+};
+
+// src/openInGitHub.ts
+var import_electron = __toModule(require("electron"));
+var import_obsidian5 = __toModule(require("obsidian"));
+function openLineInGitHub(editor, file, manager) {
+ return __async(this, null, function* () {
+ const { isGitHub, branch, repo, user } = yield getData(manager);
+ if (isGitHub) {
+ const from = editor.getCursor("from").line + 1;
+ const to = editor.getCursor("to").line + 1;
+ if (from === to) {
+ yield import_electron.shell.openExternal(`https://github.com/${user}/${repo}/blob/${branch}/${file.path}?plain=1#L${from}`);
+ } else {
+ yield import_electron.shell.openExternal(`https://github.com/${user}/${repo}/blob/${branch}/${file.path}?plain=1#L${from}-L${to}`);
+ }
+ } else {
+ new import_obsidian5.Notice("It seems like you are not using GitHub");
+ }
+ });
+}
+function openHistoryInGitHub(file, manager) {
+ return __async(this, null, function* () {
+ const { isGitHub, branch, repo, user } = yield getData(manager);
+ if (isGitHub) {
+ yield import_electron.shell.openExternal(`https://github.com/${user}/${repo}/commits/${branch}/${file.path}`);
+ } else {
+ new import_obsidian5.Notice("It seems like you are not using GitHub");
+ }
+ });
+}
+function getData(manager) {
+ return __async(this, null, function* () {
+ const branchInfo = yield manager.branchInfo();
+ const remoteBranch = branchInfo.tracking;
+ const branch = branchInfo.current;
+ const remote = remoteBranch.substring(0, remoteBranch.indexOf("/"));
+ const remoteUrl = yield manager.getConfig(`remote.${remote}.url`);
+ const [isGitHub, httpsUser, httpsRepo, sshUser, sshRepo] = remoteUrl.match(/(?:^https:\/\/github\.com\/(.*)\/(.*)\.git$)|(?:^git@github\.com:(.*)\/(.*)\.git$)/);
+ return {
+ isGitHub: !!isGitHub,
+ repo: httpsRepo || sshRepo,
+ user: httpsUser || sshUser,
+ branch
+ };
+ });
+}
+
+// src/simpleGit.ts
+var import_child_process2 = __toModule(require("child_process"));
+var import_obsidian6 = __toModule(require("obsidian"));
+var path = __toModule(require("path"));
+var import_path = __toModule(require("path"));
+
+// node_modules/simple-git/dist/esm/index.js
+var import_file_exists = __toModule(require_dist());
+var import_debug = __toModule(require_src());
+var import_child_process = __toModule(require("child_process"));
+var import_promise_deferred = __toModule(require_dist2());
+var import_promise_deferred2 = __toModule(require_dist2());
+var __defProp2 = Object.defineProperty;
+var __defProps2 = Object.defineProperties;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getOwnPropSymbols2 = Object.getOwnPropertySymbols;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __propIsEnum2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp2 = (obj, key2, value) => key2 in obj ? __defProp2(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;
+var __spreadValues2 = (a, b) => {
+ for (var prop in b || (b = {}))
+ if (__hasOwnProp2.call(b, prop))
+ __defNormalProp2(a, prop, b[prop]);
+ if (__getOwnPropSymbols2)
+ for (var prop of __getOwnPropSymbols2(b)) {
+ if (__propIsEnum2.call(b, prop))
+ __defNormalProp2(a, prop, b[prop]);
+ }
+ return a;
+};
+var __spreadProps2 = (a, b) => __defProps2(a, __getOwnPropDescs2(b));
+var __markAsModule2 = (target) => __defProp2(target, "__esModule", { value: true });
+var __esm = (fn, res) => function __init() {
+ return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
+};
+var __commonJS2 = (cb, mod) => function __require() {
+ return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export2 = (target, all) => {
+ for (var name in all)
+ __defProp2(target, name, { get: all[name], enumerable: true });
+};
+var __reExport2 = (target, module2, copyDefault, desc) => {
+ if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+ for (let key2 of __getOwnPropNames2(module2))
+ if (!__hasOwnProp2.call(target, key2) && (copyDefault || key2 !== "default"))
+ __defProp2(target, key2, { get: () => module2[key2], enumerable: !(desc = __getOwnPropDesc2(module2, key2)) || desc.enumerable });
+ }
+ return target;
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+ return (module2, temp) => {
+ return cache && cache.get(module2) || (temp = __reExport2(__markAsModule2({}), module2, 1), cache && cache.set(module2, temp), temp);
+ };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var __async2 = (__this, __arguments, generator) => {
+ return new Promise((resolve, reject) => {
+ var fulfilled = (value) => {
+ try {
+ step(generator.next(value));
+ } catch (e) {
+ reject(e);
+ }
+ };
+ var rejected = (value) => {
+ try {
+ step(generator.throw(value));
+ } catch (e) {
+ reject(e);
+ }
+ };
+ var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+ step((generator = generator.apply(__this, __arguments)).next());
+ });
+};
+var GitError;
+var init_git_error = __esm({
+ "src/lib/errors/git-error.ts"() {
+ GitError = class extends Error {
+ constructor(task, message) {
+ super(message);
+ this.task = task;
+ Object.setPrototypeOf(this, new.target.prototype);
+ }
+ };
+ }
+});
+var GitResponseError;
+var init_git_response_error = __esm({
+ "src/lib/errors/git-response-error.ts"() {
+ init_git_error();
+ GitResponseError = class extends GitError {
+ constructor(git, message) {
+ super(void 0, message || String(git));
+ this.git = git;
+ }
+ };
+ }
+});
+var TaskConfigurationError;
+var init_task_configuration_error = __esm({
+ "src/lib/errors/task-configuration-error.ts"() {
+ init_git_error();
+ TaskConfigurationError = class extends GitError {
+ constructor(message) {
+ super(void 0, message);
+ }
+ };
+ }
+});
+function asFunction(source) {
+ return typeof source === "function" ? source : NOOP;
+}
+function isUserFunction(source) {
+ return typeof source === "function" && source !== NOOP;
+}
+function splitOn(input, char) {
+ const index = input.indexOf(char);
+ if (index <= 0) {
+ return [input, ""];
+ }
+ return [
+ input.substr(0, index),
+ input.substr(index + 1)
+ ];
+}
+function first(input, offset = 0) {
+ return isArrayLike(input) && input.length > offset ? input[offset] : void 0;
+}
+function last(input, offset = 0) {
+ if (isArrayLike(input) && input.length > offset) {
+ return input[input.length - 1 - offset];
+ }
+}
+function isArrayLike(input) {
+ return !!(input && typeof input.length === "number");
+}
+function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
+ return input.split(separator).reduce((output, line) => {
+ const lineContent = trimmed2 ? line.trim() : line;
+ if (lineContent) {
+ output.push(lineContent);
+ }
+ return output;
+ }, []);
+}
+function forEachLineWithContent(input, callback) {
+ return toLinesWithContent(input, true).map((line) => callback(line));
+}
+function folderExists(path3) {
+ return (0, import_file_exists.exists)(path3, import_file_exists.FOLDER);
+}
+function append(target, item) {
+ if (Array.isArray(target)) {
+ if (!target.includes(item)) {
+ target.push(item);
+ }
+ } else {
+ target.add(item);
+ }
+ return item;
+}
+function including(target, item) {
+ if (Array.isArray(target) && !target.includes(item)) {
+ target.push(item);
+ }
+ return target;
+}
+function remove(target, item) {
+ if (Array.isArray(target)) {
+ const index = target.indexOf(item);
+ if (index >= 0) {
+ target.splice(index, 1);
+ }
+ } else {
+ target.delete(item);
+ }
+ return item;
+}
+function asArray(source) {
+ return Array.isArray(source) ? source : [source];
+}
+function asStringArray(source) {
+ return asArray(source).map(String);
+}
+function asNumber(source, onNaN = 0) {
+ if (source == null) {
+ return onNaN;
+ }
+ const num = parseInt(source, 10);
+ return isNaN(num) ? onNaN : num;
+}
+function prefixedArray(input, prefix) {
+ const output = [];
+ for (let i = 0, max = input.length; i < max; i++) {
+ output.push(prefix, input[i]);
+ }
+ return output;
+}
+function bufferToString(input) {
+ return (Array.isArray(input) ? Buffer.concat(input) : input).toString("utf-8");
+}
+function pick(source, properties) {
+ return Object.assign({}, ...properties.map((property) => property in source ? { [property]: source[property] } : {}));
+}
+function delay(duration = 0) {
+ return new Promise((done) => setTimeout(done, duration));
+}
+var NULL;
+var NOOP;
+var objectToString;
+var init_util = __esm({
+ "src/lib/utils/util.ts"() {
+ NULL = "\0";
+ NOOP = () => {
+ };
+ objectToString = Object.prototype.toString.call.bind(Object.prototype.toString);
+ }
+});
+function filterType(input, filter, def) {
+ if (filter(input)) {
+ return input;
+ }
+ return arguments.length > 2 ? def : void 0;
+}
+function filterPrimitives(input, omit) {
+ return /number|string|boolean/.test(typeof input) && (!omit || !omit.includes(typeof input));
+}
+function filterPlainObject(input) {
+ return !!input && objectToString(input) === "[object Object]";
+}
+function filterFunction(input) {
+ return typeof input === "function";
+}
+var filterArray;
+var filterString;
+var filterStringArray;
+var filterStringOrStringArray;
+var filterHasLength;
+var init_argument_filters = __esm({
+ "src/lib/utils/argument-filters.ts"() {
+ init_util();
+ filterArray = (input) => {
+ return Array.isArray(input);
+ };
+ filterString = (input) => {
+ return typeof input === "string";
+ };
+ filterStringArray = (input) => {
+ return Array.isArray(input) && input.every(filterString);
+ };
+ filterStringOrStringArray = (input) => {
+ return filterString(input) || Array.isArray(input) && input.every(filterString);
+ };
+ filterHasLength = (input) => {
+ if (input == null || "number|boolean|function".includes(typeof input)) {
+ return false;
+ }
+ return Array.isArray(input) || typeof input === "string" || typeof input.length === "number";
+ };
+ }
+});
+var ExitCodes;
+var init_exit_codes = __esm({
+ "src/lib/utils/exit-codes.ts"() {
+ ExitCodes = /* @__PURE__ */ ((ExitCodes2) => {
+ ExitCodes2[ExitCodes2["SUCCESS"] = 0] = "SUCCESS";
+ ExitCodes2[ExitCodes2["ERROR"] = 1] = "ERROR";
+ ExitCodes2[ExitCodes2["UNCLEAN"] = 128] = "UNCLEAN";
+ return ExitCodes2;
+ })(ExitCodes || {});
+ }
+});
+var GitOutputStreams;
+var init_git_output_streams = __esm({
+ "src/lib/utils/git-output-streams.ts"() {
+ GitOutputStreams = class {
+ constructor(stdOut, stdErr) {
+ this.stdOut = stdOut;
+ this.stdErr = stdErr;
+ }
+ asStrings() {
+ return new GitOutputStreams(this.stdOut.toString("utf8"), this.stdErr.toString("utf8"));
+ }
+ };
+ }
+});
+var LineParser;
+var RemoteLineParser;
+var init_line_parser = __esm({
+ "src/lib/utils/line-parser.ts"() {
+ LineParser = class {
+ constructor(regExp, useMatches) {
+ this.matches = [];
+ this.parse = (line, target) => {
+ this.resetMatches();
+ if (!this._regExp.every((reg, index) => this.addMatch(reg, index, line(index)))) {
+ return false;
+ }
+ return this.useMatches(target, this.prepareMatches()) !== false;
+ };
+ this._regExp = Array.isArray(regExp) ? regExp : [regExp];
+ if (useMatches) {
+ this.useMatches = useMatches;
+ }
+ }
+ useMatches(target, match) {
+ throw new Error(`LineParser:useMatches not implemented`);
+ }
+ resetMatches() {
+ this.matches.length = 0;
+ }
+ prepareMatches() {
+ return this.matches;
+ }
+ addMatch(reg, index, line) {
+ const matched = line && reg.exec(line);
+ if (matched) {
+ this.pushMatch(index, matched);
+ }
+ return !!matched;
+ }
+ pushMatch(_index, matched) {
+ this.matches.push(...matched.slice(1));
+ }
+ };
+ RemoteLineParser = class extends LineParser {
+ addMatch(reg, index, line) {
+ return /^remote:\s/.test(String(line)) && super.addMatch(reg, index, line);
+ }
+ pushMatch(index, matched) {
+ if (index > 0 || matched.length > 1) {
+ super.pushMatch(index, matched);
+ }
+ }
+ };
+ }
+});
+function createInstanceConfig(...options) {
+ const baseDir = process.cwd();
+ const config = Object.assign(__spreadValues2({ baseDir }, defaultOptions), ...options.filter((o) => typeof o === "object" && o));
+ config.baseDir = config.baseDir || baseDir;
+ return config;
+}
+var defaultOptions;
+var init_simple_git_options = __esm({
+ "src/lib/utils/simple-git-options.ts"() {
+ defaultOptions = {
+ binary: "git",
+ maxConcurrentProcesses: 5,
+ config: []
+ };
+ }
+});
+function appendTaskOptions(options, commands = []) {
+ if (!filterPlainObject(options)) {
+ return commands;
+ }
+ return Object.keys(options).reduce((commands2, key2) => {
+ const value = options[key2];
+ if (filterPrimitives(value, ["boolean"])) {
+ commands2.push(key2 + "=" + value);
+ } else {
+ commands2.push(key2);
+ }
+ return commands2;
+ }, commands);
+}
+function getTrailingOptions(args, initialPrimitive = 0, objectOnly = false) {
+ const command = [];
+ for (let i = 0, max = initialPrimitive < 0 ? args.length : initialPrimitive; i < max; i++) {
+ if ("string|number".includes(typeof args[i])) {
+ command.push(String(args[i]));
+ }
+ }
+ appendTaskOptions(trailingOptionsArgument(args), command);
+ if (!objectOnly) {
+ command.push(...trailingArrayArgument(args));
+ }
+ return command;
+}
+function trailingArrayArgument(args) {
+ const hasTrailingCallback = typeof last(args) === "function";
+ return filterType(last(args, hasTrailingCallback ? 1 : 0), filterArray, []);
+}
+function trailingOptionsArgument(args) {
+ const hasTrailingCallback = filterFunction(last(args));
+ return filterType(last(args, hasTrailingCallback ? 1 : 0), filterPlainObject);
+}
+function trailingFunctionArgument(args, includeNoop = true) {
+ const callback = asFunction(last(args));
+ return includeNoop || isUserFunction(callback) ? callback : void 0;
+}
+var init_task_options = __esm({
+ "src/lib/utils/task-options.ts"() {
+ init_argument_filters();
+ init_util();
+ }
+});
+function callTaskParser(parser3, streams) {
+ return parser3(streams.stdOut, streams.stdErr);
+}
+function parseStringResponse(result, parsers11, ...texts) {
+ texts.forEach((text2) => {
+ for (let lines = toLinesWithContent(text2), i = 0, max = lines.length; i < max; i++) {
+ const line = (offset = 0) => {
+ if (i + offset >= max) {
+ return;
+ }
+ return lines[i + offset];
+ };
+ parsers11.some(({ parse }) => parse(line, result));
+ }
+ });
+ return result;
+}
+var init_task_parser = __esm({
+ "src/lib/utils/task-parser.ts"() {
+ init_util();
+ }
+});
+var utils_exports = {};
+__export2(utils_exports, {
+ ExitCodes: () => ExitCodes,
+ GitOutputStreams: () => GitOutputStreams,
+ LineParser: () => LineParser,
+ NOOP: () => NOOP,
+ NULL: () => NULL,
+ RemoteLineParser: () => RemoteLineParser,
+ append: () => append,
+ appendTaskOptions: () => appendTaskOptions,
+ asArray: () => asArray,
+ asFunction: () => asFunction,
+ asNumber: () => asNumber,
+ asStringArray: () => asStringArray,
+ bufferToString: () => bufferToString,
+ callTaskParser: () => callTaskParser,
+ createInstanceConfig: () => createInstanceConfig,
+ delay: () => delay,
+ filterArray: () => filterArray,
+ filterFunction: () => filterFunction,
+ filterHasLength: () => filterHasLength,
+ filterPlainObject: () => filterPlainObject,
+ filterPrimitives: () => filterPrimitives,
+ filterString: () => filterString,
+ filterStringArray: () => filterStringArray,
+ filterStringOrStringArray: () => filterStringOrStringArray,
+ filterType: () => filterType,
+ first: () => first,
+ folderExists: () => folderExists,
+ forEachLineWithContent: () => forEachLineWithContent,
+ getTrailingOptions: () => getTrailingOptions,
+ including: () => including,
+ isUserFunction: () => isUserFunction,
+ last: () => last,
+ objectToString: () => objectToString,
+ parseStringResponse: () => parseStringResponse,
+ pick: () => pick,
+ prefixedArray: () => prefixedArray,
+ remove: () => remove,
+ splitOn: () => splitOn,
+ toLinesWithContent: () => toLinesWithContent,
+ trailingFunctionArgument: () => trailingFunctionArgument,
+ trailingOptionsArgument: () => trailingOptionsArgument
+});
+var init_utils = __esm({
+ "src/lib/utils/index.ts"() {
+ init_argument_filters();
+ init_exit_codes();
+ init_git_output_streams();
+ init_line_parser();
+ init_simple_git_options();
+ init_task_options();
+ init_task_parser();
+ init_util();
+ }
+});
+var check_is_repo_exports = {};
+__export2(check_is_repo_exports, {
+ CheckRepoActions: () => CheckRepoActions,
+ checkIsBareRepoTask: () => checkIsBareRepoTask,
+ checkIsRepoRootTask: () => checkIsRepoRootTask,
+ checkIsRepoTask: () => checkIsRepoTask
+});
+function checkIsRepoTask(action) {
+ switch (action) {
+ case "bare":
+ return checkIsBareRepoTask();
+ case "root":
+ return checkIsRepoRootTask();
+ }
+ const commands = ["rev-parse", "--is-inside-work-tree"];
+ return {
+ commands,
+ format: "utf-8",
+ onError,
+ parser
+ };
+}
+function checkIsRepoRootTask() {
+ const commands = ["rev-parse", "--git-dir"];
+ return {
+ commands,
+ format: "utf-8",
+ onError,
+ parser(path3) {
+ return /^\.(git)?$/.test(path3.trim());
+ }
+ };
+}
+function checkIsBareRepoTask() {
+ const commands = ["rev-parse", "--is-bare-repository"];
+ return {
+ commands,
+ format: "utf-8",
+ onError,
+ parser
+ };
+}
+function isNotRepoMessage(error) {
+ return /(Not a git repository|Kein Git-Repository)/i.test(String(error));
+}
+var CheckRepoActions;
+var onError;
+var parser;
+var init_check_is_repo = __esm({
+ "src/lib/tasks/check-is-repo.ts"() {
+ init_utils();
+ CheckRepoActions = /* @__PURE__ */ ((CheckRepoActions2) => {
+ CheckRepoActions2["BARE"] = "bare";
+ CheckRepoActions2["IN_TREE"] = "tree";
+ CheckRepoActions2["IS_REPO_ROOT"] = "root";
+ return CheckRepoActions2;
+ })(CheckRepoActions || {});
+ onError = ({ exitCode }, error, done, fail) => {
+ if (exitCode === 128 && isNotRepoMessage(error)) {
+ return done(Buffer.from("false"));
+ }
+ fail(error);
+ };
+ parser = (text2) => {
+ return text2.trim() === "true";
+ };
+ }
+});
+function cleanSummaryParser(dryRun, text2) {
+ const summary = new CleanResponse(dryRun);
+ const regexp = dryRun ? dryRunRemovalRegexp : removalRegexp;
+ toLinesWithContent(text2).forEach((line) => {
+ const removed = line.replace(regexp, "");
+ summary.paths.push(removed);
+ (isFolderRegexp.test(removed) ? summary.folders : summary.files).push(removed);
+ });
+ return summary;
+}
+var CleanResponse;
+var removalRegexp;
+var dryRunRemovalRegexp;
+var isFolderRegexp;
+var init_CleanSummary = __esm({
+ "src/lib/responses/CleanSummary.ts"() {
+ init_utils();
+ CleanResponse = class {
+ constructor(dryRun) {
+ this.dryRun = dryRun;
+ this.paths = [];
+ this.files = [];
+ this.folders = [];
+ }
+ };
+ removalRegexp = /^[a-z]+\s*/i;
+ dryRunRemovalRegexp = /^[a-z]+\s+[a-z]+\s*/i;
+ isFolderRegexp = /\/$/;
+ }
+});
+var task_exports = {};
+__export2(task_exports, {
+ EMPTY_COMMANDS: () => EMPTY_COMMANDS,
+ adhocExecTask: () => adhocExecTask,
+ configurationErrorTask: () => configurationErrorTask,
+ isBufferTask: () => isBufferTask,
+ isEmptyTask: () => isEmptyTask,
+ straightThroughBufferTask: () => straightThroughBufferTask,
+ straightThroughStringTask: () => straightThroughStringTask
+});
+function adhocExecTask(parser3) {
+ return {
+ commands: EMPTY_COMMANDS,
+ format: "empty",
+ parser: parser3
+ };
+}
+function configurationErrorTask(error) {
+ return {
+ commands: EMPTY_COMMANDS,
+ format: "empty",
+ parser() {
+ throw typeof error === "string" ? new TaskConfigurationError(error) : error;
+ }
+ };
+}
+function straightThroughStringTask(commands, trimmed2 = false) {
+ return {
+ commands,
+ format: "utf-8",
+ parser(text2) {
+ return trimmed2 ? String(text2).trim() : text2;
+ }
+ };
+}
+function straightThroughBufferTask(commands) {
+ return {
+ commands,
+ format: "buffer",
+ parser(buffer) {
+ return buffer;
+ }
+ };
+}
+function isBufferTask(task) {
+ return task.format === "buffer";
+}
+function isEmptyTask(task) {
+ return task.format === "empty" || !task.commands.length;
+}
+var EMPTY_COMMANDS;
+var init_task = __esm({
+ "src/lib/tasks/task.ts"() {
+ init_task_configuration_error();
+ EMPTY_COMMANDS = [];
+ }
+});
+var clean_exports = {};
+__export2(clean_exports, {
+ CONFIG_ERROR_INTERACTIVE_MODE: () => CONFIG_ERROR_INTERACTIVE_MODE,
+ CONFIG_ERROR_MODE_REQUIRED: () => CONFIG_ERROR_MODE_REQUIRED,
+ CONFIG_ERROR_UNKNOWN_OPTION: () => CONFIG_ERROR_UNKNOWN_OPTION,
+ CleanOptions: () => CleanOptions,
+ cleanTask: () => cleanTask,
+ cleanWithOptionsTask: () => cleanWithOptionsTask,
+ isCleanOptionsArray: () => isCleanOptionsArray
+});
+function cleanWithOptionsTask(mode, customArgs) {
+ const { cleanMode, options, valid } = getCleanOptions(mode);
+ if (!cleanMode) {
+ return configurationErrorTask(CONFIG_ERROR_MODE_REQUIRED);
+ }
+ if (!valid.options) {
+ return configurationErrorTask(CONFIG_ERROR_UNKNOWN_OPTION + JSON.stringify(mode));
+ }
+ options.push(...customArgs);
+ if (options.some(isInteractiveMode)) {
+ return configurationErrorTask(CONFIG_ERROR_INTERACTIVE_MODE);
+ }
+ return cleanTask(cleanMode, options);
+}
+function cleanTask(mode, customArgs) {
+ const commands = ["clean", `-${mode}`, ...customArgs];
+ return {
+ commands,
+ format: "utf-8",
+ parser(text2) {
+ return cleanSummaryParser(mode === "n", text2);
+ }
+ };
+}
+function isCleanOptionsArray(input) {
+ return Array.isArray(input) && input.every((test) => CleanOptionValues.has(test));
+}
+function getCleanOptions(input) {
+ let cleanMode;
+ let options = [];
+ let valid = { cleanMode: false, options: true };
+ input.replace(/[^a-z]i/g, "").split("").forEach((char) => {
+ if (isCleanMode(char)) {
+ cleanMode = char;
+ valid.cleanMode = true;
+ } else {
+ valid.options = valid.options && isKnownOption(options[options.length] = `-${char}`);
+ }
+ });
+ return {
+ cleanMode,
+ options,
+ valid
+ };
+}
+function isCleanMode(cleanMode) {
+ return cleanMode === "f" || cleanMode === "n";
+}
+function isKnownOption(option) {
+ return /^-[a-z]$/i.test(option) && CleanOptionValues.has(option.charAt(1));
+}
+function isInteractiveMode(option) {
+ if (/^-[^\-]/.test(option)) {
+ return option.indexOf("i") > 0;
+ }
+ return option === "--interactive";
+}
+var CONFIG_ERROR_INTERACTIVE_MODE;
+var CONFIG_ERROR_MODE_REQUIRED;
+var CONFIG_ERROR_UNKNOWN_OPTION;
+var CleanOptions;
+var CleanOptionValues;
+var init_clean = __esm({
+ "src/lib/tasks/clean.ts"() {
+ init_CleanSummary();
+ init_utils();
+ init_task();
+ CONFIG_ERROR_INTERACTIVE_MODE = "Git clean interactive mode is not supported";
+ CONFIG_ERROR_MODE_REQUIRED = 'Git clean mode parameter ("n" or "f") is required';
+ CONFIG_ERROR_UNKNOWN_OPTION = "Git clean unknown option found in: ";
+ CleanOptions = /* @__PURE__ */ ((CleanOptions2) => {
+ CleanOptions2["DRY_RUN"] = "n";
+ CleanOptions2["FORCE"] = "f";
+ CleanOptions2["IGNORED_INCLUDED"] = "x";
+ CleanOptions2["IGNORED_ONLY"] = "X";
+ CleanOptions2["EXCLUDING"] = "e";
+ CleanOptions2["QUIET"] = "q";
+ CleanOptions2["RECURSIVE"] = "d";
+ return CleanOptions2;
+ })(CleanOptions || {});
+ CleanOptionValues = /* @__PURE__ */ new Set(["i", ...asStringArray(Object.values(CleanOptions))]);
+ }
+});
+function configListParser(text2) {
+ const config = new ConfigList();
+ for (const item of configParser(text2)) {
+ config.addValue(item.file, String(item.key), item.value);
+ }
+ return config;
+}
+function configGetParser(text2, key2) {
+ let value = null;
+ const values = [];
+ const scopes = /* @__PURE__ */ new Map();
+ for (const item of configParser(text2, key2)) {
+ if (item.key !== key2) {
+ continue;
+ }
+ values.push(value = item.value);
+ if (!scopes.has(item.file)) {
+ scopes.set(item.file, []);
+ }
+ scopes.get(item.file).push(value);
+ }
+ return {
+ key: key2,
+ paths: Array.from(scopes.keys()),
+ scopes,
+ value,
+ values
+ };
+}
+function configFilePath(filePath) {
+ return filePath.replace(/^(file):/, "");
+}
+function* configParser(text2, requestedKey = null) {
+ const lines = text2.split("\0");
+ for (let i = 0, max = lines.length - 1; i < max; ) {
+ const file = configFilePath(lines[i++]);
+ let value = lines[i++];
+ let key2 = requestedKey;
+ if (value.includes("\n")) {
+ const line = splitOn(value, "\n");
+ key2 = line[0];
+ value = line[1];
+ }
+ yield { file, key: key2, value };
+ }
+}
+var ConfigList;
+var init_ConfigList = __esm({
+ "src/lib/responses/ConfigList.ts"() {
+ init_utils();
+ ConfigList = class {
+ constructor() {
+ this.files = [];
+ this.values = /* @__PURE__ */ Object.create(null);
+ }
+ get all() {
+ if (!this._all) {
+ this._all = this.files.reduce((all, file) => {
+ return Object.assign(all, this.values[file]);
+ }, {});
+ }
+ return this._all;
+ }
+ addFile(file) {
+ if (!(file in this.values)) {
+ const latest = last(this.files);
+ this.values[file] = latest ? Object.create(this.values[latest]) : {};
+ this.files.push(file);
+ }
+ return this.values[file];
+ }
+ addValue(file, key2, value) {
+ const values = this.addFile(file);
+ if (!values.hasOwnProperty(key2)) {
+ values[key2] = value;
+ } else if (Array.isArray(values[key2])) {
+ values[key2].push(value);
+ } else {
+ values[key2] = [values[key2], value];
+ }
+ this._all = void 0;
+ }
+ };
+ }
+});
+function asConfigScope(scope, fallback) {
+ if (typeof scope === "string" && GitConfigScope.hasOwnProperty(scope)) {
+ return scope;
+ }
+ return fallback;
+}
+function addConfigTask(key2, value, append22, scope) {
+ const commands = ["config", `--${scope}`];
+ if (append22) {
+ commands.push("--add");
+ }
+ commands.push(key2, value);
+ return {
+ commands,
+ format: "utf-8",
+ parser(text2) {
+ return text2;
+ }
+ };
+}
+function getConfigTask(key2, scope) {
+ const commands = ["config", "--null", "--show-origin", "--get-all", key2];
+ if (scope) {
+ commands.splice(1, 0, `--${scope}`);
+ }
+ return {
+ commands,
+ format: "utf-8",
+ parser(text2) {
+ return configGetParser(text2, key2);
+ }
+ };
+}
+function listConfigTask(scope) {
+ const commands = ["config", "--list", "--show-origin", "--null"];
+ if (scope) {
+ commands.push(`--${scope}`);
+ }
+ return {
+ commands,
+ format: "utf-8",
+ parser(text2) {
+ return configListParser(text2);
+ }
+ };
+}
+function config_default() {
+ return {
+ addConfig(key2, value, ...rest) {
+ return this._runTask(addConfigTask(key2, value, rest[0] === true, asConfigScope(rest[1], "local")), trailingFunctionArgument(arguments));
+ },
+ getConfig(key2, scope) {
+ return this._runTask(getConfigTask(key2, asConfigScope(scope, void 0)), trailingFunctionArgument(arguments));
+ },
+ listConfig(...rest) {
+ return this._runTask(listConfigTask(asConfigScope(rest[0], void 0)), trailingFunctionArgument(arguments));
+ }
+ };
+}
+var GitConfigScope;
+var init_config = __esm({
+ "src/lib/tasks/config.ts"() {
+ init_ConfigList();
+ init_utils();
+ GitConfigScope = /* @__PURE__ */ ((GitConfigScope2) => {
+ GitConfigScope2["system"] = "system";
+ GitConfigScope2["global"] = "global";
+ GitConfigScope2["local"] = "local";
+ GitConfigScope2["worktree"] = "worktree";
+ return GitConfigScope2;
+ })(GitConfigScope || {});
+ }
+});
+function grepQueryBuilder(...params) {
+ return new GrepQuery().param(...params);
+}
+function parseGrep(grep) {
+ const paths = /* @__PURE__ */ new Set();
+ const results = {};
+ forEachLineWithContent(grep, (input) => {
+ const [path3, line, preview] = input.split(NULL);
+ paths.add(path3);
+ (results[path3] = results[path3] || []).push({
+ line: asNumber(line),
+ path: path3,
+ preview
+ });
+ });
+ return {
+ paths,
+ results
+ };
+}
+function grep_default() {
+ return {
+ grep(searchTerm) {
+ const then = trailingFunctionArgument(arguments);
+ const options = getTrailingOptions(arguments);
+ for (const option of disallowedOptions) {
+ if (options.includes(option)) {
+ return this._runTask(configurationErrorTask(`git.grep: use of "${option}" is not supported.`), then);
+ }
+ }
+ if (typeof searchTerm === "string") {
+ searchTerm = grepQueryBuilder().param(searchTerm);
+ }
+ const commands = ["grep", "--null", "-n", "--full-name", ...options, ...searchTerm];
+ return this._runTask({
+ commands,
+ format: "utf-8",
+ parser(stdOut) {
+ return parseGrep(stdOut);
+ }
+ }, then);
+ }
+ };
+}
+var disallowedOptions;
+var Query;
+var _a;
+var GrepQuery;
+var init_grep = __esm({
+ "src/lib/tasks/grep.ts"() {
+ init_utils();
+ init_task();
+ disallowedOptions = ["-h"];
+ Query = Symbol("grepQuery");
+ GrepQuery = class {
+ constructor() {
+ this[_a] = [];
+ }
+ *[(_a = Query, Symbol.iterator)]() {
+ for (const query of this[Query]) {
+ yield query;
+ }
+ }
+ and(...and) {
+ and.length && this[Query].push("--and", "(", ...prefixedArray(and, "-e"), ")");
+ return this;
+ }
+ param(...param) {
+ this[Query].push(...prefixedArray(param, "-e"));
+ return this;
+ }
+ };
+ }
+});
+var reset_exports = {};
+__export2(reset_exports, {
+ ResetMode: () => ResetMode,
+ getResetMode: () => getResetMode,
+ resetTask: () => resetTask
+});
+function resetTask(mode, customArgs) {
+ const commands = ["reset"];
+ if (isValidResetMode(mode)) {
+ commands.push(`--${mode}`);
+ }
+ commands.push(...customArgs);
+ return straightThroughStringTask(commands);
+}
+function getResetMode(mode) {
+ if (isValidResetMode(mode)) {
+ return mode;
+ }
+ switch (typeof mode) {
+ case "string":
+ case "undefined":
+ return "soft";
+ }
+ return;
+}
+function isValidResetMode(mode) {
+ return ResetModes.includes(mode);
+}
+var ResetMode;
+var ResetModes;
+var init_reset = __esm({
+ "src/lib/tasks/reset.ts"() {
+ init_task();
+ ResetMode = /* @__PURE__ */ ((ResetMode2) => {
+ ResetMode2["MIXED"] = "mixed";
+ ResetMode2["SOFT"] = "soft";
+ ResetMode2["HARD"] = "hard";
+ ResetMode2["MERGE"] = "merge";
+ ResetMode2["KEEP"] = "keep";
+ return ResetMode2;
+ })(ResetMode || {});
+ ResetModes = Array.from(Object.values(ResetMode));
+ }
+});
+function createLog() {
+ return (0, import_debug.default)("simple-git");
+}
+function prefixedLogger(to, prefix, forward) {
+ if (!prefix || !String(prefix).replace(/\s*/, "")) {
+ return !forward ? to : (message, ...args) => {
+ to(message, ...args);
+ forward(message, ...args);
+ };
+ }
+ return (message, ...args) => {
+ to(`%s ${message}`, prefix, ...args);
+ if (forward) {
+ forward(message, ...args);
+ }
+ };
+}
+function childLoggerName(name, childDebugger, { namespace: parentNamespace }) {
+ if (typeof name === "string") {
+ return name;
+ }
+ const childNamespace = childDebugger && childDebugger.namespace || "";
+ if (childNamespace.startsWith(parentNamespace)) {
+ return childNamespace.substr(parentNamespace.length + 1);
+ }
+ return childNamespace || parentNamespace;
+}
+function createLogger(label, verbose, initialStep, infoDebugger = createLog()) {
+ const labelPrefix = label && `[${label}]` || "";
+ const spawned = [];
+ const debugDebugger = typeof verbose === "string" ? infoDebugger.extend(verbose) : verbose;
+ const key2 = childLoggerName(filterType(verbose, filterString), debugDebugger, infoDebugger);
+ return step(initialStep);
+ function sibling(name, initial) {
+ return append(spawned, createLogger(label, key2.replace(/^[^:]+/, name), initial, infoDebugger));
+ }
+ function step(phase) {
+ const stepPrefix = phase && `[${phase}]` || "";
+ const debug2 = debugDebugger && prefixedLogger(debugDebugger, stepPrefix) || NOOP;
+ const info = prefixedLogger(infoDebugger, `${labelPrefix} ${stepPrefix}`, debug2);
+ return Object.assign(debugDebugger ? debug2 : info, {
+ label,
+ sibling,
+ info,
+ step
+ });
+ }
+}
+var init_git_logger = __esm({
+ "src/lib/git-logger.ts"() {
+ init_utils();
+ import_debug.default.formatters.L = (value) => String(filterHasLength(value) ? value.length : "-");
+ import_debug.default.formatters.B = (value) => {
+ if (Buffer.isBuffer(value)) {
+ return value.toString("utf8");
+ }
+ return objectToString(value);
+ };
+ }
+});
+var _TasksPendingQueue;
+var TasksPendingQueue;
+var init_tasks_pending_queue = __esm({
+ "src/lib/runners/tasks-pending-queue.ts"() {
+ init_git_error();
+ init_git_logger();
+ _TasksPendingQueue = class {
+ constructor(logLabel = "GitExecutor") {
+ this.logLabel = logLabel;
+ this._queue = /* @__PURE__ */ new Map();
+ }
+ withProgress(task) {
+ return this._queue.get(task);
+ }
+ createProgress(task) {
+ const name = _TasksPendingQueue.getName(task.commands[0]);
+ const logger = 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(void 0, "TasksPendingQueue: attempt called for an unknown task");
+ }
+ progress.logger("Starting task");
+ return progress;
+ }
+ static getName(name = "empty") {
+ return `task:${name}:${++_TasksPendingQueue.counter}`;
+ }
+ };
+ TasksPendingQueue = _TasksPendingQueue;
+ TasksPendingQueue.counter = 0;
+ }
+});
+function pluginContext(task, commands) {
+ return {
+ method: first(task.commands) || "",
+ commands
+ };
+}
+function onErrorReceived(target, 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 GitExecutorChain;
+var init_git_executor_chain = __esm({
+ "src/lib/runners/git-executor-chain.ts"() {
+ init_git_error();
+ init_task();
+ init_utils();
+ init_tasks_pending_queue();
+ GitExecutorChain = class {
+ constructor(_executor, _scheduler, _plugins) {
+ this._executor = _executor;
+ this._scheduler = _scheduler;
+ this._plugins = _plugins;
+ this._chain = Promise.resolve();
+ this._queue = new TasksPendingQueue();
+ }
+ get binary() {
+ return this._executor.binary;
+ }
+ get cwd() {
+ return this._cwd || this._executor.cwd;
+ }
+ set cwd(cwd) {
+ this._cwd = cwd;
+ }
+ get env() {
+ return this._executor.env;
+ }
+ get outputHandler() {
+ return this._executor.outputHandler;
+ }
+ chain() {
+ return this;
+ }
+ push(task) {
+ this._queue.push(task);
+ return this._chain = this._chain.then(() => this.attemptTask(task));
+ }
+ attemptTask(task) {
+ return __async2(this, null, function* () {
+ const onScheduleComplete = yield this._scheduler.next();
+ const onQueueComplete = () => this._queue.complete(task);
+ try {
+ const { logger } = this._queue.attempt(task);
+ return yield isEmptyTask(task) ? this.attemptEmptyTask(task, logger) : this.attemptRemoteTask(task, logger);
+ } catch (e) {
+ throw this.onFatalException(task, e);
+ } finally {
+ onQueueComplete();
+ onScheduleComplete();
+ }
+ });
+ }
+ onFatalException(task, e) {
+ const gitError = e instanceof GitError ? Object.assign(e, { task }) : new GitError(task, e && String(e));
+ this._chain = Promise.resolve();
+ this._queue.fatal(gitError);
+ return gitError;
+ }
+ attemptRemoteTask(task, logger) {
+ return __async2(this, null, function* () {
+ const args = this._plugins.exec("spawn.args", [...task.commands], pluginContext(task, task.commands));
+ const raw = yield this.gitResponse(task, this.binary, args, this.outputHandler, logger.step("SPAWN"));
+ const outputStreams = yield this.handleTaskData(task, args, raw, logger.step("HANDLE"));
+ logger(`passing response to task's parser as a %s`, task.format);
+ if (isBufferTask(task)) {
+ return callTaskParser(task.parser, outputStreams);
+ }
+ return callTaskParser(task.parser, outputStreams.asStrings());
+ });
+ }
+ attemptEmptyTask(task, logger) {
+ return __async2(this, null, 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 }, __spreadValues2(__spreadValues2({}, 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`, objectToString(newStdOut));
+ done(new 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 GitOutputStreams(Buffer.concat(stdOut), Buffer.concat(stdErr)));
+ });
+ }
+ gitResponse(task, command, args, outputHandler, logger) {
+ return __async2(this, null, function* () {
+ const outputLogger = logger.sibling("output");
+ const spawnOptions = this._plugins.exec("spawn.options", {
+ cwd: this.cwd,
+ env: this.env,
+ windowsHide: true
+ }, pluginContext(task, task.commands));
+ return new Promise((done) => {
+ const stdOut = [];
+ const stdErr = [];
+ let rejection;
+ logger.info(`%s %o`, command, args);
+ logger("%O", spawnOptions);
+ const spawned = (0, import_child_process.spawn)(command, args, spawnOptions);
+ spawned.stdout.on("data", onDataReceived(stdOut, "stdOut", logger, outputLogger.step("stdOut")));
+ spawned.stderr.on("data", onDataReceived(stdErr, "stdErr", logger, outputLogger.step("stdErr")));
+ spawned.on("error", onErrorReceived(stdErr, logger));
+ if (outputHandler) {
+ logger(`Passing child process stdOut/stdErr to custom outputHandler`);
+ outputHandler(command, spawned.stdout, spawned.stderr, [...args]);
+ }
+ this._plugins.exec("spawn.after", void 0, __spreadProps2(__spreadValues2({}, pluginContext(task, args)), {
+ spawned,
+ close(exitCode, reason) {
+ done({
+ stdOut,
+ stdErr,
+ exitCode,
+ rejection: rejection || reason
+ });
+ },
+ kill(reason) {
+ if (spawned.killed) {
+ return;
+ }
+ rejection = reason;
+ spawned.kill("SIGINT");
+ }
+ }));
+ });
+ });
+ }
+ };
+ }
+});
+var git_executor_exports = {};
+__export2(git_executor_exports, {
+ GitExecutor: () => GitExecutor
+});
+var GitExecutor;
+var init_git_executor = __esm({
+ "src/lib/runners/git-executor.ts"() {
+ init_git_executor_chain();
+ GitExecutor = class {
+ constructor(binary = "git", cwd, _scheduler, _plugins) {
+ this.binary = binary;
+ this.cwd = cwd;
+ this._scheduler = _scheduler;
+ this._plugins = _plugins;
+ this._chain = new GitExecutorChain(this, this._scheduler, this._plugins);
+ }
+ chain() {
+ return new GitExecutorChain(this, this._scheduler, this._plugins);
+ }
+ push(task) {
+ return this._chain.push(task);
+ }
+ };
+ }
+});
+function taskCallback(task, response, callback = NOOP) {
+ const onSuccess = (data) => {
+ callback(null, data);
+ };
+ const onError2 = (err) => {
+ if ((err == null ? void 0 : err.task) === task) {
+ callback(err instanceof GitResponseError ? addDeprecationNoticeToError(err) : err, void 0);
+ }
+ };
+ response.then(onSuccess, onError2);
+}
+function addDeprecationNoticeToError(err) {
+ let log = (name) => {
+ console.warn(`simple-git deprecation notice: accessing GitResponseError.${name} should be GitResponseError.git.${name}, this will no longer be available in version 3`);
+ log = NOOP;
+ };
+ return Object.create(err, Object.getOwnPropertyNames(err.git).reduce(descriptorReducer, {}));
+ function descriptorReducer(all, name) {
+ if (name in err) {
+ return all;
+ }
+ all[name] = {
+ enumerable: false,
+ configurable: false,
+ get() {
+ log(name);
+ return err.git[name];
+ }
+ };
+ return all;
+ }
+}
+var init_task_callback = __esm({
+ "src/lib/task-callback.ts"() {
+ init_git_response_error();
+ init_utils();
+ }
+});
+function changeWorkingDirectoryTask(directory, root) {
+ return adhocExecTask((instance5) => {
+ if (!folderExists(directory)) {
+ throw new Error(`Git.cwd: cannot change to non-directory "${directory}"`);
+ }
+ return (root || instance5).cwd = directory;
+ });
+}
+var init_change_working_directory = __esm({
+ "src/lib/tasks/change-working-directory.ts"() {
+ init_utils();
+ init_task();
+ }
+});
+function parseCommitResult(stdOut) {
+ const result = {
+ author: null,
+ branch: "",
+ commit: "",
+ root: false,
+ summary: {
+ changes: 0,
+ insertions: 0,
+ deletions: 0
+ }
+ };
+ return parseStringResponse(result, parsers, stdOut);
+}
+var parsers;
+var init_parse_commit = __esm({
+ "src/lib/parsers/parse-commit.ts"() {
+ init_utils();
+ parsers = [
+ new LineParser(/^\[([^\s]+)( \([^)]+\))? ([^\]]+)/, (result, [branch, root, commit]) => {
+ result.branch = branch;
+ result.commit = commit;
+ result.root = !!root;
+ }),
+ new LineParser(/\s*Author:\s(.+)/i, (result, [author]) => {
+ const parts = author.split("<");
+ const email = parts.pop();
+ if (!email || !email.includes("@")) {
+ return;
+ }
+ result.author = {
+ email: email.substr(0, email.length - 1),
+ name: parts.join("<").trim()
+ };
+ }),
+ new LineParser(/(\d+)[^,]*(?:,\s*(\d+)[^,]*)(?:,\s*(\d+))/g, (result, [changes, insertions, deletions]) => {
+ result.summary.changes = parseInt(changes, 10) || 0;
+ result.summary.insertions = parseInt(insertions, 10) || 0;
+ result.summary.deletions = parseInt(deletions, 10) || 0;
+ }),
+ new LineParser(/^(\d+)[^,]*(?:,\s*(\d+)[^(]+\(([+-]))?/, (result, [changes, lines, direction]) => {
+ result.summary.changes = parseInt(changes, 10) || 0;
+ const count = parseInt(lines, 10) || 0;
+ if (direction === "-") {
+ result.summary.deletions = count;
+ } else if (direction === "+") {
+ result.summary.insertions = count;
+ }
+ })
+ ];
+ }
+});
+var commit_exports = {};
+__export2(commit_exports, {
+ commitTask: () => commitTask,
+ default: () => commit_default
+});
+function commitTask(message, files, customArgs) {
+ const commands = [
+ "-c",
+ "core.abbrev=40",
+ "commit",
+ ...prefixedArray(message, "-m"),
+ ...files,
+ ...customArgs
+ ];
+ return {
+ commands,
+ format: "utf-8",
+ parser: parseCommitResult
+ };
+}
+function commit_default() {
+ return {
+ commit(message, ...rest) {
+ const next = trailingFunctionArgument(arguments);
+ const task = rejectDeprecatedSignatures(message) || commitTask(asArray(message), asArray(filterType(rest[0], filterStringOrStringArray, [])), [...filterType(rest[1], filterArray, []), ...getTrailingOptions(arguments, 0, true)]);
+ return this._runTask(task, next);
+ }
+ };
+ function rejectDeprecatedSignatures(message) {
+ return !filterStringOrStringArray(message) && configurationErrorTask(`git.commit: requires the commit message to be supplied as a string/string[]`);
+ }
+}
+var init_commit = __esm({
+ "src/lib/tasks/commit.ts"() {
+ init_parse_commit();
+ init_utils();
+ init_task();
+ }
+});
+function hashObjectTask(filePath, write) {
+ const commands = ["hash-object", filePath];
+ if (write) {
+ commands.push("-w");
+ }
+ return straightThroughStringTask(commands, true);
+}
+var init_hash_object = __esm({
+ "src/lib/tasks/hash-object.ts"() {
+ init_task();
+ }
+});
+function parseInit(bare, path3, text2) {
+ const response = String(text2).trim();
+ let result;
+ if (result = initResponseRegex.exec(response)) {
+ return new InitSummary(bare, path3, false, result[1]);
+ }
+ if (result = reInitResponseRegex.exec(response)) {
+ return new InitSummary(bare, path3, 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, path3, /^re/i.test(response), gitDir);
+}
+var InitSummary;
+var initResponseRegex;
+var reInitResponseRegex;
+var init_InitSummary = __esm({
+ "src/lib/responses/InitSummary.ts"() {
+ InitSummary = class {
+ constructor(bare, path3, existing, gitDir) {
+ this.bare = bare;
+ this.path = path3;
+ this.existing = existing;
+ this.gitDir = gitDir;
+ }
+ };
+ initResponseRegex = /^Init.+ repository in (.+)$/;
+ reInitResponseRegex = /^Rein.+ in (.+)$/;
+ }
+});
+function hasBareCommand(command) {
+ return command.includes(bareCommand);
+}
+function initTask(bare = false, path3, customArgs) {
+ const commands = ["init", ...customArgs];
+ if (bare && !hasBareCommand(commands)) {
+ commands.splice(1, 0, bareCommand);
+ }
+ return {
+ commands,
+ format: "utf-8",
+ parser(text2) {
+ return parseInit(commands.includes("--bare"), path3, text2);
+ }
+ };
+}
+var bareCommand;
+var init_init = __esm({
+ "src/lib/tasks/init.ts"() {
+ init_InitSummary();
+ bareCommand = "--bare";
+ }
+});
+var DiffSummary;
+var init_DiffSummary = __esm({
+ "src/lib/responses/DiffSummary.ts"() {
+ DiffSummary = class {
+ constructor() {
+ this.changed = 0;
+ this.deletions = 0;
+ this.insertions = 0;
+ this.files = [];
+ }
+ };
+ }
+});
+function parseDiffResult(stdOut) {
+ const lines = stdOut.trim().split("\n");
+ const status = new 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;
+}
+function readSummaryLine(status, summary) {
+ (summary || "").trim().split(", ").forEach(function(text2) {
+ const summary2 = /(\d+)\s([a-z]+)/.exec(text2);
+ if (!summary2) {
+ return;
+ }
+ summaryType(status, summary2[2], parseInt(summary2[1], 10));
+ });
+}
+function summaryType(status, key2, value) {
+ const match = /([a-z]+?)s?\b/.exec(key2);
+ if (!match || !statusUpdate[match[1]]) {
+ return;
+ }
+ statusUpdate[match[1]](status, 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 statusUpdate;
+var init_parse_diff_summary = __esm({
+ "src/lib/parsers/parse-diff-summary.ts"() {
+ init_DiffSummary();
+ statusUpdate = {
+ file(status, value) {
+ status.changed = value;
+ },
+ deletion(status, value) {
+ status.deletions = value;
+ },
+ insertion(status, value) {
+ status.insertions = value;
+ }
+ };
+ }
+});
+function lineBuilder(tokens, fields) {
+ return fields.reduce((line, field, index) => {
+ line[field] = tokens[index] || "";
+ return line;
+ }, /* @__PURE__ */ Object.create({ diff: null }));
+}
+function createListLogSummaryParser(splitter = SPLITTER, fields = defaultFieldNames) {
+ return function(stdOut) {
+ const all = toLinesWithContent(stdOut, true, START_BOUNDARY).map(function(item) {
+ const lineDetail = item.trim().split(COMMIT_BOUNDARY);
+ const listLogLine = lineBuilder(lineDetail[0].trim().split(splitter), fields);
+ if (lineDetail.length > 1 && !!lineDetail[1].trim()) {
+ listLogLine.diff = parseDiffResult(lineDetail[1]);
+ }
+ return listLogLine;
+ });
+ return {
+ all,
+ latest: all.length && all[0] || null,
+ total: all.length
+ };
+ };
+}
+var START_BOUNDARY;
+var COMMIT_BOUNDARY;
+var SPLITTER;
+var defaultFieldNames;
+var init_parse_list_log_summary = __esm({
+ "src/lib/parsers/parse-list-log-summary.ts"() {
+ init_utils();
+ init_parse_diff_summary();
+ START_BOUNDARY = "\xF2\xF2\xF2\xF2\xF2\xF2 ";
+ COMMIT_BOUNDARY = " \xF2\xF2";
+ SPLITTER = " \xF2 ";
+ defaultFieldNames = ["hash", "date", "message", "refs", "author_name", "author_email"];
+ }
+});
+function prettyFormat(format, splitter) {
+ const fields = [];
+ const formatStr = [];
+ Object.keys(format).forEach((field) => {
+ fields.push(field);
+ formatStr.push(String(format[field]));
+ });
+ return [
+ fields,
+ formatStr.join(splitter)
+ ];
+}
+function userOptions(input) {
+ return Object.keys(input).reduce((out, key2) => {
+ if (!(key2 in excludeOptions)) {
+ out[key2] = input[key2];
+ }
+ return out;
+ }, {});
+}
+function parseLogOptions(opt = {}, customArgs = []) {
+ const splitter = filterType(opt.splitter, filterString, SPLITTER);
+ const format = !filterPrimitives(opt.format) && opt.format ? opt.format : {
+ hash: "%H",
+ date: opt.strictDate === false ? "%ai" : "%aI",
+ message: "%s",
+ refs: "%D",
+ body: opt.multiLine ? "%B" : "%b",
+ author_name: opt.mailMap !== false ? "%aN" : "%an",
+ author_email: opt.mailMap !== false ? "%aE" : "%ae"
+ };
+ const [fields, formatStr] = prettyFormat(format, splitter);
+ const suffix = [];
+ const command = [
+ `--pretty=format:${START_BOUNDARY}${formatStr}${COMMIT_BOUNDARY}`,
+ ...customArgs
+ ];
+ const maxCount = opt.n || opt["max-count"] || opt.maxCount;
+ if (maxCount) {
+ command.push(`--max-count=${maxCount}`);
+ }
+ if (opt.from && opt.to) {
+ const rangeOperator = opt.symmetric !== false ? "..." : "..";
+ suffix.push(`${opt.from}${rangeOperator}${opt.to}`);
+ }
+ if (filterString(opt.file)) {
+ suffix.push("--follow", opt.file);
+ }
+ appendTaskOptions(userOptions(opt), command);
+ return {
+ fields,
+ splitter,
+ commands: [
+ ...command,
+ ...suffix
+ ]
+ };
+}
+function logTask(splitter, fields, customArgs) {
+ return {
+ commands: ["log", ...customArgs],
+ format: "utf-8",
+ parser: createListLogSummaryParser(splitter, fields)
+ };
+}
+function log_default() {
+ return {
+ log(...rest) {
+ const next = trailingFunctionArgument(arguments);
+ const task = rejectDeprecatedSignatures(...rest) || createLogTask(parseLogOptions(trailingOptionsArgument(arguments), filterType(arguments[0], filterArray)));
+ return this._runTask(task, next);
+ }
+ };
+ function createLogTask(options) {
+ return logTask(options.splitter, options.fields, options.commands);
+ }
+ function rejectDeprecatedSignatures(from, to) {
+ return filterString(from) && filterString(to) && configurationErrorTask(`git.log(string, string) should be replaced with git.log({ from: string, to: string })`);
+ }
+}
+var excludeOptions;
+var init_log = __esm({
+ "src/lib/tasks/log.ts"() {
+ init_parse_list_log_summary();
+ init_utils();
+ init_task();
+ excludeOptions = /* @__PURE__ */ ((excludeOptions2) => {
+ excludeOptions2[excludeOptions2["--pretty"] = 0] = "--pretty";
+ excludeOptions2[excludeOptions2["max-count"] = 1] = "max-count";
+ excludeOptions2[excludeOptions2["maxCount"] = 2] = "maxCount";
+ excludeOptions2[excludeOptions2["n"] = 3] = "n";
+ excludeOptions2[excludeOptions2["file"] = 4] = "file";
+ excludeOptions2[excludeOptions2["format"] = 5] = "format";
+ excludeOptions2[excludeOptions2["from"] = 6] = "from";
+ excludeOptions2[excludeOptions2["to"] = 7] = "to";
+ excludeOptions2[excludeOptions2["splitter"] = 8] = "splitter";
+ excludeOptions2[excludeOptions2["symmetric"] = 9] = "symmetric";
+ excludeOptions2[excludeOptions2["mailMap"] = 10] = "mailMap";
+ excludeOptions2[excludeOptions2["multiLine"] = 11] = "multiLine";
+ excludeOptions2[excludeOptions2["strictDate"] = 12] = "strictDate";
+ return excludeOptions2;
+ })(excludeOptions || {});
+ }
+});
+var MergeSummaryConflict;
+var MergeSummaryDetail;
+var init_MergeSummary = __esm({
+ "src/lib/responses/MergeSummary.ts"() {
+ MergeSummaryConflict = class {
+ constructor(reason, file = null, meta) {
+ this.reason = reason;
+ this.file = file;
+ this.meta = meta;
+ }
+ toString() {
+ return `${this.file}:${this.reason}`;
+ }
+ };
+ MergeSummaryDetail = class {
+ constructor() {
+ this.conflicts = [];
+ this.merges = [];
+ this.result = "success";
+ }
+ get failed() {
+ return this.conflicts.length > 0;
+ }
+ get reason() {
+ return this.result;
+ }
+ toString() {
+ if (this.conflicts.length) {
+ return `CONFLICTS: ${this.conflicts.join(", ")}`;
+ }
+ return "OK";
+ }
+ };
+ }
+});
+var PullSummary;
+var PullFailedSummary;
+var init_PullSummary = __esm({
+ "src/lib/responses/PullSummary.ts"() {
+ PullSummary = class {
+ constructor() {
+ this.remoteMessages = {
+ all: []
+ };
+ this.created = [];
+ this.deleted = [];
+ this.files = [];
+ this.deletions = {};
+ this.insertions = {};
+ this.summary = {
+ changes: 0,
+ deletions: 0,
+ insertions: 0
+ };
+ }
+ };
+ PullFailedSummary = class {
+ constructor() {
+ this.remote = "";
+ this.hash = {
+ local: "",
+ remote: ""
+ };
+ this.branch = {
+ local: "",
+ remote: ""
+ };
+ this.message = "";
+ }
+ toString() {
+ return this.message;
+ }
+ };
+ }
+});
+function objectEnumerationResult(remoteMessages) {
+ return remoteMessages.objects = remoteMessages.objects || {
+ compressing: 0,
+ counting: 0,
+ enumerating: 0,
+ packReused: 0,
+ reused: { count: 0, delta: 0 },
+ total: { count: 0, delta: 0 }
+ };
+}
+function asObjectCount(source) {
+ const count = /^\s*(\d+)/.exec(source);
+ const delta = /delta (\d+)/i.exec(source);
+ return {
+ count: asNumber(count && count[1] || "0"),
+ delta: asNumber(delta && delta[1] || "0")
+ };
+}
+var remoteMessagesObjectParsers;
+var init_parse_remote_objects = __esm({
+ "src/lib/parsers/parse-remote-objects.ts"() {
+ init_utils();
+ remoteMessagesObjectParsers = [
+ new RemoteLineParser(/^remote:\s*(enumerating|counting|compressing) objects: (\d+),/i, (result, [action, count]) => {
+ const key2 = action.toLowerCase();
+ const enumeration = objectEnumerationResult(result.remoteMessages);
+ Object.assign(enumeration, { [key2]: asNumber(count) });
+ }),
+ new RemoteLineParser(/^remote:\s*(enumerating|counting|compressing) objects: \d+% \(\d+\/(\d+)\),/i, (result, [action, count]) => {
+ const key2 = action.toLowerCase();
+ const enumeration = objectEnumerationResult(result.remoteMessages);
+ Object.assign(enumeration, { [key2]: asNumber(count) });
+ }),
+ new RemoteLineParser(/total ([^,]+), reused ([^,]+), pack-reused (\d+)/i, (result, [total, reused, packReused]) => {
+ const objects = objectEnumerationResult(result.remoteMessages);
+ objects.total = asObjectCount(total);
+ objects.reused = asObjectCount(reused);
+ objects.packReused = asNumber(packReused);
+ })
+ ];
+ }
+});
+function parseRemoteMessages(_stdOut, stdErr) {
+ return parseStringResponse({ remoteMessages: new RemoteMessageSummary() }, parsers2, stdErr);
+}
+var parsers2;
+var RemoteMessageSummary;
+var init_parse_remote_messages = __esm({
+ "src/lib/parsers/parse-remote-messages.ts"() {
+ init_utils();
+ init_parse_remote_objects();
+ parsers2 = [
+ new RemoteLineParser(/^remote:\s*(.+)$/, (result, [text2]) => {
+ result.remoteMessages.all.push(text2.trim());
+ return false;
+ }),
+ ...remoteMessagesObjectParsers,
+ new RemoteLineParser([/create a (?:pull|merge) request/i, /\s(https?:\/\/\S+)$/], (result, [pullRequestUrl]) => {
+ result.remoteMessages.pullRequestUrl = pullRequestUrl;
+ }),
+ new RemoteLineParser([/found (\d+) vulnerabilities.+\(([^)]+)\)/i, /\s(https?:\/\/\S+)$/], (result, [count, summary, url]) => {
+ result.remoteMessages.vulnerabilities = {
+ count: asNumber(count),
+ summary,
+ url
+ };
+ })
+ ];
+ RemoteMessageSummary = class {
+ constructor() {
+ this.all = [];
+ }
+ };
+ }
+});
+function parsePullErrorResult(stdOut, stdErr) {
+ const pullError = parseStringResponse(new PullFailedSummary(), errorParsers, stdOut, stdErr);
+ return pullError.message && pullError;
+}
+var FILE_UPDATE_REGEX;
+var SUMMARY_REGEX;
+var ACTION_REGEX;
+var parsers3;
+var errorParsers;
+var parsePullDetail;
+var parsePullResult;
+var init_parse_pull = __esm({
+ "src/lib/parsers/parse-pull.ts"() {
+ init_PullSummary();
+ init_utils();
+ init_parse_remote_messages();
+ FILE_UPDATE_REGEX = /^\s*(.+?)\s+\|\s+\d+\s*(\+*)(-*)/;
+ SUMMARY_REGEX = /(\d+)\D+((\d+)\D+\(\+\))?(\D+(\d+)\D+\(-\))?/;
+ ACTION_REGEX = /^(create|delete) mode \d+ (.+)/;
+ parsers3 = [
+ new LineParser(FILE_UPDATE_REGEX, (result, [file, insertions, deletions]) => {
+ result.files.push(file);
+ if (insertions) {
+ result.insertions[file] = insertions.length;
+ }
+ if (deletions) {
+ result.deletions[file] = deletions.length;
+ }
+ }),
+ new LineParser(SUMMARY_REGEX, (result, [changes, , insertions, , deletions]) => {
+ if (insertions !== void 0 || deletions !== void 0) {
+ result.summary.changes = +changes || 0;
+ result.summary.insertions = +insertions || 0;
+ result.summary.deletions = +deletions || 0;
+ return true;
+ }
+ return false;
+ }),
+ new LineParser(ACTION_REGEX, (result, [action, file]) => {
+ append(result.files, file);
+ append(action === "create" ? result.created : result.deleted, file);
+ })
+ ];
+ errorParsers = [
+ new LineParser(/^from\s(.+)$/i, (result, [remote]) => void (result.remote = remote)),
+ new LineParser(/^fatal:\s(.+)$/, (result, [message]) => void (result.message = message)),
+ new LineParser(/([a-z0-9]+)\.\.([a-z0-9]+)\s+(\S+)\s+->\s+(\S+)$/, (result, [hashLocal, hashRemote, branchLocal, branchRemote]) => {
+ result.branch.local = branchLocal;
+ result.hash.local = hashLocal;
+ result.branch.remote = branchRemote;
+ result.hash.remote = hashRemote;
+ })
+ ];
+ parsePullDetail = (stdOut, stdErr) => {
+ return parseStringResponse(new PullSummary(), parsers3, stdOut, stdErr);
+ };
+ parsePullResult = (stdOut, stdErr) => {
+ return Object.assign(new PullSummary(), parsePullDetail(stdOut, stdErr), parseRemoteMessages(stdOut, stdErr));
+ };
+ }
+});
+var parsers4;
+var parseMergeResult;
+var parseMergeDetail;
+var init_parse_merge = __esm({
+ "src/lib/parsers/parse-merge.ts"() {
+ init_MergeSummary();
+ init_utils();
+ init_parse_pull();
+ parsers4 = [
+ new LineParser(/^Auto-merging\s+(.+)$/, (summary, [autoMerge]) => {
+ summary.merges.push(autoMerge);
+ }),
+ new LineParser(/^CONFLICT\s+\((.+)\): Merge conflict in (.+)$/, (summary, [reason, file]) => {
+ summary.conflicts.push(new MergeSummaryConflict(reason, file));
+ }),
+ new LineParser(/^CONFLICT\s+\((.+\/delete)\): (.+) deleted in (.+) and/, (summary, [reason, file, deleteRef]) => {
+ summary.conflicts.push(new MergeSummaryConflict(reason, file, { deleteRef }));
+ }),
+ new LineParser(/^CONFLICT\s+\((.+)\):/, (summary, [reason]) => {
+ summary.conflicts.push(new MergeSummaryConflict(reason, null));
+ }),
+ new LineParser(/^Automatic merge failed;\s+(.+)$/, (summary, [result]) => {
+ summary.result = result;
+ })
+ ];
+ parseMergeResult = (stdOut, stdErr) => {
+ return Object.assign(parseMergeDetail(stdOut, stdErr), parsePullResult(stdOut, stdErr));
+ };
+ parseMergeDetail = (stdOut) => {
+ return parseStringResponse(new MergeSummaryDetail(), parsers4, stdOut);
+ };
+ }
+});
+function mergeTask(customArgs) {
+ if (!customArgs.length) {
+ return configurationErrorTask("Git.merge requires at least one option");
+ }
+ return {
+ commands: ["merge", ...customArgs],
+ format: "utf-8",
+ parser(stdOut, stdErr) {
+ const merge = parseMergeResult(stdOut, stdErr);
+ if (merge.failed) {
+ throw new GitResponseError(merge);
+ }
+ return merge;
+ }
+ };
+}
+var init_merge = __esm({
+ "src/lib/tasks/merge.ts"() {
+ init_git_response_error();
+ init_parse_merge();
+ init_task();
+ }
+});
+function pushResultPushedItem(local, remote, status) {
+ const deleted = status.includes("deleted");
+ const tag = status.includes("tag") || /^refs\/tags/.test(local);
+ const alreadyUpdated = !status.includes("new");
+ return {
+ deleted,
+ tag,
+ branch: !tag,
+ new: !alreadyUpdated,
+ alreadyUpdated,
+ local,
+ remote
+ };
+}
+var parsers5;
+var parsePushResult;
+var parsePushDetail;
+var init_parse_push = __esm({
+ "src/lib/parsers/parse-push.ts"() {
+ init_utils();
+ init_parse_remote_messages();
+ parsers5 = [
+ new LineParser(/^Pushing to (.+)$/, (result, [repo]) => {
+ result.repo = repo;
+ }),
+ new LineParser(/^updating local tracking ref '(.+)'/, (result, [local]) => {
+ result.ref = __spreadProps2(__spreadValues2({}, result.ref || {}), {
+ local
+ });
+ }),
+ new LineParser(/^[*-=]\s+([^:]+):(\S+)\s+\[(.+)]$/, (result, [local, remote, type]) => {
+ result.pushed.push(pushResultPushedItem(local, remote, type));
+ }),
+ new LineParser(/^Branch '([^']+)' set up to track remote branch '([^']+)' from '([^']+)'/, (result, [local, remote, remoteName]) => {
+ result.branch = __spreadProps2(__spreadValues2({}, result.branch || {}), {
+ local,
+ remote,
+ remoteName
+ });
+ }),
+ new LineParser(/^([^:]+):(\S+)\s+([a-z0-9]+)\.\.([a-z0-9]+)$/, (result, [local, remote, from, to]) => {
+ result.update = {
+ head: {
+ local,
+ remote
+ },
+ hash: {
+ from,
+ to
+ }
+ };
+ })
+ ];
+ parsePushResult = (stdOut, stdErr) => {
+ const pushDetail = parsePushDetail(stdOut, stdErr);
+ const responseDetail = parseRemoteMessages(stdOut, stdErr);
+ return __spreadValues2(__spreadValues2({}, pushDetail), responseDetail);
+ };
+ parsePushDetail = (stdOut, stdErr) => {
+ return parseStringResponse({ pushed: [] }, parsers5, stdOut, stdErr);
+ };
+ }
+});
+var push_exports = {};
+__export2(push_exports, {
+ pushTagsTask: () => pushTagsTask,
+ pushTask: () => pushTask
+});
+function pushTagsTask(ref = {}, customArgs) {
+ append(customArgs, "--tags");
+ return pushTask(ref, customArgs);
+}
+function pushTask(ref = {}, customArgs) {
+ const commands = ["push", ...customArgs];
+ if (ref.branch) {
+ commands.splice(1, 0, ref.branch);
+ }
+ if (ref.remote) {
+ commands.splice(1, 0, ref.remote);
+ }
+ remove(commands, "-v");
+ append(commands, "--verbose");
+ append(commands, "--porcelain");
+ return {
+ commands,
+ format: "utf-8",
+ parser: parsePushResult
+ };
+}
+var init_push = __esm({
+ "src/lib/tasks/push.ts"() {
+ init_parse_push();
+ init_utils();
+ }
+});
+var fromPathRegex;
+var FileStatusSummary;
+var init_FileStatusSummary = __esm({
+ "src/lib/responses/FileStatusSummary.ts"() {
+ fromPathRegex = /^(.+) -> (.+)$/;
+ FileStatusSummary = class {
+ constructor(path3, index, working_dir) {
+ this.path = path3;
+ this.index = index;
+ this.working_dir = working_dir;
+ if (index + working_dir === "R") {
+ const detail = fromPathRegex.exec(path3) || [null, path3, path3];
+ this.from = detail[1] || "";
+ this.path = detail[2] || "";
+ }
+ }
+ };
+ }
+});
+function renamedFile(line) {
+ const [to, from] = line.split(NULL);
+ return {
+ from: from || to,
+ to
+ };
+}
+function parser2(indexX, indexY, handler) {
+ return [`${indexX}${indexY}`, handler];
+}
+function conflicts(indexX, ...indexY) {
+ return indexY.map((y) => parser2(indexX, y, (result, file) => append(result.conflicted, file)));
+}
+function splitLine(result, lineStr) {
+ const trimmed2 = lineStr.trim();
+ switch (" ") {
+ case trimmed2.charAt(2):
+ return data(trimmed2.charAt(0), trimmed2.charAt(1), trimmed2.substr(3));
+ case trimmed2.charAt(1):
+ return data(" ", trimmed2.charAt(0), trimmed2.substr(2));
+ default:
+ return;
+ }
+ function data(index, workingDir, path3) {
+ const raw = `${index}${workingDir}`;
+ const handler = parsers6.get(raw);
+ if (handler) {
+ handler(result, path3);
+ }
+ if (raw !== "##" && raw !== "!!") {
+ result.files.push(new FileStatusSummary(path3.replace(/\0.+$/, ""), index, workingDir));
+ }
+ }
+}
+var StatusSummary;
+var parsers6;
+var parseStatusSummary;
+var init_StatusSummary = __esm({
+ "src/lib/responses/StatusSummary.ts"() {
+ init_utils();
+ init_FileStatusSummary();
+ StatusSummary = class {
+ constructor() {
+ this.not_added = [];
+ this.conflicted = [];
+ this.created = [];
+ this.deleted = [];
+ this.ignored = void 0;
+ this.modified = [];
+ this.renamed = [];
+ this.files = [];
+ this.staged = [];
+ this.ahead = 0;
+ this.behind = 0;
+ this.current = null;
+ this.tracking = null;
+ this.detached = false;
+ this.isClean = () => {
+ return !this.files.length;
+ };
+ }
+ };
+ parsers6 = new Map([
+ parser2(" ", "A", (result, file) => append(result.created, file)),
+ parser2(" ", "D", (result, file) => append(result.deleted, file)),
+ parser2(" ", "M", (result, file) => append(result.modified, file)),
+ parser2("A", " ", (result, file) => append(result.created, file) && append(result.staged, file)),
+ parser2("A", "M", (result, file) => append(result.created, file) && append(result.staged, file) && append(result.modified, file)),
+ parser2("D", " ", (result, file) => append(result.deleted, file) && append(result.staged, file)),
+ parser2("M", " ", (result, file) => append(result.modified, file) && append(result.staged, file)),
+ parser2("M", "M", (result, file) => append(result.modified, file) && append(result.staged, file)),
+ parser2("R", " ", (result, file) => {
+ append(result.renamed, renamedFile(file));
+ }),
+ parser2("R", "M", (result, file) => {
+ const renamed = renamedFile(file);
+ append(result.renamed, renamed);
+ append(result.modified, renamed.to);
+ }),
+ parser2("!", "!", (_result, _file) => {
+ append(_result.ignored = _result.ignored || [], _file);
+ }),
+ parser2("?", "?", (result, file) => append(result.not_added, file)),
+ ...conflicts("A", "A", "U"),
+ ...conflicts("D", "D", "U"),
+ ...conflicts("U", "A", "D", "U"),
+ ["##", (result, line) => {
+ const aheadReg = /ahead (\d+)/;
+ const behindReg = /behind (\d+)/;
+ const currentReg = /^(.+?(?=(?:\.{3}|\s|$)))/;
+ const trackingReg = /\.{3}(\S*)/;
+ const onEmptyBranchReg = /\son\s([\S]+)$/;
+ let regexResult;
+ regexResult = aheadReg.exec(line);
+ result.ahead = regexResult && +regexResult[1] || 0;
+ regexResult = behindReg.exec(line);
+ result.behind = regexResult && +regexResult[1] || 0;
+ regexResult = currentReg.exec(line);
+ result.current = regexResult && regexResult[1];
+ regexResult = trackingReg.exec(line);
+ result.tracking = regexResult && regexResult[1];
+ regexResult = onEmptyBranchReg.exec(line);
+ result.current = regexResult && regexResult[1] || result.current;
+ result.detached = /\(no branch\)/.test(line);
+ }]
+ ]);
+ parseStatusSummary = function(text2) {
+ const lines = text2.split(NULL);
+ const status = new StatusSummary();
+ for (let i = 0, l = lines.length; i < l; ) {
+ let line = lines[i++].trim();
+ if (!line) {
+ continue;
+ }
+ if (line.charAt(0) === "R") {
+ line += NULL + (lines[i++] || "");
+ }
+ splitLine(status, line);
+ }
+ return status;
+ };
+ }
+});
+function statusTask(customArgs) {
+ const commands = [
+ "status",
+ "--porcelain",
+ "-b",
+ "-u",
+ "--null",
+ ...customArgs.filter((arg) => !ignoredOptions.includes(arg))
+ ];
+ return {
+ format: "utf-8",
+ commands,
+ parser(text2) {
+ return parseStatusSummary(text2);
+ }
+ };
+}
+var ignoredOptions;
+var init_status = __esm({
+ "src/lib/tasks/status.ts"() {
+ init_StatusSummary();
+ ignoredOptions = ["--null", "-z"];
+ }
+});
+var simple_git_api_exports = {};
+__export2(simple_git_api_exports, {
+ SimpleGitApi: () => SimpleGitApi
+});
+var SimpleGitApi;
+var init_simple_git_api = __esm({
+ "src/lib/simple-git-api.ts"() {
+ init_task_callback();
+ init_change_working_directory();
+ init_commit();
+ init_config();
+ init_grep();
+ init_hash_object();
+ init_init();
+ init_log();
+ init_merge();
+ init_push();
+ init_status();
+ init_task();
+ init_utils();
+ SimpleGitApi = class {
+ constructor(_executor) {
+ this._executor = _executor;
+ }
+ _runTask(task, then) {
+ const chain = this._executor.chain();
+ const promise2 = chain.push(task);
+ if (then) {
+ taskCallback(task, promise2, then);
+ }
+ return Object.create(this, {
+ then: { value: promise2.then.bind(promise2) },
+ catch: { value: promise2.catch.bind(promise2) },
+ _executor: { value: chain }
+ });
+ }
+ add(files) {
+ return this._runTask(straightThroughStringTask(["add", ...asArray(files)]), trailingFunctionArgument(arguments));
+ }
+ cwd(directory) {
+ const next = trailingFunctionArgument(arguments);
+ if (typeof directory === "string") {
+ return this._runTask(changeWorkingDirectoryTask(directory, this._executor), next);
+ }
+ if (typeof (directory == null ? void 0 : directory.path) === "string") {
+ return this._runTask(changeWorkingDirectoryTask(directory.path, directory.root && this._executor || void 0), next);
+ }
+ return this._runTask(configurationErrorTask("Git.cwd: workingDirectory must be supplied as a string"), next);
+ }
+ hashObject(path3, write) {
+ return this._runTask(hashObjectTask(path3, write === true), trailingFunctionArgument(arguments));
+ }
+ init(bare) {
+ return this._runTask(initTask(bare === true, this._executor.cwd, getTrailingOptions(arguments)), trailingFunctionArgument(arguments));
+ }
+ merge() {
+ return this._runTask(mergeTask(getTrailingOptions(arguments)), trailingFunctionArgument(arguments));
+ }
+ mergeFromTo(remote, branch) {
+ if (!(filterString(remote) && filterString(branch))) {
+ return this._runTask(configurationErrorTask(`Git.mergeFromTo requires that the 'remote' and 'branch' arguments are supplied as strings`));
+ }
+ return this._runTask(mergeTask([remote, branch, ...getTrailingOptions(arguments)]), trailingFunctionArgument(arguments, false));
+ }
+ outputHandler(handler) {
+ this._executor.outputHandler = handler;
+ return this;
+ }
+ push() {
+ const task = pushTask({
+ remote: filterType(arguments[0], filterString),
+ branch: filterType(arguments[1], filterString)
+ }, getTrailingOptions(arguments));
+ return this._runTask(task, trailingFunctionArgument(arguments));
+ }
+ stash() {
+ return this._runTask(straightThroughStringTask(["stash", ...getTrailingOptions(arguments)]), trailingFunctionArgument(arguments));
+ }
+ status() {
+ return this._runTask(statusTask(getTrailingOptions(arguments)), trailingFunctionArgument(arguments));
+ }
+ };
+ Object.assign(SimpleGitApi.prototype, commit_default(), config_default(), grep_default(), log_default());
+ }
+});
+var scheduler_exports = {};
+__export2(scheduler_exports, {
+ Scheduler: () => Scheduler
+});
+var createScheduledTask;
+var Scheduler;
+var init_scheduler = __esm({
+ "src/lib/runners/scheduler.ts"() {
+ init_utils();
+ init_git_logger();
+ createScheduledTask = (() => {
+ let id = 0;
+ return () => {
+ id++;
+ const { promise: promise2, done } = (0, import_promise_deferred.createDeferred)();
+ return {
+ promise: promise2,
+ done,
+ id
+ };
+ };
+ })();
+ Scheduler = class {
+ constructor(concurrency = 2) {
+ this.concurrency = concurrency;
+ this.logger = createLogger("", "scheduler");
+ this.pending = [];
+ this.running = [];
+ this.logger(`Constructed, concurrency=%s`, concurrency);
+ }
+ schedule() {
+ if (!this.pending.length || this.running.length >= this.concurrency) {
+ this.logger(`Schedule attempt ignored, pending=%s running=%s concurrency=%s`, this.pending.length, this.running.length, this.concurrency);
+ return;
+ }
+ const task = append(this.running, this.pending.shift());
+ this.logger(`Attempting id=%s`, task.id);
+ task.done(() => {
+ this.logger(`Completing id=`, task.id);
+ remove(this.running, task);
+ this.schedule();
+ });
+ }
+ next() {
+ const { promise: promise2, id } = append(this.pending, createScheduledTask());
+ this.logger(`Scheduling id=%s`, id);
+ this.schedule();
+ return promise2;
+ }
+ };
+ }
+});
+var apply_patch_exports = {};
+__export2(apply_patch_exports, {
+ applyPatchTask: () => applyPatchTask
+});
+function applyPatchTask(patches, customArgs) {
+ return straightThroughStringTask(["apply", ...customArgs, ...patches]);
+}
+var init_apply_patch = __esm({
+ "src/lib/tasks/apply-patch.ts"() {
+ init_task();
+ }
+});
+function branchDeletionSuccess(branch, hash2) {
+ return {
+ branch,
+ hash: hash2,
+ success: true
+ };
+}
+function branchDeletionFailure(branch) {
+ return {
+ branch,
+ hash: null,
+ success: false
+ };
+}
+var BranchDeletionBatch;
+var init_BranchDeleteSummary = __esm({
+ "src/lib/responses/BranchDeleteSummary.ts"() {
+ BranchDeletionBatch = class {
+ constructor() {
+ this.all = [];
+ this.branches = {};
+ this.errors = [];
+ }
+ get success() {
+ return !this.errors.length;
+ }
+ };
+ }
+});
+function hasBranchDeletionError(data, processExitCode) {
+ return processExitCode === 1 && deleteErrorRegex.test(data);
+}
+var deleteSuccessRegex;
+var deleteErrorRegex;
+var parsers7;
+var parseBranchDeletions;
+var init_parse_branch_delete = __esm({
+ "src/lib/parsers/parse-branch-delete.ts"() {
+ init_BranchDeleteSummary();
+ init_utils();
+ deleteSuccessRegex = /(\S+)\s+\(\S+\s([^)]+)\)/;
+ deleteErrorRegex = /^error[^']+'([^']+)'/m;
+ parsers7 = [
+ new LineParser(deleteSuccessRegex, (result, [branch, hash2]) => {
+ const deletion = branchDeletionSuccess(branch, hash2);
+ result.all.push(deletion);
+ result.branches[branch] = deletion;
+ }),
+ new LineParser(deleteErrorRegex, (result, [branch]) => {
+ const deletion = branchDeletionFailure(branch);
+ result.errors.push(deletion);
+ result.all.push(deletion);
+ result.branches[branch] = deletion;
+ })
+ ];
+ parseBranchDeletions = (stdOut, stdErr) => {
+ return parseStringResponse(new BranchDeletionBatch(), parsers7, stdOut, stdErr);
+ };
+ }
+});
+var BranchSummaryResult;
+var init_BranchSummary = __esm({
+ "src/lib/responses/BranchSummary.ts"() {
+ BranchSummaryResult = class {
+ constructor() {
+ this.all = [];
+ this.branches = {};
+ this.current = "";
+ this.detached = false;
+ }
+ push(current, detached, name, commit, label) {
+ if (current) {
+ this.detached = detached;
+ this.current = name;
+ }
+ this.all.push(name);
+ this.branches[name] = {
+ current,
+ name,
+ commit,
+ label
+ };
+ }
+ };
+ }
+});
+function parseBranchSummary(stdOut) {
+ return parseStringResponse(new BranchSummaryResult(), parsers8, stdOut);
+}
+var parsers8;
+var init_parse_branch = __esm({
+ "src/lib/parsers/parse-branch.ts"() {
+ init_BranchSummary();
+ init_utils();
+ parsers8 = [
+ new 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 LineParser(/^(\*\s)?(\S+)\s+([a-z0-9]+)\s?(.*)$/s, (result, [current, name, commit, label]) => {
+ result.push(!!current, false, name, commit, label);
+ })
+ ];
+ }
+});
+var branch_exports = {};
+__export2(branch_exports, {
+ branchLocalTask: () => branchLocalTask,
+ branchTask: () => branchTask,
+ containsDeleteBranchCommand: () => containsDeleteBranchCommand,
+ deleteBranchTask: () => deleteBranchTask,
+ deleteBranchesTask: () => deleteBranchesTask
+});
+function containsDeleteBranchCommand(commands) {
+ const deleteCommands = ["-d", "-D", "--delete"];
+ return commands.some((command) => deleteCommands.includes(command));
+}
+function branchTask(customArgs) {
+ const isDelete = containsDeleteBranchCommand(customArgs);
+ const commands = ["branch", ...customArgs];
+ if (commands.length === 1) {
+ commands.push("-a");
+ }
+ if (!commands.includes("-v")) {
+ commands.splice(1, 0, "-v");
+ }
+ return {
+ format: "utf-8",
+ commands,
+ parser(stdOut, stdErr) {
+ if (isDelete) {
+ return parseBranchDeletions(stdOut, stdErr).all[0];
+ }
+ return parseBranchSummary(stdOut);
+ }
+ };
+}
+function branchLocalTask() {
+ const parser3 = parseBranchSummary;
+ return {
+ format: "utf-8",
+ commands: ["branch", "-v"],
+ parser: parser3
+ };
+}
+function deleteBranchesTask(branches, forceDelete = false) {
+ return {
+ format: "utf-8",
+ commands: ["branch", "-v", forceDelete ? "-D" : "-d", ...branches],
+ parser(stdOut, stdErr) {
+ return parseBranchDeletions(stdOut, stdErr);
+ },
+ onError({ exitCode, stdOut }, error, done, fail) {
+ if (!hasBranchDeletionError(String(error), exitCode)) {
+ return fail(error);
+ }
+ done(stdOut);
+ }
+ };
+}
+function deleteBranchTask(branch, forceDelete = false) {
+ const task = {
+ format: "utf-8",
+ commands: ["branch", "-v", forceDelete ? "-D" : "-d", branch],
+ parser(stdOut, stdErr) {
+ return parseBranchDeletions(stdOut, stdErr).branches[branch];
+ },
+ onError({ exitCode, stdErr, stdOut }, error, _, fail) {
+ if (!hasBranchDeletionError(String(error), exitCode)) {
+ return fail(error);
+ }
+ throw new GitResponseError(task.parser(bufferToString(stdOut), bufferToString(stdErr)), String(error));
+ }
+ };
+ return task;
+}
+var init_branch = __esm({
+ "src/lib/tasks/branch.ts"() {
+ init_git_response_error();
+ init_parse_branch_delete();
+ init_parse_branch();
+ init_utils();
+ }
+});
+var parseCheckIgnore;
+var init_CheckIgnore = __esm({
+ "src/lib/responses/CheckIgnore.ts"() {
+ parseCheckIgnore = (text2) => {
+ return text2.split(/\n/g).map((line) => line.trim()).filter((file) => !!file);
+ };
+ }
+});
+var check_ignore_exports = {};
+__export2(check_ignore_exports, {
+ checkIgnoreTask: () => checkIgnoreTask
+});
+function checkIgnoreTask(paths) {
+ return {
+ commands: ["check-ignore", ...paths],
+ format: "utf-8",
+ parser: parseCheckIgnore
+ };
+}
+var init_check_ignore = __esm({
+ "src/lib/tasks/check-ignore.ts"() {
+ init_CheckIgnore();
+ }
+});
+var clone_exports = {};
+__export2(clone_exports, {
+ cloneMirrorTask: () => cloneMirrorTask,
+ cloneTask: () => cloneTask
+});
+function disallowedCommand(command) {
+ return /^--upload-pack(=|$)/.test(command);
+}
+function cloneTask(repo, directory, customArgs) {
+ const commands = ["clone", ...customArgs];
+ filterString(repo) && commands.push(repo);
+ filterString(directory) && commands.push(directory);
+ const banned = commands.find(disallowedCommand);
+ if (banned) {
+ return configurationErrorTask(`git.fetch: potential exploit argument blocked.`);
+ }
+ return straightThroughStringTask(commands);
+}
+function cloneMirrorTask(repo, directory, customArgs) {
+ append(customArgs, "--mirror");
+ return cloneTask(repo, directory, customArgs);
+}
+var init_clone = __esm({
+ "src/lib/tasks/clone.ts"() {
+ init_task();
+ init_utils();
+ }
+});
+var diff_exports = {};
+__export2(diff_exports, {
+ diffSummaryTask: () => diffSummaryTask
+});
+function diffSummaryTask(customArgs) {
+ return {
+ commands: ["diff", "--stat=4096", ...customArgs],
+ format: "utf-8",
+ parser(stdOut) {
+ return parseDiffResult(stdOut);
+ }
+ };
+}
+var init_diff = __esm({
+ "src/lib/tasks/diff.ts"() {
+ init_parse_diff_summary();
+ }
+});
+function parseFetchResult(stdOut, stdErr) {
+ const result = {
+ raw: stdOut,
+ remote: null,
+ branches: [],
+ tags: []
+ };
+ return parseStringResponse(result, parsers9, stdOut, stdErr);
+}
+var parsers9;
+var init_parse_fetch = __esm({
+ "src/lib/parsers/parse-fetch.ts"() {
+ init_utils();
+ parsers9 = [
+ new LineParser(/From (.+)$/, (result, [remote]) => {
+ result.remote = remote;
+ }),
+ new LineParser(/\* \[new branch]\s+(\S+)\s*-> (.+)$/, (result, [name, tracking]) => {
+ result.branches.push({
+ name,
+ tracking
+ });
+ }),
+ new LineParser(/\* \[new tag]\s+(\S+)\s*-> (.+)$/, (result, [name, tracking]) => {
+ result.tags.push({
+ name,
+ tracking
+ });
+ })
+ ];
+ }
+});
+var fetch_exports = {};
+__export2(fetch_exports, {
+ fetchTask: () => fetchTask
+});
+function disallowedCommand2(command) {
+ return /^--upload-pack(=|$)/.test(command);
+}
+function fetchTask(remote, branch, customArgs) {
+ const commands = ["fetch", ...customArgs];
+ if (remote && branch) {
+ commands.push(remote, branch);
+ }
+ const banned = commands.find(disallowedCommand2);
+ if (banned) {
+ return configurationErrorTask(`git.fetch: potential exploit argument blocked.`);
+ }
+ return {
+ commands,
+ format: "utf-8",
+ parser: parseFetchResult
+ };
+}
+var init_fetch = __esm({
+ "src/lib/tasks/fetch.ts"() {
+ init_parse_fetch();
+ init_task();
+ }
+});
+function parseMoveResult(stdOut) {
+ return parseStringResponse({ moves: [] }, parsers10, stdOut);
+}
+var parsers10;
+var init_parse_move = __esm({
+ "src/lib/parsers/parse-move.ts"() {
+ init_utils();
+ parsers10 = [
+ new LineParser(/^Renaming (.+) to (.+)$/, (result, [from, to]) => {
+ result.moves.push({ from, to });
+ })
+ ];
+ }
+});
+var move_exports = {};
+__export2(move_exports, {
+ moveTask: () => moveTask
+});
+function moveTask(from, to) {
+ return {
+ commands: ["mv", "-v", ...asArray(from), to],
+ format: "utf-8",
+ parser: parseMoveResult
+ };
+}
+var init_move = __esm({
+ "src/lib/tasks/move.ts"() {
+ init_parse_move();
+ init_utils();
+ }
+});
+var pull_exports = {};
+__export2(pull_exports, {
+ pullTask: () => pullTask
+});
+function pullTask(remote, branch, customArgs) {
+ const commands = ["pull", ...customArgs];
+ if (remote && branch) {
+ commands.splice(1, 0, remote, branch);
+ }
+ return {
+ commands,
+ format: "utf-8",
+ parser(stdOut, stdErr) {
+ return parsePullResult(stdOut, stdErr);
+ },
+ onError(result, _error, _done, fail) {
+ const pullError = parsePullErrorResult(bufferToString(result.stdOut), bufferToString(result.stdErr));
+ if (pullError) {
+ return fail(new GitResponseError(pullError));
+ }
+ fail(_error);
+ }
+ };
+}
+var init_pull = __esm({
+ "src/lib/tasks/pull.ts"() {
+ init_git_response_error();
+ init_parse_pull();
+ init_utils();
+ }
+});
+function parseGetRemotes(text2) {
+ const remotes = {};
+ forEach(text2, ([name]) => remotes[name] = { name });
+ return Object.values(remotes);
+}
+function parseGetRemotesVerbose(text2) {
+ const remotes = {};
+ forEach(text2, ([name, url, purpose]) => {
+ if (!remotes.hasOwnProperty(name)) {
+ remotes[name] = {
+ name,
+ refs: { fetch: "", push: "" }
+ };
+ }
+ if (purpose && url) {
+ remotes[name].refs[purpose.replace(/[^a-z]/g, "")] = url;
+ }
+ });
+ return Object.values(remotes);
+}
+function forEach(text2, handler) {
+ forEachLineWithContent(text2, (line) => handler(line.split(/\s+/)));
+}
+var init_GetRemoteSummary = __esm({
+ "src/lib/responses/GetRemoteSummary.ts"() {
+ init_utils();
+ }
+});
+var remote_exports = {};
+__export2(remote_exports, {
+ addRemoteTask: () => addRemoteTask,
+ getRemotesTask: () => getRemotesTask,
+ listRemotesTask: () => listRemotesTask,
+ remoteTask: () => remoteTask,
+ removeRemoteTask: () => removeRemoteTask
+});
+function addRemoteTask(remoteName, remoteRepo, customArgs = []) {
+ return straightThroughStringTask(["remote", "add", ...customArgs, remoteName, remoteRepo]);
+}
+function getRemotesTask(verbose) {
+ const commands = ["remote"];
+ if (verbose) {
+ commands.push("-v");
+ }
+ return {
+ commands,
+ format: "utf-8",
+ parser: verbose ? parseGetRemotesVerbose : parseGetRemotes
+ };
+}
+function listRemotesTask(customArgs = []) {
+ const commands = [...customArgs];
+ if (commands[0] !== "ls-remote") {
+ commands.unshift("ls-remote");
+ }
+ return straightThroughStringTask(commands);
+}
+function remoteTask(customArgs = []) {
+ const commands = [...customArgs];
+ if (commands[0] !== "remote") {
+ commands.unshift("remote");
+ }
+ return straightThroughStringTask(commands);
+}
+function removeRemoteTask(remoteName) {
+ return straightThroughStringTask(["remote", "remove", remoteName]);
+}
+var init_remote = __esm({
+ "src/lib/tasks/remote.ts"() {
+ init_GetRemoteSummary();
+ init_task();
+ }
+});
+var stash_list_exports = {};
+__export2(stash_list_exports, {
+ stashListTask: () => stashListTask
+});
+function stashListTask(opt = {}, customArgs) {
+ const options = parseLogOptions(opt);
+ const parser3 = createListLogSummaryParser(options.splitter, options.fields);
+ return {
+ commands: ["stash", "list", ...options.commands, ...customArgs],
+ format: "utf-8",
+ parser: parser3
+ };
+}
+var init_stash_list = __esm({
+ "src/lib/tasks/stash-list.ts"() {
+ init_parse_list_log_summary();
+ init_log();
+ }
+});
+var sub_module_exports = {};
+__export2(sub_module_exports, {
+ addSubModuleTask: () => addSubModuleTask,
+ initSubModuleTask: () => initSubModuleTask,
+ subModuleTask: () => subModuleTask,
+ updateSubModuleTask: () => updateSubModuleTask
+});
+function addSubModuleTask(repo, path3) {
+ return subModuleTask(["add", repo, path3]);
+}
+function initSubModuleTask(customArgs) {
+ return subModuleTask(["init", ...customArgs]);
+}
+function subModuleTask(customArgs) {
+ const commands = [...customArgs];
+ if (commands[0] !== "submodule") {
+ commands.unshift("submodule");
+ }
+ return straightThroughStringTask(commands);
+}
+function updateSubModuleTask(customArgs) {
+ return subModuleTask(["update", ...customArgs]);
+}
+var init_sub_module = __esm({
+ "src/lib/tasks/sub-module.ts"() {
+ init_task();
+ }
+});
+function singleSorted(a, b) {
+ const aIsNum = isNaN(a);
+ const bIsNum = isNaN(b);
+ if (aIsNum !== bIsNum) {
+ return aIsNum ? 1 : -1;
+ }
+ return aIsNum ? sorted(a, b) : 0;
+}
+function sorted(a, b) {
+ return a === b ? 0 : a > b ? 1 : -1;
+}
+function trimmed(input) {
+ return input.trim();
+}
+function toNumber(input) {
+ if (typeof input === "string") {
+ return parseInt(input.replace(/^\D+/g, ""), 10) || 0;
+ }
+ return 0;
+}
+var TagList;
+var parseTagList;
+var init_TagList = __esm({
+ "src/lib/responses/TagList.ts"() {
+ TagList = class {
+ constructor(all, latest) {
+ this.all = all;
+ this.latest = latest;
+ }
+ };
+ parseTagList = function(data, customSort = false) {
+ const tags = data.split("\n").map(trimmed).filter(Boolean);
+ if (!customSort) {
+ tags.sort(function(tagA, tagB) {
+ const partsA = tagA.split(".");
+ const partsB = tagB.split(".");
+ if (partsA.length === 1 || partsB.length === 1) {
+ return singleSorted(toNumber(partsA[0]), toNumber(partsB[0]));
+ }
+ for (let i = 0, l = Math.max(partsA.length, partsB.length); i < l; i++) {
+ const diff = sorted(toNumber(partsA[i]), toNumber(partsB[i]));
+ if (diff) {
+ return diff;
+ }
+ }
+ return 0;
+ });
+ }
+ const latest = customSort ? tags[0] : [...tags].reverse().find((tag) => tag.indexOf(".") >= 0);
+ return new TagList(tags, latest);
+ };
+ }
+});
+var tag_exports = {};
+__export2(tag_exports, {
+ addAnnotatedTagTask: () => addAnnotatedTagTask,
+ addTagTask: () => addTagTask,
+ tagListTask: () => tagListTask
+});
+function tagListTask(customArgs = []) {
+ const hasCustomSort = customArgs.some((option) => /^--sort=/.test(option));
+ return {
+ format: "utf-8",
+ commands: ["tag", "-l", ...customArgs],
+ parser(text2) {
+ return parseTagList(text2, hasCustomSort);
+ }
+ };
+}
+function addTagTask(name) {
+ return {
+ format: "utf-8",
+ commands: ["tag", name],
+ parser() {
+ return { name };
+ }
+ };
+}
+function addAnnotatedTagTask(name, tagMessage) {
+ return {
+ format: "utf-8",
+ commands: ["tag", "-a", "-m", tagMessage, name],
+ parser() {
+ return { name };
+ }
+ };
+}
+var init_tag = __esm({
+ "src/lib/tasks/tag.ts"() {
+ init_TagList();
+ }
+});
+var require_git = __commonJS2({
+ "src/git.js"(exports, module2) {
+ var { GitExecutor: GitExecutor2 } = (init_git_executor(), __toCommonJS(git_executor_exports));
+ var { SimpleGitApi: SimpleGitApi2 } = (init_simple_git_api(), __toCommonJS(simple_git_api_exports));
+ var { Scheduler: Scheduler2 } = (init_scheduler(), __toCommonJS(scheduler_exports));
+ var { configurationErrorTask: configurationErrorTask2 } = (init_task(), __toCommonJS(task_exports));
+ var {
+ asArray: asArray2,
+ filterArray: filterArray2,
+ filterPrimitives: filterPrimitives2,
+ filterString: filterString2,
+ filterStringOrStringArray: filterStringOrStringArray2,
+ filterType: filterType2,
+ getTrailingOptions: getTrailingOptions2,
+ trailingFunctionArgument: trailingFunctionArgument2,
+ trailingOptionsArgument: trailingOptionsArgument2
+ } = (init_utils(), __toCommonJS(utils_exports));
+ var { applyPatchTask: applyPatchTask2 } = (init_apply_patch(), __toCommonJS(apply_patch_exports));
+ var { branchTask: branchTask2, branchLocalTask: branchLocalTask2, deleteBranchesTask: deleteBranchesTask2, deleteBranchTask: deleteBranchTask2 } = (init_branch(), __toCommonJS(branch_exports));
+ var { checkIgnoreTask: checkIgnoreTask2 } = (init_check_ignore(), __toCommonJS(check_ignore_exports));
+ var { checkIsRepoTask: checkIsRepoTask2 } = (init_check_is_repo(), __toCommonJS(check_is_repo_exports));
+ var { cloneTask: cloneTask2, cloneMirrorTask: cloneMirrorTask2 } = (init_clone(), __toCommonJS(clone_exports));
+ var { cleanWithOptionsTask: cleanWithOptionsTask2, isCleanOptionsArray: isCleanOptionsArray2 } = (init_clean(), __toCommonJS(clean_exports));
+ var { commitTask: commitTask2 } = (init_commit(), __toCommonJS(commit_exports));
+ var { diffSummaryTask: diffSummaryTask2 } = (init_diff(), __toCommonJS(diff_exports));
+ var { fetchTask: fetchTask2 } = (init_fetch(), __toCommonJS(fetch_exports));
+ var { moveTask: moveTask2 } = (init_move(), __toCommonJS(move_exports));
+ var { pullTask: pullTask2 } = (init_pull(), __toCommonJS(pull_exports));
+ var { pushTagsTask: pushTagsTask2 } = (init_push(), __toCommonJS(push_exports));
+ var { addRemoteTask: addRemoteTask2, getRemotesTask: getRemotesTask2, listRemotesTask: listRemotesTask2, remoteTask: remoteTask2, removeRemoteTask: removeRemoteTask2 } = (init_remote(), __toCommonJS(remote_exports));
+ var { getResetMode: getResetMode2, resetTask: resetTask2 } = (init_reset(), __toCommonJS(reset_exports));
+ var { stashListTask: stashListTask2 } = (init_stash_list(), __toCommonJS(stash_list_exports));
+ var { addSubModuleTask: addSubModuleTask2, initSubModuleTask: initSubModuleTask2, subModuleTask: subModuleTask2, updateSubModuleTask: updateSubModuleTask2 } = (init_sub_module(), __toCommonJS(sub_module_exports));
+ var { addAnnotatedTagTask: addAnnotatedTagTask2, addTagTask: addTagTask2, tagListTask: tagListTask2 } = (init_tag(), __toCommonJS(tag_exports));
+ var { straightThroughBufferTask: straightThroughBufferTask2, straightThroughStringTask: straightThroughStringTask2 } = (init_task(), __toCommonJS(task_exports));
+ function Git2(options, plugins) {
+ this._executor = new GitExecutor2(options.binary, options.baseDir, new Scheduler2(options.maxConcurrentProcesses), plugins);
+ }
+ (Git2.prototype = Object.create(SimpleGitApi2.prototype)).constructor = Git2;
+ Git2.prototype.customBinary = function(command) {
+ this._executor.binary = command;
+ return this;
+ };
+ Git2.prototype.env = function(name, value) {
+ if (arguments.length === 1 && typeof name === "object") {
+ this._executor.env = name;
+ } else {
+ (this._executor.env = this._executor.env || {})[name] = value;
+ }
+ return this;
+ };
+ Git2.prototype.stashList = function(options) {
+ return this._runTask(stashListTask2(trailingOptionsArgument2(arguments) || {}, filterArray2(options) && options || []), trailingFunctionArgument2(arguments));
+ };
+ function createCloneTask(api, task, repoPath, localPath) {
+ if (typeof repoPath !== "string") {
+ return configurationErrorTask2(`git.${api}() requires a string 'repoPath'`);
+ }
+ return task(repoPath, filterType2(localPath, filterString2), getTrailingOptions2(arguments));
+ }
+ Git2.prototype.clone = function() {
+ return this._runTask(createCloneTask("clone", cloneTask2, ...arguments), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.mirror = function() {
+ return this._runTask(createCloneTask("mirror", cloneMirrorTask2, ...arguments), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.mv = function(from, to) {
+ return this._runTask(moveTask2(from, to), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.checkoutLatestTag = function(then) {
+ var git = this;
+ return this.pull(function() {
+ git.tags(function(err, tags) {
+ git.checkout(tags.latest, then);
+ });
+ });
+ };
+ Git2.prototype.pull = function(remote, branch, options, then) {
+ return this._runTask(pullTask2(filterType2(remote, filterString2), filterType2(branch, filterString2), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.fetch = function(remote, branch) {
+ return this._runTask(fetchTask2(filterType2(remote, filterString2), filterType2(branch, filterString2), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.silent = function(silence) {
+ console.warn("simple-git deprecation notice: git.silent: logging should be configured using the `debug` library / `DEBUG` environment variable, this will be an error in version 3");
+ return this;
+ };
+ Git2.prototype.tags = function(options, then) {
+ return this._runTask(tagListTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.rebase = function() {
+ return this._runTask(straightThroughStringTask2(["rebase", ...getTrailingOptions2(arguments)]), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.reset = function(mode) {
+ return this._runTask(resetTask2(getResetMode2(mode), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.revert = function(commit) {
+ const next = trailingFunctionArgument2(arguments);
+ if (typeof commit !== "string") {
+ return this._runTask(configurationErrorTask2("Commit must be a string"), next);
+ }
+ return this._runTask(straightThroughStringTask2(["revert", ...getTrailingOptions2(arguments, 0, true), commit]), next);
+ };
+ Git2.prototype.addTag = function(name) {
+ const task = typeof name === "string" ? addTagTask2(name) : configurationErrorTask2("Git.addTag requires a tag name");
+ return this._runTask(task, trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.addAnnotatedTag = function(tagName, tagMessage) {
+ return this._runTask(addAnnotatedTagTask2(tagName, tagMessage), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.checkout = function() {
+ const commands = ["checkout", ...getTrailingOptions2(arguments, true)];
+ return this._runTask(straightThroughStringTask2(commands), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.checkoutBranch = function(branchName, startPoint, then) {
+ return this.checkout(["-b", branchName, startPoint], trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.checkoutLocalBranch = function(branchName, then) {
+ return this.checkout(["-b", branchName], trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.deleteLocalBranch = function(branchName, forceDelete, then) {
+ return this._runTask(deleteBranchTask2(branchName, typeof forceDelete === "boolean" ? forceDelete : false), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.deleteLocalBranches = function(branchNames, forceDelete, then) {
+ return this._runTask(deleteBranchesTask2(branchNames, typeof forceDelete === "boolean" ? forceDelete : false), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.branch = function(options, then) {
+ return this._runTask(branchTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.branchLocal = function(then) {
+ return this._runTask(branchLocalTask2(), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.raw = function(commands) {
+ const createRestCommands = !Array.isArray(commands);
+ const command = [].slice.call(createRestCommands ? arguments : commands, 0);
+ for (let i = 0; i < command.length && createRestCommands; i++) {
+ if (!filterPrimitives2(command[i])) {
+ command.splice(i, command.length - i);
+ break;
+ }
+ }
+ command.push(...getTrailingOptions2(arguments, 0, true));
+ var next = trailingFunctionArgument2(arguments);
+ if (!command.length) {
+ return this._runTask(configurationErrorTask2("Raw: must supply one or more command to execute"), next);
+ }
+ return this._runTask(straightThroughStringTask2(command), next);
+ };
+ Git2.prototype.submoduleAdd = function(repo, path3, then) {
+ return this._runTask(addSubModuleTask2(repo, path3), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.submoduleUpdate = function(args, then) {
+ return this._runTask(updateSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.submoduleInit = function(args, then) {
+ return this._runTask(initSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.subModule = function(options, then) {
+ return this._runTask(subModuleTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.listRemote = function() {
+ return this._runTask(listRemotesTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.addRemote = function(remoteName, remoteRepo, then) {
+ return this._runTask(addRemoteTask2(remoteName, remoteRepo, getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.removeRemote = function(remoteName, then) {
+ return this._runTask(removeRemoteTask2(remoteName), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.getRemotes = function(verbose, then) {
+ return this._runTask(getRemotesTask2(verbose === true), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.remote = function(options, then) {
+ return this._runTask(remoteTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.tag = function(options, then) {
+ const command = getTrailingOptions2(arguments);
+ if (command[0] !== "tag") {
+ command.unshift("tag");
+ }
+ return this._runTask(straightThroughStringTask2(command), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.updateServerInfo = function(then) {
+ return this._runTask(straightThroughStringTask2(["update-server-info"]), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.pushTags = function(remote, then) {
+ const task = pushTagsTask2({ remote: filterType2(remote, filterString2) }, getTrailingOptions2(arguments));
+ return this._runTask(task, trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.rm = function(files) {
+ return this._runTask(straightThroughStringTask2(["rm", "-f", ...asArray2(files)]), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.rmKeepLocal = function(files) {
+ return this._runTask(straightThroughStringTask2(["rm", "--cached", ...asArray2(files)]), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.catFile = function(options, then) {
+ return this._catFile("utf-8", arguments);
+ };
+ Git2.prototype.binaryCatFile = function() {
+ return this._catFile("buffer", arguments);
+ };
+ Git2.prototype._catFile = function(format, args) {
+ var handler = trailingFunctionArgument2(args);
+ var command = ["cat-file"];
+ var options = args[0];
+ if (typeof options === "string") {
+ return this._runTask(configurationErrorTask2("Git.catFile: options must be supplied as an array of strings"), handler);
+ }
+ if (Array.isArray(options)) {
+ command.push.apply(command, options);
+ }
+ const task = format === "buffer" ? straightThroughBufferTask2(command) : straightThroughStringTask2(command);
+ return this._runTask(task, handler);
+ };
+ Git2.prototype.diff = function(options, then) {
+ const task = filterString2(options) ? configurationErrorTask2("git.diff: supplying options as a single string is no longer supported, switch to an array of strings") : straightThroughStringTask2(["diff", ...getTrailingOptions2(arguments)]);
+ return this._runTask(task, trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.diffSummary = function() {
+ return this._runTask(diffSummaryTask2(getTrailingOptions2(arguments, 1)), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.applyPatch = function(patches) {
+ const task = !filterStringOrStringArray2(patches) ? configurationErrorTask2(`git.applyPatch requires one or more string patches as the first argument`) : applyPatchTask2(asArray2(patches), getTrailingOptions2([].slice.call(arguments, 1)));
+ return this._runTask(task, trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.revparse = function() {
+ const commands = ["rev-parse", ...getTrailingOptions2(arguments, true)];
+ return this._runTask(straightThroughStringTask2(commands, true), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.show = function(options, then) {
+ return this._runTask(straightThroughStringTask2(["show", ...getTrailingOptions2(arguments, 1)]), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.clean = function(mode, options, then) {
+ const usingCleanOptionsArray = isCleanOptionsArray2(mode);
+ const cleanMode = usingCleanOptionsArray && mode.join("") || filterType2(mode, filterString2) || "";
+ const customArgs = getTrailingOptions2([].slice.call(arguments, usingCleanOptionsArray ? 1 : 0));
+ return this._runTask(cleanWithOptionsTask2(cleanMode, customArgs), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.exec = function(then) {
+ const task = {
+ commands: [],
+ format: "utf-8",
+ parser() {
+ if (typeof then === "function") {
+ then();
+ }
+ }
+ };
+ return this._runTask(task);
+ };
+ Git2.prototype.clearQueue = function() {
+ return this;
+ };
+ Git2.prototype.checkIgnore = function(pathnames, then) {
+ return this._runTask(checkIgnoreTask2(asArray2(filterType2(pathnames, filterStringOrStringArray2, []))), trailingFunctionArgument2(arguments));
+ };
+ Git2.prototype.checkIsRepo = function(checkType, then) {
+ return this._runTask(checkIsRepoTask2(filterType2(checkType, filterString2)), trailingFunctionArgument2(arguments));
+ };
+ module2.exports = Git2;
+ }
+});
+init_git_error();
+var GitConstructError = class extends GitError {
+ constructor(config, message) {
+ super(void 0, message);
+ this.config = config;
+ }
+};
+init_git_error();
+init_git_error();
+var GitPluginError = class extends GitError {
+ constructor(task, plugin, message) {
+ super(task, message);
+ this.task = task;
+ this.plugin = plugin;
+ Object.setPrototypeOf(this, new.target.prototype);
+ }
+};
+init_git_response_error();
+init_task_configuration_error();
+init_check_is_repo();
+init_clean();
+init_config();
+init_grep();
+init_reset();
+init_utils();
+function commandConfigPrefixingPlugin(configuration) {
+ const prefix = prefixedArray(configuration, "-c");
+ return {
+ type: "spawn.args",
+ action(data) {
+ return [...prefix, ...data];
+ }
+ };
+}
+init_utils();
+var never = (0, import_promise_deferred2.deferred)().promise;
+function completionDetectionPlugin({
+ onClose = true,
+ onExit = 50
+} = {}) {
+ function createEvents() {
+ let exitCode = -1;
+ const events = {
+ close: (0, import_promise_deferred2.deferred)(),
+ closeTimeout: (0, import_promise_deferred2.deferred)(),
+ exit: (0, import_promise_deferred2.deferred)(),
+ exitTimeout: (0, import_promise_deferred2.deferred)()
+ };
+ const result = Promise.race([
+ onClose === false ? never : events.closeTimeout.promise,
+ onExit === false ? never : events.exitTimeout.promise
+ ]);
+ configureTimeout(onClose, events.close, events.closeTimeout);
+ configureTimeout(onExit, events.exit, events.exitTimeout);
+ return {
+ close(code) {
+ exitCode = code;
+ events.close.done();
+ },
+ exit(code) {
+ exitCode = code;
+ events.exit.done();
+ },
+ get exitCode() {
+ return exitCode;
+ },
+ result
+ };
+ }
+ function configureTimeout(flag, event, timeout) {
+ if (flag === false) {
+ return;
+ }
+ (flag === true ? event.promise : event.promise.then(() => delay(flag))).then(timeout.done);
+ }
+ return {
+ type: "spawn.after",
+ action(_0, _1) {
+ return __async2(this, arguments, function* (_data, { spawned, close }) {
+ var _a2, _b;
+ const events = createEvents();
+ let deferClose = true;
+ let quickClose = () => void (deferClose = false);
+ (_a2 = spawned.stdout) == null ? void 0 : _a2.on("data", quickClose);
+ (_b = spawned.stderr) == null ? void 0 : _b.on("data", quickClose);
+ spawned.on("error", quickClose);
+ spawned.on("close", (code) => events.close(code));
+ spawned.on("exit", (code) => events.exit(code));
+ try {
+ yield events.result;
+ if (deferClose) {
+ yield delay(50);
+ }
+ close(events.exitCode);
+ } catch (err) {
+ close(events.exitCode, err);
+ }
+ });
+ }
+ };
+}
+init_git_error();
+function isTaskError(result) {
+ return !!(result.exitCode && result.stdErr.length);
+}
+function getErrorMessage(result) {
+ return Buffer.concat([...result.stdOut, ...result.stdErr]);
+}
+function errorDetectionHandler(overwrite = false, isError = isTaskError, errorMessage = getErrorMessage) {
+ return (error, result) => {
+ if (!overwrite && error || !isError(result)) {
+ return error;
+ }
+ return errorMessage(result);
+ };
+}
+function errorDetectionPlugin(config) {
+ return {
+ type: "task.error",
+ action(data, context) {
+ const error = config(data.error, {
+ stdErr: context.stdErr,
+ stdOut: context.stdOut,
+ exitCode: context.exitCode
+ });
+ if (Buffer.isBuffer(error)) {
+ return { error: new GitError(void 0, error.toString("utf-8")) };
+ }
+ return {
+ error
+ };
+ }
+ };
+}
+init_utils();
+var PluginStore = class {
+ constructor() {
+ this.plugins = /* @__PURE__ */ new Set();
+ }
+ add(plugin) {
+ const plugins = [];
+ asArray(plugin).forEach((plugin2) => plugin2 && this.plugins.add(append(plugins, plugin2)));
+ return () => {
+ plugins.forEach((plugin2) => this.plugins.delete(plugin2));
+ };
+ }
+ exec(type, data, context) {
+ let output = data;
+ const contextual = Object.freeze(Object.create(context));
+ for (const plugin of this.plugins) {
+ if (plugin.type === type) {
+ output = plugin.action(output, contextual);
+ }
+ }
+ return output;
+ }
+};
+init_utils();
+function progressMonitorPlugin(progress) {
+ const progressCommand = "--progress";
+ const progressMethods = ["checkout", "clone", "fetch", "pull", "push"];
+ const onProgress = {
+ type: "spawn.after",
+ action(_data, context) {
+ var _a2;
+ if (!context.commands.includes(progressCommand)) {
+ return;
+ }
+ (_a2 = context.spawned.stderr) == null ? void 0 : _a2.on("data", (chunk) => {
+ const message = /^([\s\S]+?):\s*(\d+)% \((\d+)\/(\d+)\)/.exec(chunk.toString("utf8"));
+ if (!message) {
+ return;
+ }
+ progress({
+ method: context.method,
+ stage: progressEventStage(message[1]),
+ progress: asNumber(message[2]),
+ processed: asNumber(message[3]),
+ total: asNumber(message[4])
+ });
+ });
+ }
+ };
+ const onArgs = {
+ type: "spawn.args",
+ action(args, context) {
+ if (!progressMethods.includes(context.method)) {
+ return args;
+ }
+ return including(args, progressCommand);
+ }
+ };
+ return [onArgs, onProgress];
+}
+function progressEventStage(input) {
+ return String(input.toLowerCase().split(" ", 1)) || "unknown";
+}
+init_utils();
+function spawnOptionsPlugin(spawnOptions) {
+ const options = pick(spawnOptions, ["uid", "gid"]);
+ return {
+ type: "spawn.options",
+ action(data) {
+ return __spreadValues2(__spreadValues2({}, options), data);
+ }
+ };
+}
+function timeoutPlugin({ block }) {
+ if (block > 0) {
+ return {
+ type: "spawn.after",
+ action(_data, context) {
+ var _a2, _b;
+ let timeout;
+ function wait3() {
+ timeout && clearTimeout(timeout);
+ timeout = setTimeout(kill, block);
+ }
+ function stop() {
+ var _a3, _b2;
+ (_a3 = context.spawned.stdout) == null ? void 0 : _a3.off("data", wait3);
+ (_b2 = context.spawned.stderr) == null ? void 0 : _b2.off("data", wait3);
+ context.spawned.off("exit", stop);
+ context.spawned.off("close", stop);
+ timeout && clearTimeout(timeout);
+ }
+ function kill() {
+ stop();
+ context.kill(new GitPluginError(void 0, "timeout", `block timeout reached`));
+ }
+ (_a2 = context.spawned.stdout) == null ? void 0 : _a2.on("data", wait3);
+ (_b = context.spawned.stderr) == null ? void 0 : _b.on("data", wait3);
+ context.spawned.on("exit", stop);
+ context.spawned.on("close", stop);
+ wait3();
+ }
+ };
+ }
+}
+init_utils();
+var Git = require_git();
+function gitInstanceFactory(baseDir, options) {
+ const plugins = new PluginStore();
+ const config = createInstanceConfig(baseDir && (typeof baseDir === "string" ? { baseDir } : baseDir) || {}, options);
+ if (!folderExists(config.baseDir)) {
+ throw new GitConstructError(config, `Cannot use simple-git on a directory that does not exist`);
+ }
+ if (Array.isArray(config.config)) {
+ plugins.add(commandConfigPrefixingPlugin(config.config));
+ }
+ plugins.add(completionDetectionPlugin(config.completion));
+ config.progress && plugins.add(progressMonitorPlugin(config.progress));
+ config.timeout && plugins.add(timeoutPlugin(config.timeout));
+ config.spawnOptions && plugins.add(spawnOptionsPlugin(config.spawnOptions));
+ plugins.add(errorDetectionPlugin(errorDetectionHandler(true)));
+ config.errors && plugins.add(errorDetectionPlugin(config.errors));
+ return new Git(config, plugins);
+}
+init_git_response_error();
+var esm_default = gitInstanceFactory;
+
+// src/gitManager.ts
+var GitManager = class {
+ constructor(plugin) {
+ this.plugin = plugin;
+ this.app = plugin.app;
+ }
+ getTreeStructure(children2, beginLength = 0) {
+ let list = [];
+ children2 = [...children2];
+ while (children2.length > 0) {
+ const first2 = children2.first();
+ const restPath = first2.path.substring(beginLength);
+ if (restPath.contains("/")) {
+ const title = restPath.substring(0, restPath.indexOf("/"));
+ const childrenWithSameTitle = children2.filter((item) => {
+ return item.path.substring(beginLength).startsWith(title + "/");
+ });
+ childrenWithSameTitle.forEach((item) => children2.remove(item));
+ list.push({
+ title,
+ children: this.getTreeStructure(childrenWithSameTitle, (beginLength > 0 ? beginLength + title.length : title.length) + 1)
+ });
+ } else {
+ list.push({ title: restPath, statusResult: first2 });
+ children2.remove(first2);
+ }
+ }
+ return list;
+ }
+ formatCommitMessage(template) {
+ return __async(this, null, function* () {
+ let status;
+ if (template.includes("{{numFiles}}")) {
+ status = yield this.status();
+ let numFiles = status.staged.length;
+ template = template.replace("{{numFiles}}", String(numFiles));
+ }
+ if (template.includes("{{hostname}}")) {
+ const hostname = localStorage.getItem(this.plugin.manifest.id + ":hostname") || "";
+ template = template.replace("{{hostname}}", hostname);
+ }
+ if (template.includes("{{files}}")) {
+ status = status != null ? status : yield this.status();
+ let changeset = {};
+ status.staged.forEach((value) => {
+ if (value.index in changeset) {
+ changeset[value.index].push(value.path);
+ } else {
+ changeset[value.index] = [value.path];
+ }
+ });
+ let chunks = [];
+ for (let [action, files2] of Object.entries(changeset)) {
+ chunks.push(action + " " + files2.join(" "));
+ }
+ let files = chunks.join(", ");
+ template = template.replace("{{files}}", files);
+ }
+ let moment = window.moment;
+ template = template.replace("{{date}}", moment().format(this.plugin.settings.commitDateFormat));
+ if (this.plugin.settings.listChangedFilesInMessageBody) {
+ template = template + "\n\nAffected files:\n" + (status != null ? status : yield this.status()).staged.map((e) => e.path).join("\n");
+ }
+ return template;
+ });
+ }
+};
+
+// src/simpleGit.ts
+var SimpleGit = class extends GitManager {
+ constructor(plugin) {
+ super(plugin);
+ }
+ setGitInstance(ignoreError = false) {
+ return __async(this, null, function* () {
+ if (this.isGitInstalled()) {
+ const adapter = this.app.vault.adapter;
+ const path3 = adapter.getBasePath();
+ let basePath = path3;
+ if (this.plugin.settings.basePath) {
+ const exists2 = yield adapter.exists((0, import_obsidian6.normalizePath)(this.plugin.settings.basePath));
+ if (exists2) {
+ basePath = path3 + import_path.sep + this.plugin.settings.basePath;
+ } else if (!ignoreError) {
+ new import_obsidian6.Notice("ObsidianGit: Base path does not exist");
+ }
+ }
+ this.git = esm_default({
+ baseDir: basePath,
+ binary: this.plugin.settings.gitPath || void 0,
+ config: ["core.quotepath=off"]
+ });
+ this.git.cwd(yield this.git.revparse("--show-toplevel"));
+ }
+ });
+ }
+ status() {
+ return __async(this, null, function* () {
+ this.plugin.setState(PluginState.status);
+ const status = yield this.git.status((err) => this.onError(err));
+ this.plugin.setState(PluginState.idle);
+ return {
+ changed: status.files.filter((e) => e.working_dir !== " ").map((e) => {
+ const res = this.formatPath(e);
+ return {
+ path: res.path,
+ from: res.from,
+ working_dir: e.working_dir === "?" ? "U" : e.working_dir,
+ vault_path: this.getVaultPath(res.path)
+ };
+ }),
+ staged: status.files.filter((e) => e.index !== " " && e.index != "?").map((e) => {
+ const res = this.formatPath(e, e.index === "R");
+ return {
+ path: res.path,
+ from: res.from,
+ index: e.index,
+ vault_path: this.getVaultPath(res.path)
+ };
+ }),
+ conflicted: status.conflicted.map((e) => this.formatPath({
+ path: e,
+ from: void 0,
+ index: void 0,
+ working_dir: void 0
+ }).path)
+ };
+ });
+ }
+ getVaultPath(path3) {
+ if (this.plugin.settings.basePath) {
+ return this.plugin.settings.basePath + "/" + path3;
+ } else {
+ return path3;
+ }
+ }
+ formatPath(path3, renamed = false) {
+ function format(path4) {
+ if (path4 == void 0)
+ return void 0;
+ if (path4.startsWith('"') && path4.endsWith('"')) {
+ return path4.substring(1, path4.length - 1);
+ } else {
+ return path4;
+ }
+ }
+ if (renamed) {
+ return {
+ from: format(path3.from),
+ path: format(path3.path)
+ };
+ } else {
+ return {
+ path: format(path3.path)
+ };
+ }
+ }
+ commitAll(message) {
+ return __async(this, null, function* () {
+ if (this.plugin.settings.updateSubmodules) {
+ this.plugin.setState(PluginState.commit);
+ yield new Promise((resolve, reject) => __async(this, null, function* () {
+ this.git.outputHandler((cmd, stdout, stderr, args) => __async(this, null, function* () {
+ if (!(args.contains("submodule") && args.contains("foreach")))
+ return;
+ let body = "";
+ let root = this.app.vault.adapter.getBasePath() + (this.plugin.settings.basePath ? "/" + this.plugin.settings.basePath : "");
+ stdout.on("data", (chunk) => {
+ body += chunk.toString("utf8");
+ });
+ stdout.on("end", () => __async(this, null, function* () {
+ let submods = body.split("\n");
+ submods = submods.map((i) => {
+ let submod = i.match(/'([^']*)'/);
+ if (submod != void 0) {
+ return root + "/" + submod[1] + import_path.sep;
+ }
+ });
+ submods.reverse();
+ for (const item of submods) {
+ if (item != void 0) {
+ yield this.git.cwd({ path: item, root: false }).add("-A", (err) => this.onError(err));
+ yield this.git.cwd({ path: item, root: false }).commit(yield this.formatCommitMessage(message), (err) => this.onError(err));
+ }
+ }
+ resolve();
+ }));
+ }));
+ yield this.git.subModule(["foreach", "--recursive", ""]);
+ this.git.outputHandler(() => {
+ });
+ }));
+ }
+ this.plugin.setState(PluginState.add);
+ yield this.git.add("-A", (err) => this.onError(err));
+ this.plugin.setState(PluginState.commit);
+ return (yield this.git.commit(yield this.formatCommitMessage(message), (err) => this.onError(err))).summary.changes;
+ });
+ }
+ commit(message) {
+ return __async(this, null, function* () {
+ this.plugin.setState(PluginState.commit);
+ const res = (yield this.git.commit(yield this.formatCommitMessage(message), (err) => this.onError(err))).summary.changes;
+ this.plugin.setState(PluginState.idle);
+ return res;
+ });
+ }
+ stage(filepath) {
+ return __async(this, null, function* () {
+ this.plugin.setState(PluginState.add);
+ yield this.git.add(["--", filepath], (err) => this.onError(err));
+ this.plugin.setState(PluginState.idle);
+ });
+ }
+ stageAll() {
+ return __async(this, null, function* () {
+ this.plugin.setState(PluginState.add);
+ yield this.git.add("-A", (err) => this.onError(err));
+ this.plugin.setState(PluginState.idle);
+ });
+ }
+ unstageAll() {
+ return __async(this, null, function* () {
+ this.plugin.setState(PluginState.add);
+ yield this.git.reset([], (err) => this.onError(err));
+ this.plugin.setState(PluginState.idle);
+ });
+ }
+ unstage(filepath) {
+ return __async(this, null, function* () {
+ this.plugin.setState(PluginState.add);
+ yield this.git.reset(["--", filepath], (err) => this.onError(err));
+ this.plugin.setState(PluginState.idle);
+ });
+ }
+ discard(filepath) {
+ return __async(this, null, function* () {
+ this.plugin.setState(PluginState.add);
+ yield this.git.checkout(["--", filepath], (err) => this.onError(err));
+ this.plugin.setState(PluginState.idle);
+ });
+ }
+ pull() {
+ return __async(this, null, function* () {
+ this.plugin.setState(PluginState.pull);
+ if (this.plugin.settings.updateSubmodules)
+ yield this.git.subModule(["update", "--remote", "--merge", "--recursive"], (err) => this.onError(err));
+ const branchInfo = yield this.branchInfo();
+ const localCommit = yield this.git.revparse([branchInfo.current], (err) => this.onError(err));
+ yield this.git.fetch((err) => this.onError(err));
+ const upstreamCommit = yield this.git.revparse([branchInfo.tracking], (err) => this.onError(err));
+ if (localCommit !== upstreamCommit) {
+ if (this.plugin.settings.syncMethod === "merge" || this.plugin.settings.syncMethod === "rebase") {
+ try {
+ switch (this.plugin.settings.syncMethod) {
+ case "merge":
+ yield this.git.merge([branchInfo.tracking]);
+ break;
+ case "rebase":
+ yield this.git.rebase([branchInfo.tracking]);
+ }
+ } catch (err) {
+ this.plugin.displayError(`Pull failed (${this.plugin.settings.syncMethod}): ${err.message}`);
+ return;
+ }
+ } else if (this.plugin.settings.syncMethod === "reset") {
+ try {
+ yield this.git.raw(["update-ref", `refs/heads/${branchInfo.current}`, upstreamCommit], (err) => this.onError(err));
+ yield this.unstageAll();
+ } catch (err) {
+ this.plugin.displayError(`Sync failed (${this.plugin.settings.syncMethod}): ${err.message}`);
+ }
+ }
+ const afterMergeCommit = yield this.git.revparse([branchInfo.current], (err) => this.onError(err));
+ const filesChanged = yield this.git.diff([`${localCommit}..${afterMergeCommit}`, "--name-only"]);
+ return filesChanged.split(/\r\n|\r|\n/).filter((value) => value.length > 0).length;
+ } else {
+ return 0;
+ }
+ });
+ }
+ push() {
+ return __async(this, null, function* () {
+ this.plugin.setState(PluginState.status);
+ const status = yield this.git.status();
+ const trackingBranch = status.tracking;
+ const currentBranch = status.current;
+ const remoteChangedFiles = (yield this.git.diffSummary([currentBranch, trackingBranch], (err) => this.onError(err))).changed;
+ this.plugin.setState(PluginState.push);
+ if (this.plugin.settings.updateSubmodules) {
+ yield this.git.env(__spreadProps(__spreadValues({}, 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) => this.onError(err));
+ }
+ yield this.git.env(__spreadProps(__spreadValues({}, process.env), { "OBSIDIAN_GIT": 1 })).push((err) => this.onError(err));
+ return remoteChangedFiles;
+ });
+ }
+ canPush() {
+ return __async(this, null, function* () {
+ if (this.plugin.settings.updateSubmodules === true) {
+ return true;
+ }
+ const status = yield this.git.status((err) => this.onError(err));
+ const trackingBranch = status.tracking;
+ const currentBranch = status.current;
+ const remoteChangedFiles = (yield this.git.diffSummary([currentBranch, trackingBranch])).changed;
+ return remoteChangedFiles !== 0;
+ });
+ }
+ checkRequirements() {
+ return __async(this, null, function* () {
+ if (!this.isGitInstalled()) {
+ return "missing-git";
+ }
+ if (!(yield this.git.checkIsRepo())) {
+ return "missing-repo";
+ }
+ return "valid";
+ });
+ }
+ branchInfo() {
+ return __async(this, null, function* () {
+ const status = yield this.git.status((err) => this.onError(err));
+ const branches = yield this.git.branch(["--no-color"], (err) => this.onError(err));
+ return {
+ current: status.current,
+ tracking: status.tracking,
+ branches: branches.all
+ };
+ });
+ }
+ log(file, relativeToRepo = false) {
+ return __async(this, null, function* () {
+ const path3 = relativeToRepo && this.plugin.settings.basePath ? file : file == null ? void 0 : file.substring(this.plugin.settings.basePath.length + 1);
+ const res = yield this.git.log({ file: path3 }, (err) => this.onError(err));
+ return res.all;
+ });
+ }
+ show(commitHash, file, relativeToRepo = false) {
+ return __async(this, null, function* () {
+ const path3 = relativeToRepo && this.plugin.settings.basePath ? file : file.substring(this.plugin.settings.basePath.length + 1);
+ return this.git.show([commitHash + ":" + path3], (err) => this.onError(err));
+ });
+ }
+ checkout(branch) {
+ return __async(this, null, function* () {
+ yield this.git.checkout(branch, (err) => this.onError(err));
+ });
+ }
+ init() {
+ return __async(this, null, function* () {
+ yield this.git.init(false, (err) => this.onError(err));
+ });
+ }
+ clone(url, dir) {
+ return __async(this, null, function* () {
+ yield this.git.clone(url, path.join(this.app.vault.adapter.getBasePath(), dir), [], (err) => this.onError(err));
+ });
+ }
+ setConfig(path3, value) {
+ return __async(this, null, function* () {
+ yield this.git.addConfig(path3, value, (err) => this.onError(err));
+ });
+ }
+ getConfig(path3) {
+ return __async(this, null, function* () {
+ const config = yield this.git.listConfig((err) => this.onError(err));
+ return config.all[path3];
+ });
+ }
+ fetch(remote) {
+ return __async(this, null, function* () {
+ yield this.git.fetch(remote != void 0 ? [remote] : [], (err) => this.onError(err));
+ });
+ }
+ setRemote(name, url) {
+ return __async(this, null, function* () {
+ if ((yield this.getRemotes()).includes(name))
+ yield this.git.remote(["set-url", name, url], (err) => this.onError(err));
+ else {
+ yield this.git.remote(["add", name, url], (err) => this.onError(err));
+ }
+ });
+ }
+ getRemoteBranches(remote) {
+ return __async(this, null, function* () {
+ const res = yield this.git.branch(["-r", "--list", `${remote}*`], (err) => this.onError(err));
+ const list = [];
+ for (var item in res.branches) {
+ list.push(res.branches[item].name);
+ }
+ return list;
+ });
+ }
+ getRemotes() {
+ return __async(this, null, function* () {
+ const res = yield this.git.remote([], (err) => this.onError(err));
+ if (res) {
+ return res.trim().split("\n");
+ } else {
+ return [];
+ }
+ });
+ }
+ removeRemote(remoteName) {
+ return __async(this, null, function* () {
+ yield this.git.removeRemote(remoteName);
+ });
+ }
+ updateUpstreamBranch(remoteBranch) {
+ return __async(this, null, function* () {
+ yield this.git.push(["--set-upstream", ...remoteBranch.split("/")], (err) => this.onError(err));
+ });
+ }
+ updateGitPath(gitPath) {
+ this.setGitInstance();
+ }
+ updateBasePath(basePath) {
+ this.setGitInstance(true);
+ }
+ getDiffString(filePath, stagedChanges = false) {
+ return __async(this, null, function* () {
+ if (stagedChanges)
+ return yield this.git.diff(["--cached", "--", filePath]);
+ else
+ return yield this.git.diff(["--", filePath]);
+ });
+ }
+ diff(file, commit1, commit2) {
+ return __async(this, null, function* () {
+ return yield this.git.diff([`${commit1}..${commit2}`, "--", file]);
+ });
+ }
+ isGitInstalled() {
+ const command = (0, import_child_process2.spawnSync)(this.plugin.settings.gitPath || "git", ["--version"], {
+ stdio: "ignore"
+ });
+ if (command.error) {
+ console.error(command.error);
+ return false;
+ }
+ return true;
+ }
+ onError(error) {
+ if (error) {
+ let networkFailure = error.message.contains("Could not resolve host");
+ if (!networkFailure) {
+ this.plugin.displayError(error.message);
+ this.plugin.setState(PluginState.idle);
+ } else if (!this.plugin.offlineMode) {
+ this.plugin.displayError("Git: Going into offline mode. Future network errors will no longer be displayed.", 2e3);
+ }
+ if (networkFailure) {
+ this.plugin.offlineMode = true;
+ this.plugin.setState(PluginState.idle);
+ }
+ }
+ }
+};
+
+// src/ui/diff/diffView.ts
+var import_diff2html = __toModule(require_diff2html());
+var import_obsidian7 = __toModule(require("obsidian"));
+var DiffView = class extends import_obsidian7.ItemView {
+ constructor(leaf, plugin) {
+ super(leaf);
+ this.plugin = plugin;
+ this.gettingDiff = false;
+ this.parser = new DOMParser();
+ addEventListener("git-refresh", this.refresh.bind(this));
+ }
+ getViewType() {
+ return DIFF_VIEW_CONFIG.type;
+ }
+ getDisplayText() {
+ return DIFF_VIEW_CONFIG.name;
+ }
+ getIcon() {
+ return DIFF_VIEW_CONFIG.icon;
+ }
+ setState(state, result) {
+ return __async(this, null, function* () {
+ this.state = state;
+ yield this.refresh();
+ return;
+ });
+ }
+ getState() {
+ return this.state;
+ }
+ onClose() {
+ removeEventListener("git-refresh", this.refresh.bind(this));
+ return super.onClose();
+ }
+ onOpen() {
+ this.refresh();
+ return super.onOpen();
+ }
+ refresh() {
+ return __async(this, null, function* () {
+ var _a2;
+ if (((_a2 = this.state) == null ? void 0 : _a2.file) && !this.gettingDiff && this.plugin.gitManager) {
+ this.gettingDiff = true;
+ const diff = this.parser.parseFromString((0, import_diff2html.html)(yield this.plugin.gitManager.getDiffString(this.state.file, this.state.staged)), "text/html").querySelector(".d2h-file-diff");
+ this.contentEl.empty();
+ if (diff) {
+ this.contentEl.append(diff);
+ } else {
+ const div = this.contentEl.createDiv({ cls: "diff-err" });
+ div.createSpan({ text: "\u26A0\uFE0F", cls: "diff-err-sign" });
+ div.createEl("br");
+ div.createSpan({ text: "No changes to " + this.state.file });
+ }
+ this.gettingDiff = false;
+ }
+ });
+ }
+};
+
+// src/ui/modals/generalModal.ts
+var import_obsidian8 = __toModule(require("obsidian"));
+var GeneralModal = class extends import_obsidian8.SuggestModal {
+ constructor(app2, remotes, placeholder) {
+ super(app2);
+ this.resolve = null;
+ this.list = remotes;
+ this.setPlaceholder(placeholder);
+ }
+ open() {
+ super.open();
+ return new Promise((resolve) => {
+ this.resolve = resolve;
+ });
+ }
+ selectSuggestion(value, evt) {
+ if (this.resolve)
+ this.resolve(value);
+ super.selectSuggestion(value, evt);
+ }
+ onClose() {
+ if (this.resolve)
+ this.resolve(void 0);
+ }
+ getSuggestions(query) {
+ return [query.length > 0 ? query : "...", ...this.list];
+ }
+ renderSuggestion(value, el) {
+ el.innerText = value;
+ }
+ onChooseSuggestion(item, _) {
+ }
+};
+
+// src/ui/sidebar/sidebarView.ts
+var import_obsidian14 = __toModule(require("obsidian"));
+
+// node_modules/svelte/internal/index.mjs
+function noop() {
+}
+var identity = (x) => x;
+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;
+}
+var is_client = typeof window !== "undefined";
+var now = is_client ? () => window.performance.now() : () => Date.now();
+var raf = is_client ? (cb) => requestAnimationFrame(cb) : noop;
+var tasks = new Set();
+function run_tasks(now2) {
+ tasks.forEach((task) => {
+ if (!task.c(now2)) {
+ tasks.delete(task);
+ task.f();
+ }
+ });
+ if (tasks.size !== 0)
+ raf(run_tasks);
+}
+function loop(callback) {
+ let task;
+ if (tasks.size === 0)
+ raf(run_tasks);
+ return {
+ promise: new Promise((fulfill) => {
+ tasks.add(task = { c: callback, f: fulfill });
+ }),
+ abort() {
+ tasks.delete(task);
+ }
+ };
+}
+var is_hydrating = false;
+function start_hydrating() {
+ is_hydrating = true;
+}
+function end_hydrating() {
+ is_hydrating = false;
+}
+function append2(target, node) {
+ target.appendChild(node);
+}
+function append_styles(target, style_sheet_id, styles) {
+ const append_styles_to = get_root_for_style(target);
+ if (!append_styles_to.getElementById(style_sheet_id)) {
+ const style = element("style");
+ style.id = style_sheet_id;
+ style.textContent = styles;
+ append_stylesheet(append_styles_to, style);
+ }
+}
+function get_root_for_style(node) {
+ if (!node)
+ return document;
+ const root = node.getRootNode ? node.getRootNode() : node.ownerDocument;
+ if (root && root.host) {
+ return root;
+ }
+ return node.ownerDocument;
+}
+function append_empty_stylesheet(node) {
+ const style_element = element("style");
+ append_stylesheet(get_root_for_style(node), style_element);
+ return style_element.sheet;
+}
+function append_stylesheet(node, style) {
+ append2(node.head || node, style);
+}
+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 text(data) {
+ return document.createTextNode(data);
+}
+function space() {
+ return text(" ");
+}
+function empty() {
+ return text("");
+}
+function listen(node, event, handler, options) {
+ node.addEventListener(event, handler, options);
+ return () => node.removeEventListener(event, handler, options);
+}
+function self2(fn) {
+ return function(event) {
+ if (event.target === this)
+ fn.call(this, event);
+ };
+}
+function attr(node, attribute, value) {
+ if (value == null)
+ node.removeAttribute(attribute);
+ else if (node.getAttribute(attribute) !== value)
+ node.setAttribute(attribute, value);
+}
+function children(element2) {
+ return Array.from(element2.childNodes);
+}
+function set_data(text2, data) {
+ data = "" + data;
+ if (text2.wholeText !== data)
+ text2.data = data;
+}
+function set_input_value(input, value) {
+ input.value = value == null ? "" : value;
+}
+function toggle_class(element2, name, toggle) {
+ element2.classList[toggle ? "add" : "remove"](name);
+}
+function custom_event(type, detail, { bubbles = false, cancelable = false } = {}) {
+ const e = document.createEvent("CustomEvent");
+ e.initCustomEvent(type, bubbles, cancelable, detail);
+ return e;
+}
+var managed_styles = new Map();
+var active = 0;
+function hash(str) {
+ let hash2 = 5381;
+ let i = str.length;
+ while (i--)
+ hash2 = (hash2 << 5) - hash2 ^ str.charCodeAt(i);
+ return hash2 >>> 0;
+}
+function create_style_information(doc, node) {
+ const info = { stylesheet: append_empty_stylesheet(node), rules: {} };
+ managed_styles.set(doc, info);
+ return info;
+}
+function create_rule(node, a, b, duration, delay2, ease, fn, uid = 0) {
+ const step = 16.666 / duration;
+ let keyframes = "{\n";
+ for (let p = 0; p <= 1; p += step) {
+ const t = a + (b - a) * ease(p);
+ keyframes += p * 100 + `%{${fn(t, 1 - t)}}
+`;
+ }
+ const rule = keyframes + `100% {${fn(b, 1 - b)}}
+}`;
+ const name = `__svelte_${hash(rule)}_${uid}`;
+ const doc = get_root_for_style(node);
+ const { stylesheet, rules } = managed_styles.get(doc) || create_style_information(doc, node);
+ if (!rules[name]) {
+ rules[name] = true;
+ stylesheet.insertRule(`@keyframes ${name} ${rule}`, stylesheet.cssRules.length);
+ }
+ const animation = node.style.animation || "";
+ node.style.animation = `${animation ? `${animation}, ` : ""}${name} ${duration}ms linear ${delay2}ms 1 both`;
+ active += 1;
+ return name;
+}
+function delete_rule(node, name) {
+ const previous = (node.style.animation || "").split(", ");
+ const next = previous.filter(name ? (anim) => anim.indexOf(name) < 0 : (anim) => anim.indexOf("__svelte") === -1);
+ const deleted = previous.length - next.length;
+ if (deleted) {
+ node.style.animation = next.join(", ");
+ active -= deleted;
+ if (!active)
+ clear_rules();
+ }
+}
+function clear_rules() {
+ raf(() => {
+ if (active)
+ return;
+ managed_styles.forEach((info) => {
+ const { stylesheet } = info;
+ let i = stylesheet.cssRules.length;
+ while (i--)
+ stylesheet.deleteRule(i);
+ info.rules = {};
+ });
+ managed_styles.clear();
+ });
+}
+var current_component;
+function set_current_component(component) {
+ current_component = component;
+}
+function get_current_component() {
+ if (!current_component)
+ throw new Error("Function called outside component initialization");
+ return current_component;
+}
+function onDestroy(fn) {
+ get_current_component().$$.on_destroy.push(fn);
+}
+function bubble(component, event) {
+ const callbacks = component.$$.callbacks[event.type];
+ if (callbacks) {
+ callbacks.slice().forEach((fn) => fn.call(this, event));
+ }
+}
+var dirty_components = [];
+var binding_callbacks = [];
+var render_callbacks = [];
+var flush_callbacks = [];
+var resolved_promise = Promise.resolve();
+var 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);
+}
+var seen_callbacks = new Set();
+var flushidx = 0;
+function flush() {
+ const saved_component = current_component;
+ do {
+ while (flushidx < dirty_components.length) {
+ const component = dirty_components[flushidx];
+ flushidx++;
+ set_current_component(component);
+ update(component.$$);
+ }
+ set_current_component(null);
+ dirty_components.length = 0;
+ flushidx = 0;
+ while (binding_callbacks.length)
+ binding_callbacks.pop()();
+ for (let i = 0; i < render_callbacks.length; i += 1) {
+ const callback = render_callbacks[i];
+ if (!seen_callbacks.has(callback)) {
+ seen_callbacks.add(callback);
+ callback();
+ }
+ }
+ render_callbacks.length = 0;
+ } while (dirty_components.length);
+ while (flush_callbacks.length) {
+ flush_callbacks.pop()();
+ }
+ update_scheduled = false;
+ seen_callbacks.clear();
+ set_current_component(saved_component);
+}
+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);
+ }
+}
+var promise;
+function wait() {
+ if (!promise) {
+ promise = Promise.resolve();
+ promise.then(() => {
+ promise = null;
+ });
+ }
+ return promise;
+}
+function dispatch(node, direction, kind) {
+ node.dispatchEvent(custom_event(`${direction ? "intro" : "outro"}${kind}`));
+}
+var outroing = new Set();
+var outros;
+function group_outros() {
+ outros = {
+ r: 0,
+ c: [],
+ p: outros
+ };
+}
+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, detach2, callback) {
+ if (block && block.o) {
+ if (outroing.has(block))
+ return;
+ outroing.add(block);
+ outros.c.push(() => {
+ outroing.delete(block);
+ if (callback) {
+ if (detach2)
+ block.d(1);
+ callback();
+ }
+ });
+ block.o(local);
+ }
+}
+var null_transition = { duration: 0 };
+function create_bidirectional_transition(node, fn, params, intro) {
+ let config = fn(node, params);
+ let t = intro ? 0 : 1;
+ let running_program = null;
+ let pending_program = null;
+ let animation_name = null;
+ function clear_animation() {
+ if (animation_name)
+ delete_rule(node, animation_name);
+ }
+ function init2(program, duration) {
+ const d = program.b - t;
+ duration *= Math.abs(d);
+ return {
+ a: t,
+ b: program.b,
+ d,
+ duration,
+ start: program.start,
+ end: program.start + duration,
+ group: program.group
+ };
+ }
+ function go(b) {
+ const { delay: delay2 = 0, duration = 300, easing = identity, tick: tick2 = noop, css } = config || null_transition;
+ const program = {
+ start: now() + delay2,
+ b
+ };
+ if (!b) {
+ program.group = outros;
+ outros.r += 1;
+ }
+ if (running_program || pending_program) {
+ pending_program = program;
+ } else {
+ if (css) {
+ clear_animation();
+ animation_name = create_rule(node, t, b, duration, delay2, easing, css);
+ }
+ if (b)
+ tick2(0, 1);
+ running_program = init2(program, duration);
+ add_render_callback(() => dispatch(node, b, "start"));
+ loop((now2) => {
+ if (pending_program && now2 > pending_program.start) {
+ running_program = init2(pending_program, duration);
+ pending_program = null;
+ dispatch(node, running_program.b, "start");
+ if (css) {
+ clear_animation();
+ animation_name = create_rule(node, t, running_program.b, running_program.duration, 0, easing, config.css);
+ }
+ }
+ if (running_program) {
+ if (now2 >= running_program.end) {
+ tick2(t = running_program.b, 1 - t);
+ dispatch(node, running_program.b, "end");
+ if (!pending_program) {
+ if (running_program.b) {
+ clear_animation();
+ } else {
+ if (!--running_program.group.r)
+ run_all(running_program.group.c);
+ }
+ }
+ running_program = null;
+ } else if (now2 >= running_program.start) {
+ const p = now2 - running_program.start;
+ t = running_program.a + running_program.d * easing(p / running_program.duration);
+ tick2(t, 1 - t);
+ }
+ }
+ return !!(running_program || pending_program);
+ });
+ }
+ }
+ return {
+ run(b) {
+ if (is_function(config)) {
+ wait().then(() => {
+ config = config();
+ go(b);
+ });
+ } else {
+ go(b);
+ }
+ },
+ end() {
+ clear_animation();
+ running_program = pending_program = null;
+ }
+ };
+}
+var globals = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : global;
+var boolean_attributes = new Set([
+ "allowfullscreen",
+ "allowpaymentrequest",
+ "async",
+ "autofocus",
+ "autoplay",
+ "checked",
+ "controls",
+ "default",
+ "defer",
+ "disabled",
+ "formnovalidate",
+ "hidden",
+ "ismap",
+ "loop",
+ "multiple",
+ "muted",
+ "nomodule",
+ "novalidate",
+ "open",
+ "playsinline",
+ "readonly",
+ "required",
+ "reversed",
+ "selected"
+]);
+function create_component(block) {
+ block && block.c();
+}
+function mount_component(component, target, anchor, customElement) {
+ const { fragment, on_mount, on_destroy, after_update } = component.$$;
+ fragment && fragment.m(target, anchor);
+ if (!customElement) {
+ add_render_callback(() => {
+ const new_on_destroy = on_mount.map(run).filter(is_function);
+ if (on_destroy) {
+ on_destroy.push(...new_on_destroy);
+ } else {
+ 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);
+ $$.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, instance5, create_fragment5, not_equal, props, append_styles2, dirty = [-1]) {
+ const parent_component = current_component;
+ set_current_component(component);
+ const $$ = component.$$ = {
+ fragment: null,
+ ctx: null,
+ props,
+ update: noop,
+ not_equal,
+ bound: blank_object(),
+ on_mount: [],
+ on_destroy: [],
+ on_disconnect: [],
+ before_update: [],
+ after_update: [],
+ context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
+ callbacks: blank_object(),
+ dirty,
+ skip_bound: false,
+ root: options.target || parent_component.$$.root
+ };
+ append_styles2 && append_styles2($$.root);
+ let ready2 = false;
+ $$.ctx = instance5 ? instance5(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 (ready2)
+ make_dirty(component, i);
+ }
+ return ret;
+ }) : [];
+ $$.update();
+ ready2 = true;
+ run_all($$.before_update);
+ $$.fragment = create_fragment5 ? create_fragment5($$.ctx) : false;
+ if (options.target) {
+ if (options.hydrate) {
+ start_hydrating();
+ const nodes = children(options.target);
+ $$.fragment && $$.fragment.l(nodes);
+ nodes.forEach(detach);
+ } else {
+ $$.fragment && $$.fragment.c();
+ }
+ if (options.intro)
+ transition_in(component.$$.fragment);
+ mount_component(component, options.target, options.anchor, options.customElement);
+ end_hydrating();
+ flush();
+ }
+ set_current_component(parent_component);
+}
+var SvelteElement;
+if (typeof HTMLElement === "function") {
+ SvelteElement = class extends HTMLElement {
+ constructor() {
+ super();
+ this.attachShadow({ mode: "open" });
+ }
+ connectedCallback() {
+ const { on_mount } = this.$$;
+ this.$$.on_disconnect = on_mount.map(run).filter(is_function);
+ for (const key2 in this.$$.slotted) {
+ this.appendChild(this.$$.slotted[key2]);
+ }
+ }
+ attributeChangedCallback(attr2, _oldValue, newValue) {
+ this[attr2] = newValue;
+ }
+ disconnectedCallback() {
+ run_all(this.$$.on_disconnect);
+ }
+ $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;
+ }
+ }
+ };
+}
+var SvelteComponent = class {
+ $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;
+ }
+ }
+};
+
+// node_modules/tslib/modules/index.js
+var import_tslib = __toModule(require_tslib());
+var {
+ __extends,
+ __assign,
+ __rest,
+ __decorate,
+ __param,
+ __metadata,
+ __awaiter,
+ __generator,
+ __exportStar,
+ __createBinding,
+ __values,
+ __read,
+ __spread,
+ __spreadArrays,
+ __spreadArray,
+ __await,
+ __asyncGenerator,
+ __asyncDelegator,
+ __asyncValues,
+ __makeTemplateObject,
+ __importStar,
+ __importDefault,
+ __classPrivateFieldGet,
+ __classPrivateFieldSet,
+ __classPrivateFieldIn
+} = import_tslib.default;
+
+// src/ui/sidebar/gitView.svelte
+var import_obsidian13 = __toModule(require("obsidian"));
+
+// node_modules/svelte/easing/index.mjs
+function cubicOut(t) {
+ const f = t - 1;
+ return f * f * f + 1;
+}
+
+// node_modules/svelte/transition/index.mjs
+function slide(node, { delay: delay2 = 0, duration = 400, easing = cubicOut } = {}) {
+ const style = getComputedStyle(node);
+ const opacity = +style.opacity;
+ const height = parseFloat(style.height);
+ const padding_top = parseFloat(style.paddingTop);
+ const padding_bottom = parseFloat(style.paddingBottom);
+ const margin_top = parseFloat(style.marginTop);
+ const margin_bottom = parseFloat(style.marginBottom);
+ const border_top_width = parseFloat(style.borderTopWidth);
+ const border_bottom_width = parseFloat(style.borderBottomWidth);
+ return {
+ delay: delay2,
+ duration,
+ easing,
+ css: (t) => `overflow: hidden;opacity: ${Math.min(t * 20, 1) * opacity};height: ${t * height}px;padding-top: ${t * padding_top}px;padding-bottom: ${t * padding_bottom}px;margin-top: ${t * margin_top}px;margin-bottom: ${t * margin_bottom}px;border-top-width: ${t * border_top_width}px;border-bottom-width: ${t * border_bottom_width}px;`
+ };
+}
+
+// src/ui/sidebar/components/fileComponent.svelte
+var import_obsidian11 = __toModule(require("obsidian"));
+
+// node_modules/obsidian-community-lib/dist/utils.js
+var feather = __toModule(require_feather());
+var import_obsidian9 = __toModule(require("obsidian"));
+function hoverPreview(event, view, to) {
+ const targetEl = event.target;
+ app.workspace.trigger("hover-link", {
+ event,
+ source: view.getViewType(),
+ hoverParent: view,
+ targetEl,
+ linktext: to
+ });
+}
+function createNewMDNote(newName, currFilePath = "") {
+ return __async(this, null, function* () {
+ const newFileFolder = app.fileManager.getNewFileParent(currFilePath).path;
+ const newFilePath = (0, import_obsidian9.normalizePath)(`${newFileFolder}${newFileFolder === "/" ? "" : "/"}${addMD(newName)}`);
+ return yield app.vault.create(newFilePath, "");
+ });
+}
+var addMD = (noteName) => {
+ return noteName.match(/\.MD$|\.md$/m) ? noteName : noteName + ".md";
+};
+function openOrSwitch(_0, _1) {
+ return __async(this, arguments, function* (dest, event, options = { createNewFile: true }) {
+ const { workspace } = app;
+ let destFile = app.metadataCache.getFirstLinkpathDest(dest, "");
+ if (!destFile && options.createNewFile) {
+ destFile = yield createNewMDNote(dest);
+ } else if (!destFile && !options.createNewFile)
+ return;
+ const leavesWithDestAlreadyOpen = [];
+ workspace.iterateAllLeaves((leaf) => {
+ var _a2;
+ if (leaf.view instanceof import_obsidian9.MarkdownView) {
+ const file = (_a2 = leaf.view) === null || _a2 === void 0 ? void 0 : _a2.file;
+ if (file && file.basename + "." + file.extension === dest) {
+ leavesWithDestAlreadyOpen.push(leaf);
+ }
+ }
+ });
+ if (leavesWithDestAlreadyOpen.length > 0) {
+ workspace.setActiveLeaf(leavesWithDestAlreadyOpen[0]);
+ } else {
+ const mode = app.vault.getConfig("defaultViewMode");
+ const leaf = event.ctrlKey || event.getModifierState("Meta") ? workspace.splitActiveLeaf() : workspace.getUnpinnedLeaf();
+ yield leaf.openFile(destFile, { active: true, mode });
+ }
+ });
+}
+
+// src/ui/modals/discardModal.ts
+var import_obsidian10 = __toModule(require("obsidian"));
+var DiscardModal = class extends import_obsidian10.Modal {
+ constructor(app2, deletion, filename) {
+ super(app2);
+ this.deletion = deletion;
+ this.filename = filename;
+ this.resolve = null;
+ }
+ myOpen() {
+ this.open();
+ return new Promise((resolve) => {
+ this.resolve = resolve;
+ });
+ }
+ onOpen() {
+ let { contentEl, titleEl } = this;
+ titleEl.setText(`${this.deletion ? "Delete" : "Discard"} this file?`);
+ contentEl.createEl("h4").setText(`Do you really want to ${this.deletion ? "delete" : "discard the changes of"} "${this.filename}"`);
+ const div = contentEl.createDiv();
+ div.addClass("obsidian-git-center");
+ div.createEl("button", { text: "Cancel" }).addEventListener("click", () => {
+ if (this.resolve)
+ this.resolve(false);
+ return this.close();
+ });
+ div.createEl("button", {
+ cls: "mod-cta",
+ text: "Confirm"
+ }).addEventListener("click", () => __async(this, null, function* () {
+ if (this.resolve)
+ this.resolve(true);
+ this.close();
+ }));
+ }
+ onClose() {
+ let { contentEl } = this;
+ contentEl.empty();
+ }
+};
+
+// src/ui/sidebar/components/fileComponent.svelte
+function add_css(target) {
+ append_styles(target, "svelte-1furf50", "main.svelte-1furf50.svelte-1furf50.svelte-1furf50{cursor:pointer;background-color:var(--background-secondary);border-radius:4px;width:98%;display:flex;justify-content:space-between;font-size:0.8rem;margin-bottom:2px}main.svelte-1furf50 .path.svelte-1furf50.svelte-1furf50{color:var(--text-muted);white-space:nowrap;max-width:75%;overflow:hidden;text-overflow:ellipsis}main.svelte-1furf50:hover .path.svelte-1furf50.svelte-1furf50{color:var(--text-normal);transition:all 200ms}main.svelte-1furf50 .tools.svelte-1furf50.svelte-1furf50{display:flex;align-items:center}main.svelte-1furf50 .tools .type.svelte-1furf50.svelte-1furf50{height:16px;width:16px;margin:0;display:flex;align-items:center;justify-content:center}main.svelte-1furf50 .tools .type[data-type=M].svelte-1furf50.svelte-1furf50{color:orange}main.svelte-1furf50 .tools .type[data-type=D].svelte-1furf50.svelte-1furf50{color:red}main.svelte-1furf50 .tools .buttons.svelte-1furf50.svelte-1furf50{display:flex}main.svelte-1furf50 .tools .buttons.svelte-1furf50>.svelte-1furf50{color:var(--text-faint);height:16px;width:16px;margin:0;transition:all 0.2s;border-radius:2px;margin-right:1px}main.svelte-1furf50 .tools .buttons.svelte-1furf50>.svelte-1furf50:hover{color:var(--text-normal);background-color:var(--interactive-accent)}");
+}
+function create_if_block(ctx) {
+ let div;
+ let mounted;
+ let dispose;
+ return {
+ c() {
+ div = element("div");
+ attr(div, "data-icon", "go-to-file");
+ attr(div, "aria-label", "Open File");
+ attr(div, "class", "svelte-1furf50");
+ },
+ m(target, anchor) {
+ insert(target, div, anchor);
+ ctx[12](div);
+ if (!mounted) {
+ dispose = listen(div, "click", ctx[5]);
+ mounted = true;
+ }
+ },
+ p: noop,
+ d(detaching) {
+ if (detaching)
+ detach(div);
+ ctx[12](null);
+ mounted = false;
+ dispose();
+ }
+ };
+}
+function create_fragment(ctx) {
+ let main;
+ let span0;
+ let t0_value = ctx[0].vault_path.split("/").last().replace(".md", "") + "";
+ let t0;
+ let span0_aria_label_value;
+ let t1;
+ let div3;
+ let div2;
+ let show_if = ctx[1].app.vault.getAbstractFileByPath(ctx[0].vault_path);
+ let t2;
+ let div0;
+ let t3;
+ let div1;
+ let t4;
+ let span1;
+ let t5_value = ctx[0].working_dir + "";
+ let t5;
+ let span1_data_type_value;
+ let mounted;
+ let dispose;
+ let if_block = show_if && create_if_block(ctx);
+ return {
+ c() {
+ main = element("main");
+ span0 = element("span");
+ t0 = text(t0_value);
+ t1 = space();
+ div3 = element("div");
+ div2 = element("div");
+ if (if_block)
+ if_block.c();
+ t2 = space();
+ div0 = element("div");
+ t3 = space();
+ div1 = element("div");
+ t4 = space();
+ span1 = element("span");
+ t5 = text(t5_value);
+ attr(span0, "class", "path svelte-1furf50");
+ attr(span0, "aria-label-position", ctx[3]);
+ attr(span0, "aria-label", span0_aria_label_value = ctx[0].vault_path.split("/").last() != ctx[0].vault_path ? ctx[0].vault_path : "");
+ attr(div0, "data-icon", "skip-back");
+ attr(div0, "aria-label", "Discard");
+ attr(div0, "class", "svelte-1furf50");
+ attr(div1, "data-icon", "plus");
+ attr(div1, "aria-label", "Stage");
+ attr(div1, "class", "svelte-1furf50");
+ attr(div2, "class", "buttons svelte-1furf50");
+ attr(span1, "class", "type svelte-1furf50");
+ attr(span1, "data-type", span1_data_type_value = ctx[0].working_dir);
+ attr(div3, "class", "tools svelte-1furf50");
+ attr(main, "class", "svelte-1furf50");
+ },
+ m(target, anchor) {
+ insert(target, main, anchor);
+ append2(main, span0);
+ append2(span0, t0);
+ append2(main, t1);
+ append2(main, div3);
+ append2(div3, div2);
+ if (if_block)
+ if_block.m(div2, null);
+ append2(div2, t2);
+ append2(div2, div0);
+ ctx[13](div0);
+ append2(div2, t3);
+ append2(div2, div1);
+ ctx[14](div1);
+ append2(div3, t4);
+ append2(div3, span1);
+ append2(span1, t5);
+ if (!mounted) {
+ dispose = [
+ listen(span0, "click", self2(ctx[7])),
+ listen(div0, "click", ctx[8]),
+ listen(div1, "click", ctx[6]),
+ listen(main, "mouseover", ctx[4]),
+ listen(main, "click", self2(ctx[7])),
+ listen(main, "focus", ctx[11])
+ ];
+ mounted = true;
+ }
+ },
+ p(ctx2, [dirty]) {
+ if (dirty & 1 && t0_value !== (t0_value = ctx2[0].vault_path.split("/").last().replace(".md", "") + ""))
+ set_data(t0, t0_value);
+ if (dirty & 8) {
+ attr(span0, "aria-label-position", ctx2[3]);
+ }
+ if (dirty & 1 && span0_aria_label_value !== (span0_aria_label_value = ctx2[0].vault_path.split("/").last() != ctx2[0].vault_path ? ctx2[0].vault_path : "")) {
+ attr(span0, "aria-label", span0_aria_label_value);
+ }
+ if (dirty & 3)
+ show_if = ctx2[1].app.vault.getAbstractFileByPath(ctx2[0].vault_path);
+ if (show_if) {
+ if (if_block) {
+ if_block.p(ctx2, dirty);
+ } else {
+ if_block = create_if_block(ctx2);
+ if_block.c();
+ if_block.m(div2, t2);
+ }
+ } else if (if_block) {
+ if_block.d(1);
+ if_block = null;
+ }
+ if (dirty & 1 && t5_value !== (t5_value = ctx2[0].working_dir + ""))
+ set_data(t5, t5_value);
+ if (dirty & 1 && span1_data_type_value !== (span1_data_type_value = ctx2[0].working_dir)) {
+ attr(span1, "data-type", span1_data_type_value);
+ }
+ },
+ i: noop,
+ o: noop,
+ d(detaching) {
+ if (detaching)
+ detach(main);
+ if (if_block)
+ if_block.d();
+ ctx[13](null);
+ ctx[14](null);
+ mounted = false;
+ run_all(dispose);
+ }
+ };
+}
+function instance($$self, $$props, $$invalidate) {
+ let side;
+ let { change } = $$props;
+ let { view } = $$props;
+ let { manager } = $$props;
+ let { workspace } = $$props;
+ let buttons = [];
+ setImmediate(() => buttons.forEach((b) => (0, import_obsidian11.setIcon)(b, b.getAttr("data-icon"), 16)));
+ function hover(event) {
+ if (!change.path.startsWith(view.app.vault.configDir) || !change.path.startsWith(".")) {
+ hoverPreview(event, view, change.vault_path.split("/").last().replace(".md", ""));
+ }
+ }
+ function open(event) {
+ if (!(change.path.startsWith(view.app.vault.configDir) || change.path.startsWith(".") || change.working_dir === "D")) {
+ openOrSwitch(view.app, change.vault_path, event);
+ }
+ }
+ function stage() {
+ manager.stage(change.path).finally(() => {
+ dispatchEvent(new CustomEvent("git-refresh"));
+ });
+ }
+ function showDiff(event) {
+ const leaf = workspace.activeLeaf;
+ if (leaf && !leaf.getViewState().pinned && !(event.ctrlKey || event.getModifierState("Meta"))) {
+ leaf.setViewState({
+ type: DIFF_VIEW_CONFIG.type,
+ state: { file: change.path, staged: false }
+ });
+ } else {
+ workspace.createLeafInParent(workspace.rootSplit, 0).setViewState({
+ type: DIFF_VIEW_CONFIG.type,
+ active: true,
+ state: { file: change.path, staged: false }
+ });
+ }
+ }
+ function discard() {
+ const deleteFile = change.working_dir == "U";
+ new DiscardModal(view.app, deleteFile, change.vault_path).myOpen().then((shouldDiscard) => {
+ if (shouldDiscard === true) {
+ if (deleteFile) {
+ view.app.vault.adapter.remove(change.vault_path).finally(() => {
+ dispatchEvent(new CustomEvent("git-refresh"));
+ });
+ } else {
+ manager.discard(change.path).finally(() => {
+ dispatchEvent(new CustomEvent("git-refresh"));
+ });
+ }
+ }
+ });
+ }
+ function focus_handler(event) {
+ bubble.call(this, $$self, event);
+ }
+ function div_binding($$value) {
+ binding_callbacks[$$value ? "unshift" : "push"](() => {
+ buttons[1] = $$value;
+ $$invalidate(2, buttons);
+ });
+ }
+ function div0_binding($$value) {
+ binding_callbacks[$$value ? "unshift" : "push"](() => {
+ buttons[0] = $$value;
+ $$invalidate(2, buttons);
+ });
+ }
+ function div1_binding($$value) {
+ binding_callbacks[$$value ? "unshift" : "push"](() => {
+ buttons[2] = $$value;
+ $$invalidate(2, buttons);
+ });
+ }
+ $$self.$$set = ($$props2) => {
+ if ("change" in $$props2)
+ $$invalidate(0, change = $$props2.change);
+ if ("view" in $$props2)
+ $$invalidate(1, view = $$props2.view);
+ if ("manager" in $$props2)
+ $$invalidate(9, manager = $$props2.manager);
+ if ("workspace" in $$props2)
+ $$invalidate(10, workspace = $$props2.workspace);
+ };
+ $$self.$$.update = () => {
+ if ($$self.$$.dirty & 2) {
+ $:
+ $$invalidate(3, side = view.leaf.getRoot().side == "left" ? "right" : "left");
+ }
+ };
+ return [
+ change,
+ view,
+ buttons,
+ side,
+ hover,
+ open,
+ stage,
+ showDiff,
+ discard,
+ manager,
+ workspace,
+ focus_handler,
+ div_binding,
+ div0_binding,
+ div1_binding
+ ];
+}
+var FileComponent = class extends SvelteComponent {
+ constructor(options) {
+ super();
+ init(this, options, instance, create_fragment, safe_not_equal, {
+ change: 0,
+ view: 1,
+ manager: 9,
+ workspace: 10
+ }, add_css);
+ }
+};
+var fileComponent_default = FileComponent;
+
+// src/ui/sidebar/components/stagedFileComponent.svelte
+var import_obsidian12 = __toModule(require("obsidian"));
+var import_path2 = __toModule(require("path"));
+function add_css2(target) {
+ append_styles(target, "svelte-15heedx", "main.svelte-15heedx.svelte-15heedx.svelte-15heedx{cursor:pointer;background-color:var(--background-secondary);border-radius:4px;width:98%;display:flex;justify-content:space-between;font-size:0.8rem;margin-bottom:2px}main.svelte-15heedx .path.svelte-15heedx.svelte-15heedx{color:var(--text-muted);white-space:nowrap;max-width:75%;overflow:hidden;text-overflow:ellipsis}main.svelte-15heedx:hover .path.svelte-15heedx.svelte-15heedx{color:var(--text-normal);transition:all 200ms}main.svelte-15heedx .tools.svelte-15heedx.svelte-15heedx{display:flex;align-items:center}main.svelte-15heedx .tools .type.svelte-15heedx.svelte-15heedx{height:16px;width:16px;margin:0;display:flex;align-items:center;justify-content:center}main.svelte-15heedx .tools .type[data-type=M].svelte-15heedx.svelte-15heedx{color:orange}main.svelte-15heedx .tools .type[data-type=D].svelte-15heedx.svelte-15heedx{color:red}main.svelte-15heedx .tools .type[data-type=A].svelte-15heedx.svelte-15heedx{color:yellowgreen}main.svelte-15heedx .tools .type[data-type=R].svelte-15heedx.svelte-15heedx{color:violet}main.svelte-15heedx .tools .buttons.svelte-15heedx.svelte-15heedx{display:flex}main.svelte-15heedx .tools .buttons.svelte-15heedx>.svelte-15heedx{color:var(--text-faint);height:16px;width:16px;margin:0;transition:all 0.2s;border-radius:2px;margin-right:1px}main.svelte-15heedx .tools .buttons.svelte-15heedx>.svelte-15heedx:hover{color:var(--text-normal);background-color:var(--interactive-accent)}");
+}
+function create_if_block2(ctx) {
+ let div;
+ let mounted;
+ let dispose;
+ return {
+ c() {
+ div = element("div");
+ attr(div, "data-icon", "go-to-file");
+ attr(div, "aria-label", "Open File");
+ attr(div, "class", "svelte-15heedx");
+ },
+ m(target, anchor) {
+ insert(target, div, anchor);
+ ctx[11](div);
+ if (!mounted) {
+ dispose = listen(div, "click", ctx[6]);
+ mounted = true;
+ }
+ },
+ p: noop,
+ d(detaching) {
+ if (detaching)
+ detach(div);
+ ctx[11](null);
+ mounted = false;
+ dispose();
+ }
+ };
+}
+function create_fragment2(ctx) {
+ let main;
+ let span0;
+ let t0_value = ctx[3].split("/").last().replace(".md", "") + "";
+ let t0;
+ let span0_aria_label_value;
+ let t1;
+ let div2;
+ let div1;
+ let show_if = ctx[1].app.vault.getAbstractFileByPath(ctx[3]);
+ let t2;
+ let div0;
+ let t3;
+ let span1;
+ let t4_value = ctx[0].index + "";
+ let t4;
+ let span1_data_type_value;
+ let mounted;
+ let dispose;
+ let if_block = show_if && create_if_block2(ctx);
+ return {
+ c() {
+ main = element("main");
+ span0 = element("span");
+ t0 = text(t0_value);
+ t1 = space();
+ div2 = element("div");
+ div1 = element("div");
+ if (if_block)
+ if_block.c();
+ t2 = space();
+ div0 = element("div");
+ t3 = space();
+ span1 = element("span");
+ t4 = text(t4_value);
+ attr(span0, "class", "path svelte-15heedx");
+ attr(span0, "aria-label-position", ctx[4]);
+ attr(span0, "aria-label", span0_aria_label_value = ctx[3].split("/").last() != ctx[3] ? ctx[3] : "");
+ attr(div0, "data-icon", "minus");
+ attr(div0, "aria-label", "Unstage");
+ attr(div0, "class", "svelte-15heedx");
+ attr(div1, "class", "buttons svelte-15heedx");
+ attr(span1, "class", "type svelte-15heedx");
+ attr(span1, "data-type", span1_data_type_value = ctx[0].index);
+ attr(div2, "class", "tools svelte-15heedx");
+ attr(main, "class", "svelte-15heedx");
+ },
+ m(target, anchor) {
+ insert(target, main, anchor);
+ append2(main, span0);
+ append2(span0, t0);
+ append2(main, t1);
+ append2(main, div2);
+ append2(div2, div1);
+ if (if_block)
+ if_block.m(div1, null);
+ append2(div1, t2);
+ append2(div1, div0);
+ ctx[12](div0);
+ append2(div2, t3);
+ append2(div2, span1);
+ append2(span1, t4);
+ if (!mounted) {
+ dispose = [
+ listen(span0, "click", ctx[7]),
+ listen(div0, "click", ctx[8]),
+ listen(main, "mouseover", ctx[5]),
+ listen(main, "focus", ctx[10]),
+ listen(main, "click", self2(ctx[7]))
+ ];
+ mounted = true;
+ }
+ },
+ p(ctx2, [dirty]) {
+ if (dirty & 8 && t0_value !== (t0_value = ctx2[3].split("/").last().replace(".md", "") + ""))
+ set_data(t0, t0_value);
+ if (dirty & 16) {
+ attr(span0, "aria-label-position", ctx2[4]);
+ }
+ if (dirty & 8 && span0_aria_label_value !== (span0_aria_label_value = ctx2[3].split("/").last() != ctx2[3] ? ctx2[3] : "")) {
+ attr(span0, "aria-label", span0_aria_label_value);
+ }
+ if (dirty & 10)
+ show_if = ctx2[1].app.vault.getAbstractFileByPath(ctx2[3]);
+ if (show_if) {
+ if (if_block) {
+ if_block.p(ctx2, dirty);
+ } else {
+ if_block = create_if_block2(ctx2);
+ if_block.c();
+ if_block.m(div1, t2);
+ }
+ } else if (if_block) {
+ if_block.d(1);
+ if_block = null;
+ }
+ if (dirty & 1 && t4_value !== (t4_value = ctx2[0].index + ""))
+ set_data(t4, t4_value);
+ if (dirty & 1 && span1_data_type_value !== (span1_data_type_value = ctx2[0].index)) {
+ attr(span1, "data-type", span1_data_type_value);
+ }
+ },
+ i: noop,
+ o: noop,
+ d(detaching) {
+ if (detaching)
+ detach(main);
+ if (if_block)
+ if_block.d();
+ ctx[12](null);
+ mounted = false;
+ run_all(dispose);
+ }
+ };
+}
+function instance2($$self, $$props, $$invalidate) {
+ let formattedPath;
+ let side;
+ let { change } = $$props;
+ let { view } = $$props;
+ let { manager } = $$props;
+ let buttons = [];
+ setImmediate(() => buttons.forEach((b) => (0, import_obsidian12.setIcon)(b, b.getAttr("data-icon"), 16)));
+ function hover(event) {
+ if (!change.path.startsWith(view.app.vault.configDir) || !change.path.startsWith(".")) {
+ hoverPreview(event, view, formattedPath.split("/").last().replace(".md", ""));
+ }
+ }
+ function open(event) {
+ if (!(change.path.startsWith(view.app.vault.configDir) || change.path.startsWith(".") || change.index === "D")) {
+ openOrSwitch(view.app, formattedPath, event);
+ }
+ }
+ function showDiff(event) {
+ const leaf = view.app.workspace.activeLeaf;
+ if (leaf && !leaf.getViewState().pinned && !(event.ctrlKey || event.getModifierState("Meta"))) {
+ leaf.setViewState({
+ type: DIFF_VIEW_CONFIG.type,
+ state: { file: change.path, staged: true }
+ });
+ } else {
+ view.app.workspace.createLeafInParent(view.app.workspace.rootSplit, 0).setViewState({
+ type: DIFF_VIEW_CONFIG.type,
+ active: true,
+ state: { file: change.path, staged: true }
+ });
+ }
+ }
+ function unstage() {
+ manager.unstage(change.path).finally(() => {
+ dispatchEvent(new CustomEvent("git-refresh"));
+ });
+ }
+ function focus_handler(event) {
+ bubble.call(this, $$self, event);
+ }
+ function div_binding($$value) {
+ binding_callbacks[$$value ? "unshift" : "push"](() => {
+ buttons[1] = $$value;
+ $$invalidate(2, buttons);
+ });
+ }
+ function div0_binding($$value) {
+ binding_callbacks[$$value ? "unshift" : "push"](() => {
+ buttons[0] = $$value;
+ $$invalidate(2, buttons);
+ });
+ }
+ $$self.$$set = ($$props2) => {
+ if ("change" in $$props2)
+ $$invalidate(0, change = $$props2.change);
+ if ("view" in $$props2)
+ $$invalidate(1, view = $$props2.view);
+ if ("manager" in $$props2)
+ $$invalidate(9, manager = $$props2.manager);
+ };
+ $$self.$$.update = () => {
+ if ($$self.$$.dirty & 1) {
+ $:
+ $$invalidate(3, formattedPath = change.vault_path);
+ }
+ if ($$self.$$.dirty & 2) {
+ $:
+ $$invalidate(4, side = view.leaf.getRoot().side == "left" ? "right" : "left");
+ }
+ };
+ return [
+ change,
+ view,
+ buttons,
+ formattedPath,
+ side,
+ hover,
+ open,
+ showDiff,
+ unstage,
+ manager,
+ focus_handler,
+ div_binding,
+ div0_binding
+ ];
+}
+var StagedFileComponent = class extends SvelteComponent {
+ constructor(options) {
+ super();
+ init(this, options, instance2, create_fragment2, safe_not_equal, { change: 0, view: 1, manager: 9 }, add_css2);
+ }
+};
+var stagedFileComponent_default = StagedFileComponent;
+
+// src/ui/sidebar/components/treeComponent.svelte
+function add_css3(target) {
+ append_styles(target, "svelte-pgmdei", '@charset "UTF-8";main.svelte-pgmdei.svelte-pgmdei:not(.topLevel){margin-left:5px}.opener.svelte-pgmdei.svelte-pgmdei{display:flex;justify-content:space-between;align-items:center;padding:0 4px}.opener.svelte-pgmdei .collapse-icon.svelte-pgmdei::after{content:"\xA0"}.opener.svelte-pgmdei div.svelte-pgmdei{display:flex}.opener.svelte-pgmdei svg.svelte-pgmdei{transform:rotate(-90deg)}.opener.open.svelte-pgmdei svg.svelte-pgmdei{transform:rotate(0)}.opener.svelte-pgmdei span.svelte-pgmdei{font-size:0.8rem}.file-view.svelte-pgmdei.svelte-pgmdei{margin-left:5px}');
+}
+function get_each_context(ctx, list, i) {
+ const child_ctx = ctx.slice();
+ child_ctx[7] = list[i];
+ return child_ctx;
+}
+function create_else_block_1(ctx) {
+ let div2;
+ let div1;
+ let div0;
+ let t0;
+ let span;
+ let t1_value = ctx[7].title + "";
+ let t1;
+ let t2;
+ let if_block_anchor;
+ let current;
+ let mounted;
+ let dispose;
+ function click_handler() {
+ return ctx[6](ctx[7]);
+ }
+ let if_block = !ctx[5][ctx[7].title] && create_if_block_2(ctx);
+ return {
+ c() {
+ div2 = element("div");
+ div1 = element("div");
+ div0 = element("div");
+ div0.innerHTML = ``;
+ t0 = space();
+ span = element("span");
+ t1 = text(t1_value);
+ t2 = space();
+ if (if_block)
+ if_block.c();
+ if_block_anchor = empty();
+ attr(div0, "class", "tree-item-icon collapse-icon svelte-pgmdei");
+ attr(div0, "style", "");
+ attr(span, "class", "svelte-pgmdei");
+ attr(div1, "class", "svelte-pgmdei");
+ attr(div2, "class", "opener tree-item-self is-clickable svelte-pgmdei");
+ toggle_class(div2, "open", !ctx[5][ctx[7].title]);
+ },
+ m(target, anchor) {
+ insert(target, div2, anchor);
+ append2(div2, div1);
+ append2(div1, div0);
+ append2(div1, t0);
+ append2(div1, span);
+ append2(span, t1);
+ insert(target, t2, anchor);
+ if (if_block)
+ if_block.m(target, anchor);
+ insert(target, if_block_anchor, anchor);
+ current = true;
+ if (!mounted) {
+ dispose = listen(div2, "click", click_handler);
+ mounted = true;
+ }
+ },
+ p(new_ctx, dirty) {
+ ctx = new_ctx;
+ if ((!current || dirty & 1) && t1_value !== (t1_value = ctx[7].title + ""))
+ set_data(t1, t1_value);
+ if (dirty & 33) {
+ toggle_class(div2, "open", !ctx[5][ctx[7].title]);
+ }
+ if (!ctx[5][ctx[7].title]) {
+ if (if_block) {
+ if_block.p(ctx, dirty);
+ if (dirty & 33) {
+ transition_in(if_block, 1);
+ }
+ } else {
+ if_block = create_if_block_2(ctx);
+ if_block.c();
+ transition_in(if_block, 1);
+ if_block.m(if_block_anchor.parentNode, if_block_anchor);
+ }
+ } else if (if_block) {
+ group_outros();
+ transition_out(if_block, 1, 1, () => {
+ if_block = null;
+ });
+ check_outros();
+ }
+ },
+ i(local) {
+ if (current)
+ return;
+ transition_in(if_block);
+ current = true;
+ },
+ o(local) {
+ transition_out(if_block);
+ current = false;
+ },
+ d(detaching) {
+ if (detaching)
+ detach(div2);
+ if (detaching)
+ detach(t2);
+ if (if_block)
+ if_block.d(detaching);
+ if (detaching)
+ detach(if_block_anchor);
+ mounted = false;
+ dispose();
+ }
+ };
+}
+function create_if_block3(ctx) {
+ let div;
+ let current_block_type_index;
+ let if_block;
+ let t;
+ let current;
+ const if_block_creators = [create_if_block_1, create_else_block];
+ const if_blocks = [];
+ function select_block_type_1(ctx2, dirty) {
+ if (ctx2[3])
+ return 0;
+ return 1;
+ }
+ current_block_type_index = select_block_type_1(ctx, -1);
+ if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
+ return {
+ c() {
+ div = element("div");
+ if_block.c();
+ t = space();
+ attr(div, "class", "file-view svelte-pgmdei");
+ },
+ m(target, anchor) {
+ insert(target, div, anchor);
+ if_blocks[current_block_type_index].m(div, null);
+ append2(div, t);
+ current = true;
+ },
+ p(ctx2, dirty) {
+ let previous_block_index = current_block_type_index;
+ current_block_type_index = select_block_type_1(ctx2, dirty);
+ if (current_block_type_index === previous_block_index) {
+ if_blocks[current_block_type_index].p(ctx2, 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](ctx2);
+ if_block.c();
+ } else {
+ if_block.p(ctx2, dirty);
+ }
+ transition_in(if_block, 1);
+ if_block.m(div, t);
+ }
+ },
+ i(local) {
+ if (current)
+ return;
+ transition_in(if_block);
+ current = true;
+ },
+ o(local) {
+ transition_out(if_block);
+ current = false;
+ },
+ d(detaching) {
+ if (detaching)
+ detach(div);
+ if_blocks[current_block_type_index].d();
+ }
+ };
+}
+function create_if_block_2(ctx) {
+ let div;
+ let treecomponent;
+ let t;
+ let div_transition;
+ let current;
+ treecomponent = new TreeComponent({
+ props: {
+ hierarchy: ctx[7],
+ plugin: ctx[1],
+ view: ctx[2],
+ staged: ctx[3]
+ }
+ });
+ return {
+ c() {
+ div = element("div");
+ create_component(treecomponent.$$.fragment);
+ t = space();
+ attr(div, "class", "file-view svelte-pgmdei");
+ },
+ m(target, anchor) {
+ insert(target, div, anchor);
+ mount_component(treecomponent, div, null);
+ append2(div, t);
+ current = true;
+ },
+ p(ctx2, dirty) {
+ const treecomponent_changes = {};
+ if (dirty & 1)
+ treecomponent_changes.hierarchy = ctx2[7];
+ if (dirty & 2)
+ treecomponent_changes.plugin = ctx2[1];
+ if (dirty & 4)
+ treecomponent_changes.view = ctx2[2];
+ if (dirty & 8)
+ treecomponent_changes.staged = ctx2[3];
+ treecomponent.$set(treecomponent_changes);
+ },
+ i(local) {
+ if (current)
+ return;
+ transition_in(treecomponent.$$.fragment, local);
+ if (local) {
+ add_render_callback(() => {
+ if (!div_transition)
+ div_transition = create_bidirectional_transition(div, slide, { duration: 75 }, true);
+ div_transition.run(1);
+ });
+ }
+ current = true;
+ },
+ o(local) {
+ transition_out(treecomponent.$$.fragment, local);
+ if (local) {
+ if (!div_transition)
+ div_transition = create_bidirectional_transition(div, slide, { duration: 75 }, false);
+ div_transition.run(0);
+ }
+ current = false;
+ },
+ d(detaching) {
+ if (detaching)
+ detach(div);
+ destroy_component(treecomponent);
+ if (detaching && div_transition)
+ div_transition.end();
+ }
+ };
+}
+function create_else_block(ctx) {
+ let filecomponent;
+ let current;
+ filecomponent = new fileComponent_default({
+ props: {
+ change: ctx[7].statusResult,
+ manager: ctx[1].gitManager,
+ view: ctx[2],
+ workspace: ctx[1].app.workspace
+ }
+ });
+ return {
+ c() {
+ create_component(filecomponent.$$.fragment);
+ },
+ m(target, anchor) {
+ mount_component(filecomponent, target, anchor);
+ current = true;
+ },
+ p(ctx2, dirty) {
+ const filecomponent_changes = {};
+ if (dirty & 1)
+ filecomponent_changes.change = ctx2[7].statusResult;
+ if (dirty & 2)
+ filecomponent_changes.manager = ctx2[1].gitManager;
+ if (dirty & 4)
+ filecomponent_changes.view = ctx2[2];
+ if (dirty & 2)
+ filecomponent_changes.workspace = ctx2[1].app.workspace;
+ filecomponent.$set(filecomponent_changes);
+ },
+ i(local) {
+ if (current)
+ return;
+ transition_in(filecomponent.$$.fragment, local);
+ current = true;
+ },
+ o(local) {
+ transition_out(filecomponent.$$.fragment, local);
+ current = false;
+ },
+ d(detaching) {
+ destroy_component(filecomponent, detaching);
+ }
+ };
+}
+function create_if_block_1(ctx) {
+ let stagedfilecomponent;
+ let current;
+ stagedfilecomponent = new stagedFileComponent_default({
+ props: {
+ change: ctx[7].statusResult,
+ manager: ctx[1].gitManager,
+ view: ctx[2]
+ }
+ });
+ return {
+ c() {
+ create_component(stagedfilecomponent.$$.fragment);
+ },
+ m(target, anchor) {
+ mount_component(stagedfilecomponent, target, anchor);
+ current = true;
+ },
+ p(ctx2, dirty) {
+ const stagedfilecomponent_changes = {};
+ if (dirty & 1)
+ stagedfilecomponent_changes.change = ctx2[7].statusResult;
+ if (dirty & 2)
+ stagedfilecomponent_changes.manager = ctx2[1].gitManager;
+ if (dirty & 4)
+ stagedfilecomponent_changes.view = ctx2[2];
+ stagedfilecomponent.$set(stagedfilecomponent_changes);
+ },
+ i(local) {
+ if (current)
+ return;
+ transition_in(stagedfilecomponent.$$.fragment, local);
+ current = true;
+ },
+ o(local) {
+ transition_out(stagedfilecomponent.$$.fragment, local);
+ current = false;
+ },
+ d(detaching) {
+ destroy_component(stagedfilecomponent, detaching);
+ }
+ };
+}
+function create_each_block(ctx) {
+ let current_block_type_index;
+ let if_block;
+ let if_block_anchor;
+ let current;
+ const if_block_creators = [create_if_block3, create_else_block_1];
+ const if_blocks = [];
+ function select_block_type(ctx2, dirty) {
+ if (ctx2[7].statusResult)
+ return 0;
+ return 1;
+ }
+ current_block_type_index = select_block_type(ctx, -1);
+ if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
+ return {
+ c() {
+ if_block.c();
+ if_block_anchor = empty();
+ },
+ m(target, anchor) {
+ if_blocks[current_block_type_index].m(target, anchor);
+ insert(target, if_block_anchor, anchor);
+ current = true;
+ },
+ p(ctx2, dirty) {
+ let previous_block_index = current_block_type_index;
+ current_block_type_index = select_block_type(ctx2, dirty);
+ if (current_block_type_index === previous_block_index) {
+ if_blocks[current_block_type_index].p(ctx2, 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](ctx2);
+ if_block.c();
+ } else {
+ if_block.p(ctx2, dirty);
+ }
+ transition_in(if_block, 1);
+ if_block.m(if_block_anchor.parentNode, if_block_anchor);
+ }
+ },
+ i(local) {
+ if (current)
+ return;
+ transition_in(if_block);
+ current = true;
+ },
+ o(local) {
+ transition_out(if_block);
+ current = false;
+ },
+ d(detaching) {
+ if_blocks[current_block_type_index].d(detaching);
+ if (detaching)
+ detach(if_block_anchor);
+ }
+ };
+}
+function create_fragment3(ctx) {
+ let main;
+ let current;
+ let each_value = ctx[0].children;
+ 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;
+ });
+ return {
+ c() {
+ main = element("main");
+ for (let i = 0; i < each_blocks.length; i += 1) {
+ each_blocks[i].c();
+ }
+ attr(main, "class", "svelte-pgmdei");
+ toggle_class(main, "topLevel", ctx[4]);
+ },
+ m(target, anchor) {
+ insert(target, main, anchor);
+ for (let i = 0; i < each_blocks.length; i += 1) {
+ each_blocks[i].m(main, null);
+ }
+ current = true;
+ },
+ p(ctx2, [dirty]) {
+ if (dirty & 47) {
+ each_value = ctx2[0].children;
+ let i;
+ for (i = 0; i < each_value.length; i += 1) {
+ const child_ctx = get_each_context(ctx2, 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(main, null);
+ }
+ }
+ group_outros();
+ for (i = each_value.length; i < each_blocks.length; i += 1) {
+ out(i);
+ }
+ check_outros();
+ }
+ if (dirty & 16) {
+ toggle_class(main, "topLevel", ctx2[4]);
+ }
+ },
+ 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(main);
+ destroy_each(each_blocks, detaching);
+ }
+ };
+}
+function instance3($$self, $$props, $$invalidate) {
+ let { hierarchy } = $$props;
+ let { plugin } = $$props;
+ let { view } = $$props;
+ let { staged } = $$props;
+ let { topLevel = false } = $$props;
+ const closed = {};
+ const click_handler = (entity) => {
+ $$invalidate(5, closed[entity.title] = !closed[entity.title], closed);
+ };
+ $$self.$$set = ($$props2) => {
+ if ("hierarchy" in $$props2)
+ $$invalidate(0, hierarchy = $$props2.hierarchy);
+ if ("plugin" in $$props2)
+ $$invalidate(1, plugin = $$props2.plugin);
+ if ("view" in $$props2)
+ $$invalidate(2, view = $$props2.view);
+ if ("staged" in $$props2)
+ $$invalidate(3, staged = $$props2.staged);
+ if ("topLevel" in $$props2)
+ $$invalidate(4, topLevel = $$props2.topLevel);
+ };
+ return [hierarchy, plugin, view, staged, topLevel, closed, click_handler];
+}
+var TreeComponent = class extends SvelteComponent {
+ constructor(options) {
+ super();
+ init(this, options, instance3, create_fragment3, safe_not_equal, {
+ hierarchy: 0,
+ plugin: 1,
+ view: 2,
+ staged: 3,
+ topLevel: 4
+ }, add_css3);
+ }
+};
+var treeComponent_default = TreeComponent;
+
+// src/ui/sidebar/gitView.svelte
+function add_css4(target) {
+ append_styles(target, "svelte-1f0ksxd", '@charset "UTF-8";.commit-msg.svelte-1f0ksxd.svelte-1f0ksxd{width:100%;min-height:1.9em;height:1.9em;resize:vertical;padding:2px 5px;background-color:var(--background-modifier-form-field)}.search-input-container.svelte-1f0ksxd.svelte-1f0ksxd{width:100%}.file-view.svelte-1f0ksxd.svelte-1f0ksxd{margin-left:5px}.opener.svelte-1f0ksxd.svelte-1f0ksxd{display:flex;justify-content:space-between;align-items:center;padding:0 4px}.opener.svelte-1f0ksxd .collapse-icon.svelte-1f0ksxd::after{content:"\xA0"}.opener.svelte-1f0ksxd div.svelte-1f0ksxd{display:flex}.opener.svelte-1f0ksxd svg.svelte-1f0ksxd{transform:rotate(-90deg)}.opener.open.svelte-1f0ksxd svg.svelte-1f0ksxd{transform:rotate(0)}.git-view-body.svelte-1f0ksxd.svelte-1f0ksxd{overflow-y:auto;padding-left:10px}main.svelte-1f0ksxd.svelte-1f0ksxd{display:flex;flex-direction:column;height:100%;overflow-y:hidden}.nav-buttons-container.svelte-1f0ksxd.svelte-1f0ksxd{justify-content:space-between}.group.svelte-1f0ksxd.svelte-1f0ksxd{display:flex}');
+}
+function get_each_context2(ctx, list, i) {
+ const child_ctx = ctx.slice();
+ child_ctx[30] = list[i];
+ return child_ctx;
+}
+function get_each_context_1(ctx, list, i) {
+ const child_ctx = ctx.slice();
+ child_ctx[33] = list[i];
+ return child_ctx;
+}
+function create_if_block_5(ctx) {
+ let div;
+ let div_aria_label_value;
+ let mounted;
+ let dispose;
+ return {
+ c() {
+ div = element("div");
+ attr(div, "class", "search-input-clear-button");
+ attr(div, "aria-label", div_aria_label_value = "Clear");
+ },
+ m(target, anchor) {
+ insert(target, div, anchor);
+ if (!mounted) {
+ dispose = listen(div, "click", ctx[26]);
+ mounted = true;
+ }
+ },
+ p: noop,
+ d(detaching) {
+ if (detaching)
+ detach(div);
+ mounted = false;
+ dispose();
+ }
+ };
+}
+function create_if_block4(ctx) {
+ let div3;
+ let div2;
+ let div1;
+ let t2;
+ let span1;
+ let t3_value = ctx[5].staged.length + "";
+ let t3;
+ let t4;
+ let t5;
+ let div7;
+ let div6;
+ let div5;
+ let t8;
+ let span3;
+ let t9_value = ctx[5].changed.length + "";
+ let t9;
+ let t10;
+ let current;
+ let mounted;
+ let dispose;
+ let if_block0 = ctx[11] && create_if_block_3(ctx);
+ let if_block1 = ctx[10] && create_if_block_12(ctx);
+ return {
+ c() {
+ div3 = element("div");
+ div2 = element("div");
+ div1 = element("div");
+ div1.innerHTML = `
+ Staged Changes`;
+ t2 = space();
+ span1 = element("span");
+ t3 = text(t3_value);
+ t4 = space();
+ if (if_block0)
+ if_block0.c();
+ t5 = space();
+ div7 = element("div");
+ div6 = element("div");
+ div5 = element("div");
+ div5.innerHTML = `
+ Changes`;
+ t8 = space();
+ span3 = element("span");
+ t9 = text(t9_value);
+ t10 = space();
+ if (if_block1)
+ if_block1.c();
+ attr(div1, "class", "svelte-1f0ksxd");
+ attr(span1, "class", "tree-item-flair");
+ attr(div2, "class", "opener tree-item-self is-clickable svelte-1f0ksxd");
+ toggle_class(div2, "open", ctx[11]);
+ attr(div3, "class", "staged");
+ attr(div5, "class", "svelte-1f0ksxd");
+ attr(span3, "class", "tree-item-flair");
+ attr(div6, "class", "opener tree-item-self is-clickable svelte-1f0ksxd");
+ toggle_class(div6, "open", ctx[10]);
+ attr(div7, "class", "changes");
+ },
+ m(target, anchor) {
+ insert(target, div3, anchor);
+ append2(div3, div2);
+ append2(div2, div1);
+ append2(div2, t2);
+ append2(div2, span1);
+ append2(span1, t3);
+ append2(div3, t4);
+ if (if_block0)
+ if_block0.m(div3, null);
+ insert(target, t5, anchor);
+ insert(target, div7, anchor);
+ append2(div7, div6);
+ append2(div6, div5);
+ append2(div6, t8);
+ append2(div6, span3);
+ append2(span3, t9);
+ append2(div7, t10);
+ if (if_block1)
+ if_block1.m(div7, null);
+ current = true;
+ if (!mounted) {
+ dispose = [
+ listen(div2, "click", ctx[27]),
+ listen(div6, "click", ctx[28])
+ ];
+ mounted = true;
+ }
+ },
+ p(ctx2, dirty) {
+ if ((!current || dirty[0] & 32) && t3_value !== (t3_value = ctx2[5].staged.length + ""))
+ set_data(t3, t3_value);
+ if (dirty[0] & 2048) {
+ toggle_class(div2, "open", ctx2[11]);
+ }
+ if (ctx2[11]) {
+ if (if_block0) {
+ if_block0.p(ctx2, dirty);
+ if (dirty[0] & 2048) {
+ transition_in(if_block0, 1);
+ }
+ } else {
+ if_block0 = create_if_block_3(ctx2);
+ if_block0.c();
+ transition_in(if_block0, 1);
+ if_block0.m(div3, null);
+ }
+ } else if (if_block0) {
+ group_outros();
+ transition_out(if_block0, 1, 1, () => {
+ if_block0 = null;
+ });
+ check_outros();
+ }
+ if ((!current || dirty[0] & 32) && t9_value !== (t9_value = ctx2[5].changed.length + ""))
+ set_data(t9, t9_value);
+ if (dirty[0] & 1024) {
+ toggle_class(div6, "open", ctx2[10]);
+ }
+ if (ctx2[10]) {
+ if (if_block1) {
+ if_block1.p(ctx2, dirty);
+ if (dirty[0] & 1024) {
+ transition_in(if_block1, 1);
+ }
+ } else {
+ if_block1 = create_if_block_12(ctx2);
+ if_block1.c();
+ transition_in(if_block1, 1);
+ if_block1.m(div7, null);
+ }
+ } else if (if_block1) {
+ group_outros();
+ transition_out(if_block1, 1, 1, () => {
+ if_block1 = null;
+ });
+ check_outros();
+ }
+ },
+ i(local) {
+ if (current)
+ return;
+ transition_in(if_block0);
+ transition_in(if_block1);
+ current = true;
+ },
+ o(local) {
+ transition_out(if_block0);
+ transition_out(if_block1);
+ current = false;
+ },
+ d(detaching) {
+ if (detaching)
+ detach(div3);
+ if (if_block0)
+ if_block0.d();
+ if (detaching)
+ detach(t5);
+ if (detaching)
+ detach(div7);
+ if (if_block1)
+ if_block1.d();
+ mounted = false;
+ run_all(dispose);
+ }
+ };
+}
+function create_if_block_3(ctx) {
+ let div;
+ let current_block_type_index;
+ let if_block;
+ let div_transition;
+ let current;
+ const if_block_creators = [create_if_block_4, create_else_block_12];
+ const if_blocks = [];
+ function select_block_type(ctx2, dirty) {
+ if (ctx2[2])
+ return 0;
+ return 1;
+ }
+ current_block_type_index = select_block_type(ctx, [-1, -1]);
+ if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
+ return {
+ c() {
+ div = element("div");
+ if_block.c();
+ attr(div, "class", "file-view svelte-1f0ksxd");
+ },
+ m(target, anchor) {
+ insert(target, div, anchor);
+ if_blocks[current_block_type_index].m(div, null);
+ current = true;
+ },
+ p(ctx2, dirty) {
+ let previous_block_index = current_block_type_index;
+ current_block_type_index = select_block_type(ctx2, dirty);
+ if (current_block_type_index === previous_block_index) {
+ if_blocks[current_block_type_index].p(ctx2, 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](ctx2);
+ if_block.c();
+ } else {
+ if_block.p(ctx2, dirty);
+ }
+ transition_in(if_block, 1);
+ if_block.m(div, null);
+ }
+ },
+ i(local) {
+ if (current)
+ return;
+ transition_in(if_block);
+ if (local) {
+ add_render_callback(() => {
+ if (!div_transition)
+ div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, true);
+ div_transition.run(1);
+ });
+ }
+ current = true;
+ },
+ o(local) {
+ transition_out(if_block);
+ if (local) {
+ if (!div_transition)
+ div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, false);
+ div_transition.run(0);
+ }
+ current = false;
+ },
+ d(detaching) {
+ if (detaching)
+ detach(div);
+ if_blocks[current_block_type_index].d();
+ if (detaching && div_transition)
+ div_transition.end();
+ }
+ };
+}
+function create_else_block_12(ctx) {
+ let each_1_anchor;
+ let current;
+ let each_value_1 = ctx[5].staged;
+ 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() {
+ 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(ctx2, dirty) {
+ if (dirty[0] & 35) {
+ each_value_1 = ctx2[5].staged;
+ let i;
+ for (i = 0; i < each_value_1.length; i += 1) {
+ const child_ctx = get_each_context_1(ctx2, 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(each_1_anchor.parentNode, each_1_anchor);
+ }
+ }
+ group_outros();
+ for (i = each_value_1.length; i < each_blocks.length; i += 1) {
+ out(i);
+ }
+ check_outros();
+ }
+ },
+ 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) {
+ destroy_each(each_blocks, detaching);
+ if (detaching)
+ detach(each_1_anchor);
+ }
+ };
+}
+function create_if_block_4(ctx) {
+ let treecomponent;
+ let current;
+ treecomponent = new treeComponent_default({
+ props: {
+ hierarchy: ctx[9],
+ plugin: ctx[0],
+ view: ctx[1],
+ staged: true,
+ topLevel: true
+ }
+ });
+ return {
+ c() {
+ create_component(treecomponent.$$.fragment);
+ },
+ m(target, anchor) {
+ mount_component(treecomponent, target, anchor);
+ current = true;
+ },
+ p(ctx2, dirty) {
+ const treecomponent_changes = {};
+ if (dirty[0] & 512)
+ treecomponent_changes.hierarchy = ctx2[9];
+ if (dirty[0] & 1)
+ treecomponent_changes.plugin = ctx2[0];
+ if (dirty[0] & 2)
+ treecomponent_changes.view = ctx2[1];
+ treecomponent.$set(treecomponent_changes);
+ },
+ i(local) {
+ if (current)
+ return;
+ transition_in(treecomponent.$$.fragment, local);
+ current = true;
+ },
+ o(local) {
+ transition_out(treecomponent.$$.fragment, local);
+ current = false;
+ },
+ d(detaching) {
+ destroy_component(treecomponent, detaching);
+ }
+ };
+}
+function create_each_block_1(ctx) {
+ let stagedfilecomponent;
+ let current;
+ stagedfilecomponent = new stagedFileComponent_default({
+ props: {
+ change: ctx[33],
+ view: ctx[1],
+ manager: ctx[0].gitManager
+ }
+ });
+ return {
+ c() {
+ create_component(stagedfilecomponent.$$.fragment);
+ },
+ m(target, anchor) {
+ mount_component(stagedfilecomponent, target, anchor);
+ current = true;
+ },
+ p(ctx2, dirty) {
+ const stagedfilecomponent_changes = {};
+ if (dirty[0] & 32)
+ stagedfilecomponent_changes.change = ctx2[33];
+ if (dirty[0] & 2)
+ stagedfilecomponent_changes.view = ctx2[1];
+ if (dirty[0] & 1)
+ stagedfilecomponent_changes.manager = ctx2[0].gitManager;
+ stagedfilecomponent.$set(stagedfilecomponent_changes);
+ },
+ i(local) {
+ if (current)
+ return;
+ transition_in(stagedfilecomponent.$$.fragment, local);
+ current = true;
+ },
+ o(local) {
+ transition_out(stagedfilecomponent.$$.fragment, local);
+ current = false;
+ },
+ d(detaching) {
+ destroy_component(stagedfilecomponent, detaching);
+ }
+ };
+}
+function create_if_block_12(ctx) {
+ let div;
+ let current_block_type_index;
+ let if_block;
+ let div_transition;
+ let current;
+ const if_block_creators = [create_if_block_22, create_else_block2];
+ const if_blocks = [];
+ function select_block_type_1(ctx2, dirty) {
+ if (ctx2[2])
+ return 0;
+ return 1;
+ }
+ current_block_type_index = select_block_type_1(ctx, [-1, -1]);
+ if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
+ return {
+ c() {
+ div = element("div");
+ if_block.c();
+ attr(div, "class", "file-view svelte-1f0ksxd");
+ },
+ m(target, anchor) {
+ insert(target, div, anchor);
+ if_blocks[current_block_type_index].m(div, null);
+ current = true;
+ },
+ p(ctx2, dirty) {
+ let previous_block_index = current_block_type_index;
+ current_block_type_index = select_block_type_1(ctx2, dirty);
+ if (current_block_type_index === previous_block_index) {
+ if_blocks[current_block_type_index].p(ctx2, 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](ctx2);
+ if_block.c();
+ } else {
+ if_block.p(ctx2, dirty);
+ }
+ transition_in(if_block, 1);
+ if_block.m(div, null);
+ }
+ },
+ i(local) {
+ if (current)
+ return;
+ transition_in(if_block);
+ if (local) {
+ add_render_callback(() => {
+ if (!div_transition)
+ div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, true);
+ div_transition.run(1);
+ });
+ }
+ current = true;
+ },
+ o(local) {
+ transition_out(if_block);
+ if (local) {
+ if (!div_transition)
+ div_transition = create_bidirectional_transition(div, slide, { duration: 150 }, false);
+ div_transition.run(0);
+ }
+ current = false;
+ },
+ d(detaching) {
+ if (detaching)
+ detach(div);
+ if_blocks[current_block_type_index].d();
+ if (detaching && div_transition)
+ div_transition.end();
+ }
+ };
+}
+function create_else_block2(ctx) {
+ let each_1_anchor;
+ let current;
+ let each_value = ctx[5].changed;
+ let each_blocks = [];
+ for (let i = 0; i < each_value.length; i += 1) {
+ each_blocks[i] = create_each_block2(get_each_context2(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(ctx2, dirty) {
+ if (dirty[0] & 35) {
+ each_value = ctx2[5].changed;
+ let i;
+ for (i = 0; i < each_value.length; i += 1) {
+ const child_ctx = get_each_context2(ctx2, 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_block2(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);
+ }
+ };
+}
+function create_if_block_22(ctx) {
+ let treecomponent;
+ let current;
+ treecomponent = new treeComponent_default({
+ props: {
+ hierarchy: ctx[8],
+ plugin: ctx[0],
+ view: ctx[1],
+ staged: false,
+ topLevel: true
+ }
+ });
+ return {
+ c() {
+ create_component(treecomponent.$$.fragment);
+ },
+ m(target, anchor) {
+ mount_component(treecomponent, target, anchor);
+ current = true;
+ },
+ p(ctx2, dirty) {
+ const treecomponent_changes = {};
+ if (dirty[0] & 256)
+ treecomponent_changes.hierarchy = ctx2[8];
+ if (dirty[0] & 1)
+ treecomponent_changes.plugin = ctx2[0];
+ if (dirty[0] & 2)
+ treecomponent_changes.view = ctx2[1];
+ treecomponent.$set(treecomponent_changes);
+ },
+ i(local) {
+ if (current)
+ return;
+ transition_in(treecomponent.$$.fragment, local);
+ current = true;
+ },
+ o(local) {
+ transition_out(treecomponent.$$.fragment, local);
+ current = false;
+ },
+ d(detaching) {
+ destroy_component(treecomponent, detaching);
+ }
+ };
+}
+function create_each_block2(ctx) {
+ let filecomponent;
+ let current;
+ filecomponent = new fileComponent_default({
+ props: {
+ change: ctx[30],
+ view: ctx[1],
+ manager: ctx[0].gitManager,
+ workspace: ctx[0].app.workspace
+ }
+ });
+ filecomponent.$on("git-refresh", triggerRefresh);
+ return {
+ c() {
+ create_component(filecomponent.$$.fragment);
+ },
+ m(target, anchor) {
+ mount_component(filecomponent, target, anchor);
+ current = true;
+ },
+ p(ctx2, dirty) {
+ const filecomponent_changes = {};
+ if (dirty[0] & 32)
+ filecomponent_changes.change = ctx2[30];
+ if (dirty[0] & 2)
+ filecomponent_changes.view = ctx2[1];
+ if (dirty[0] & 1)
+ filecomponent_changes.manager = ctx2[0].gitManager;
+ if (dirty[0] & 1)
+ filecomponent_changes.workspace = ctx2[0].app.workspace;
+ filecomponent.$set(filecomponent_changes);
+ },
+ i(local) {
+ if (current)
+ return;
+ transition_in(filecomponent.$$.fragment, local);
+ current = true;
+ },
+ o(local) {
+ transition_out(filecomponent.$$.fragment, local);
+ current = false;
+ },
+ d(detaching) {
+ destroy_component(filecomponent, detaching);
+ }
+ };
+}
+function create_fragment4(ctx) {
+ let main;
+ let div9;
+ let div6;
+ let div0;
+ let t0;
+ let div1;
+ let t1;
+ let div2;
+ let t2;
+ let div3;
+ let t3;
+ let div4;
+ let t4;
+ let div5;
+ let t5;
+ let div7;
+ let t6;
+ let div8;
+ let textarea;
+ let t7;
+ let t8;
+ let div10;
+ let current;
+ let mounted;
+ let dispose;
+ let if_block0 = ctx[6] && create_if_block_5(ctx);
+ let if_block1 = ctx[5] && create_if_block4(ctx);
+ return {
+ c() {
+ main = element("main");
+ div9 = element("div");
+ div6 = element("div");
+ div0 = element("div");
+ t0 = space();
+ div1 = element("div");
+ t1 = space();
+ div2 = element("div");
+ t2 = space();
+ div3 = element("div");
+ t3 = space();
+ div4 = element("div");
+ t4 = space();
+ div5 = element("div");
+ t5 = space();
+ div7 = element("div");
+ t6 = space();
+ div8 = element("div");
+ textarea = element("textarea");
+ t7 = space();
+ if (if_block0)
+ if_block0.c();
+ t8 = space();
+ div10 = element("div");
+ if (if_block1)
+ if_block1.c();
+ attr(div0, "id", "commit-btn");
+ attr(div0, "data-icon", "check");
+ attr(div0, "class", "nav-action-button");
+ attr(div0, "aria-label", "Commit");
+ attr(div1, "id", "stage-all");
+ attr(div1, "class", "nav-action-button");
+ attr(div1, "data-icon", "plus-circle");
+ attr(div1, "aria-label", "Stage all");
+ attr(div2, "id", "unstage-all");
+ attr(div2, "class", "nav-action-button");
+ attr(div2, "data-icon", "minus-circle");
+ attr(div2, "aria-label", "Unstage all");
+ attr(div3, "id", "push");
+ attr(div3, "class", "nav-action-button");
+ attr(div3, "data-icon", "upload");
+ attr(div3, "aria-label", "Push");
+ attr(div4, "id", "pull");
+ attr(div4, "class", "nav-action-button");
+ attr(div4, "data-icon", "download");
+ attr(div4, "aria-label", "Pull");
+ attr(div5, "id", "layoutChange");
+ attr(div5, "class", "nav-action-button");
+ attr(div5, "aria-label", "Change Layout");
+ attr(div6, "class", "group svelte-1f0ksxd");
+ attr(div7, "id", "refresh");
+ attr(div7, "class", "nav-action-button");
+ attr(div7, "data-icon", "refresh-cw");
+ attr(div7, "aria-label", "Refresh");
+ toggle_class(div7, "loading", ctx[4]);
+ attr(textarea, "class", "commit-msg svelte-1f0ksxd");
+ attr(textarea, "type", "text");
+ attr(textarea, "spellcheck", "true");
+ attr(textarea, "placeholder", "Commit Message");
+ attr(div8, "class", "search-input-container svelte-1f0ksxd");
+ attr(div9, "class", "nav-buttons-container svelte-1f0ksxd");
+ attr(div10, "class", "git-view-body svelte-1f0ksxd");
+ attr(main, "class", "svelte-1f0ksxd");
+ },
+ m(target, anchor) {
+ insert(target, main, anchor);
+ append2(main, div9);
+ append2(div9, div6);
+ append2(div6, div0);
+ ctx[17](div0);
+ append2(div6, t0);
+ append2(div6, div1);
+ ctx[18](div1);
+ append2(div6, t1);
+ append2(div6, div2);
+ ctx[19](div2);
+ append2(div6, t2);
+ append2(div6, div3);
+ ctx[20](div3);
+ append2(div6, t3);
+ append2(div6, div4);
+ ctx[21](div4);
+ append2(div6, t4);
+ append2(div6, div5);
+ ctx[22](div5);
+ append2(div9, t5);
+ append2(div9, div7);
+ ctx[24](div7);
+ append2(div9, t6);
+ append2(div9, div8);
+ append2(div8, textarea);
+ set_input_value(textarea, ctx[6]);
+ append2(div8, t7);
+ if (if_block0)
+ if_block0.m(div8, null);
+ append2(main, t8);
+ append2(main, div10);
+ if (if_block1)
+ if_block1.m(div10, null);
+ current = true;
+ if (!mounted) {
+ dispose = [
+ listen(div0, "click", ctx[12]),
+ listen(div1, "click", ctx[13]),
+ listen(div2, "click", ctx[14]),
+ listen(div3, "click", ctx[15]),
+ listen(div4, "click", ctx[16]),
+ listen(div5, "click", ctx[23]),
+ listen(div7, "click", triggerRefresh),
+ listen(textarea, "input", ctx[25])
+ ];
+ mounted = true;
+ }
+ },
+ p(ctx2, dirty) {
+ if (dirty[0] & 16) {
+ toggle_class(div7, "loading", ctx2[4]);
+ }
+ if (dirty[0] & 64) {
+ set_input_value(textarea, ctx2[6]);
+ }
+ if (ctx2[6]) {
+ if (if_block0) {
+ if_block0.p(ctx2, dirty);
+ } else {
+ if_block0 = create_if_block_5(ctx2);
+ if_block0.c();
+ if_block0.m(div8, null);
+ }
+ } else if (if_block0) {
+ if_block0.d(1);
+ if_block0 = null;
+ }
+ if (ctx2[5]) {
+ if (if_block1) {
+ if_block1.p(ctx2, dirty);
+ if (dirty[0] & 32) {
+ transition_in(if_block1, 1);
+ }
+ } else {
+ if_block1 = create_if_block4(ctx2);
+ if_block1.c();
+ transition_in(if_block1, 1);
+ if_block1.m(div10, null);
+ }
+ } else if (if_block1) {
+ group_outros();
+ transition_out(if_block1, 1, 1, () => {
+ if_block1 = null;
+ });
+ check_outros();
+ }
+ },
+ i(local) {
+ if (current)
+ return;
+ transition_in(if_block1);
+ current = true;
+ },
+ o(local) {
+ transition_out(if_block1);
+ current = false;
+ },
+ d(detaching) {
+ if (detaching)
+ detach(main);
+ ctx[17](null);
+ ctx[18](null);
+ ctx[19](null);
+ ctx[20](null);
+ ctx[21](null);
+ ctx[22](null);
+ ctx[24](null);
+ if (if_block0)
+ if_block0.d();
+ if (if_block1)
+ if_block1.d();
+ mounted = false;
+ run_all(dispose);
+ }
+ };
+}
+function triggerRefresh() {
+ dispatchEvent(new CustomEvent("git-refresh"));
+}
+function instance4($$self, $$props, $$invalidate) {
+ let { plugin } = $$props;
+ let { view } = $$props;
+ let loading;
+ let status;
+ let commitMessage = plugin.settings.commitMessage;
+ let buttons = [];
+ let changeHierarchy;
+ let stagedHierarchy;
+ let changesOpen = true;
+ let stagedOpen = true;
+ let showTree = plugin.settings.treeStructure;
+ let layoutBtn;
+ addEventListener("git-view-refresh", refresh);
+ plugin.app.workspace.onLayoutReady(() => setImmediate(() => {
+ buttons.forEach((btn) => (0, import_obsidian13.setIcon)(btn, btn.getAttr("data-icon"), 16));
+ (0, import_obsidian13.setIcon)(layoutBtn, showTree ? "list" : "folder", 16);
+ }));
+ onDestroy(() => {
+ removeEventListener("git-view-refresh", refresh);
+ });
+ function commit() {
+ $$invalidate(4, loading = true);
+ plugin.gitManager.commit(commitMessage).then(() => {
+ if (commitMessage !== plugin.settings.commitMessage) {
+ $$invalidate(6, commitMessage = "");
+ }
+ }).finally(triggerRefresh);
+ }
+ function refresh() {
+ return __awaiter(this, void 0, void 0, function* () {
+ $$invalidate(5, status = plugin.cachedStatus);
+ if (status) {
+ $$invalidate(8, changeHierarchy = {
+ title: "",
+ children: plugin.gitManager.getTreeStructure(status.changed)
+ });
+ $$invalidate(9, stagedHierarchy = {
+ title: "",
+ children: plugin.gitManager.getTreeStructure(status.staged)
+ });
+ }
+ $$invalidate(4, loading = plugin.loading);
+ });
+ }
+ function stageAll() {
+ $$invalidate(4, loading = true);
+ plugin.gitManager.stageAll().finally(triggerRefresh);
+ }
+ function unstageAll() {
+ $$invalidate(4, loading = true);
+ plugin.gitManager.unstageAll().finally(triggerRefresh);
+ }
+ function push() {
+ $$invalidate(4, loading = true);
+ if (ready) {
+ plugin.push().finally(triggerRefresh);
+ }
+ }
+ function pull() {
+ $$invalidate(4, loading = true);
+ plugin.pullChangesFromRemote().finally(triggerRefresh);
+ }
+ function div0_binding($$value) {
+ binding_callbacks[$$value ? "unshift" : "push"](() => {
+ buttons[0] = $$value;
+ $$invalidate(7, buttons);
+ });
+ }
+ function div1_binding($$value) {
+ binding_callbacks[$$value ? "unshift" : "push"](() => {
+ buttons[1] = $$value;
+ $$invalidate(7, buttons);
+ });
+ }
+ function div2_binding($$value) {
+ binding_callbacks[$$value ? "unshift" : "push"](() => {
+ buttons[2] = $$value;
+ $$invalidate(7, buttons);
+ });
+ }
+ function div3_binding($$value) {
+ binding_callbacks[$$value ? "unshift" : "push"](() => {
+ buttons[3] = $$value;
+ $$invalidate(7, buttons);
+ });
+ }
+ function div4_binding($$value) {
+ binding_callbacks[$$value ? "unshift" : "push"](() => {
+ buttons[4] = $$value;
+ $$invalidate(7, buttons);
+ });
+ }
+ function div5_binding($$value) {
+ binding_callbacks[$$value ? "unshift" : "push"](() => {
+ layoutBtn = $$value;
+ $$invalidate(3, layoutBtn);
+ });
+ }
+ const click_handler = () => {
+ $$invalidate(2, showTree = !showTree);
+ $$invalidate(0, plugin.settings.treeStructure = showTree, plugin);
+ plugin.saveSettings();
+ };
+ function div7_binding($$value) {
+ binding_callbacks[$$value ? "unshift" : "push"](() => {
+ buttons[6] = $$value;
+ $$invalidate(7, buttons);
+ });
+ }
+ function textarea_input_handler() {
+ commitMessage = this.value;
+ $$invalidate(6, commitMessage);
+ }
+ const click_handler_1 = () => $$invalidate(6, commitMessage = "");
+ const click_handler_2 = () => $$invalidate(11, stagedOpen = !stagedOpen);
+ const click_handler_3 = () => $$invalidate(10, changesOpen = !changesOpen);
+ $$self.$$set = ($$props2) => {
+ if ("plugin" in $$props2)
+ $$invalidate(0, plugin = $$props2.plugin);
+ if ("view" in $$props2)
+ $$invalidate(1, view = $$props2.view);
+ };
+ $$self.$$.update = () => {
+ if ($$self.$$.dirty[0] & 12) {
+ $: {
+ if (layoutBtn) {
+ layoutBtn.empty();
+ (0, import_obsidian13.setIcon)(layoutBtn, showTree ? "list" : "folder", 16);
+ }
+ }
+ }
+ };
+ return [
+ plugin,
+ view,
+ showTree,
+ layoutBtn,
+ loading,
+ status,
+ commitMessage,
+ buttons,
+ changeHierarchy,
+ stagedHierarchy,
+ changesOpen,
+ stagedOpen,
+ commit,
+ stageAll,
+ unstageAll,
+ push,
+ pull,
+ div0_binding,
+ div1_binding,
+ div2_binding,
+ div3_binding,
+ div4_binding,
+ div5_binding,
+ click_handler,
+ div7_binding,
+ textarea_input_handler,
+ click_handler_1,
+ click_handler_2,
+ click_handler_3
+ ];
+}
+var GitView = class extends SvelteComponent {
+ constructor(options) {
+ super();
+ init(this, options, instance4, create_fragment4, safe_not_equal, { plugin: 0, view: 1 }, add_css4, [-1, -1]);
+ }
+};
+var gitView_default = GitView;
+
+// src/ui/sidebar/sidebarView.ts
+var GitView2 = class extends import_obsidian14.ItemView {
+ constructor(leaf, plugin) {
+ super(leaf);
+ this.plugin = plugin;
+ this.hoverPopover = null;
+ }
+ getViewType() {
+ return GIT_VIEW_CONFIG.type;
+ }
+ getDisplayText() {
+ return GIT_VIEW_CONFIG.name;
+ }
+ getIcon() {
+ return GIT_VIEW_CONFIG.icon;
+ }
+ onClose() {
+ this._view.$destroy();
+ return super.onClose();
+ }
+ onOpen() {
+ this._view = new gitView_default({
+ target: this.contentEl,
+ props: {
+ plugin: this.plugin,
+ view: this
+ }
+ });
+ return super.onOpen();
+ }
+};
+
+// src/main.ts
+var ObsidianGit = class extends import_obsidian15.Plugin {
+ constructor() {
+ super(...arguments);
+ this.gitReady = false;
+ this.promiseQueue = new PromiseQueue();
+ this.conflictOutputFile = "conflict-files-obsidian-git.md";
+ this.offlineMode = false;
+ this.loading = false;
+ this.debRefresh = (0, import_obsidian15.debounce)(() => {
+ if (this.settings.refreshSourceControl) {
+ this.refresh();
+ }
+ }, 7e3, true);
+ }
+ setState(state) {
+ var _a2;
+ this.state = state;
+ (_a2 = this.statusBar) == null ? void 0 : _a2.display();
+ }
+ updateCachedStatus() {
+ return __async(this, null, function* () {
+ this.cachedStatus = yield this.gitManager.status();
+ return this.cachedStatus;
+ });
+ }
+ refresh() {
+ return __async(this, null, function* () {
+ const gitView = this.app.workspace.getLeavesOfType(GIT_VIEW_CONFIG.type);
+ if (this.settings.changedFilesInStatusBar || gitView.length > 0) {
+ this.loading = true;
+ dispatchEvent(new CustomEvent("git-view-refresh"));
+ yield this.updateCachedStatus();
+ this.loading = false;
+ dispatchEvent(new CustomEvent("git-view-refresh"));
+ }
+ });
+ }
+ onload() {
+ return __async(this, null, function* () {
+ console.log("loading " + this.manifest.name + " plugin");
+ yield this.loadSettings();
+ this.migrateSettings();
+ this.modifyEvent = this.app.vault.on("modify", () => {
+ this.debRefresh();
+ });
+ this.deleteEvent = this.app.vault.on("delete", () => {
+ this.debRefresh();
+ });
+ this.createEvent = this.app.vault.on("create", () => {
+ this.debRefresh();
+ });
+ this.renameEvent = this.app.vault.on("rename", () => {
+ this.debRefresh();
+ });
+ this.registerEvent(this.modifyEvent);
+ this.registerEvent(this.deleteEvent);
+ this.registerEvent(this.createEvent);
+ this.registerEvent(this.renameEvent);
+ addEventListener("git-refresh", this.refresh.bind(this));
+ this.registerView(GIT_VIEW_CONFIG.type, (leaf) => {
+ return new GitView2(leaf, this);
+ });
+ this.registerView(DIFF_VIEW_CONFIG.type, (leaf) => {
+ return new DiffView(leaf, this);
+ });
+ this.app.workspace.registerHoverLinkSource(GIT_VIEW_CONFIG.type, {
+ display: "Git View",
+ defaultMod: true
+ });
+ this.addSettingTab(new ObsidianGitSettingsTab(this.app, this));
+ this.addCommand({
+ id: "open-git-view",
+ name: "Open source control view",
+ callback: () => __async(this, null, function* () {
+ if (this.app.workspace.getLeavesOfType(GIT_VIEW_CONFIG.type).length === 0) {
+ yield this.app.workspace.getRightLeaf(false).setViewState({
+ type: GIT_VIEW_CONFIG.type
+ });
+ }
+ this.app.workspace.revealLeaf(this.app.workspace.getLeavesOfType(GIT_VIEW_CONFIG.type).first());
+ dispatchEvent(new CustomEvent("git-refresh"));
+ })
+ });
+ this.addCommand({
+ id: "open-diff-view",
+ name: "Open diff view",
+ editorCallback: (editor, view) => __async(this, null, function* () {
+ this.app.workspace.createLeafBySplit(view.leaf).setViewState({ type: DIFF_VIEW_CONFIG.type, state: { staged: false, file: view.file.path } });
+ })
+ });
+ this.addCommand({
+ id: "view-file-on-github",
+ name: "Open file on GitHub",
+ editorCallback: (editor, { file }) => openLineInGitHub(editor, file, this.gitManager)
+ });
+ this.addCommand({
+ id: "view-history-on-github",
+ name: "Open file history on GitHub",
+ editorCallback: (_, { file }) => openHistoryInGitHub(file, this.gitManager)
+ });
+ this.addCommand({
+ id: "pull",
+ name: "Pull",
+ callback: () => this.promiseQueue.addTask(() => this.pullChangesFromRemote())
+ });
+ this.addCommand({
+ id: "push",
+ name: "Create backup",
+ callback: () => this.promiseQueue.addTask(() => this.createBackup(false))
+ });
+ this.addCommand({
+ id: "commit-push-specified-message",
+ name: "Create backup with specific message",
+ callback: () => this.promiseQueue.addTask(() => this.createBackup(false, true))
+ });
+ this.addCommand({
+ id: "commit",
+ name: "Commit all changes",
+ callback: () => this.promiseQueue.addTask(() => this.commit(false))
+ });
+ this.addCommand({
+ id: "commit-specified-message",
+ name: "Commit all changes with specific message",
+ callback: () => this.promiseQueue.addTask(() => this.commit(false, true))
+ });
+ this.addCommand({
+ id: "push2",
+ name: "Push",
+ callback: () => this.promiseQueue.addTask(() => this.push())
+ });
+ this.addCommand({
+ id: "edit-remotes",
+ name: "Edit remotes",
+ callback: () => __async(this, null, function* () {
+ return this.editRemotes();
+ })
+ });
+ this.addCommand({
+ id: "remove-remote",
+ name: "Remove remote",
+ callback: () => __async(this, null, function* () {
+ return this.removeRemote();
+ })
+ });
+ this.addCommand({
+ id: "init-repo",
+ name: "Initialize a new repo",
+ callback: () => __async(this, null, function* () {
+ return this.createNewRepo();
+ })
+ });
+ this.addCommand({
+ id: "clone-repo",
+ name: "Clone an existing remote repo",
+ callback: () => __async(this, null, function* () {
+ return this.cloneNewRepo();
+ })
+ });
+ this.addCommand({
+ id: "list-changed-files",
+ name: "List changed files",
+ callback: () => __async(this, null, function* () {
+ const status = yield this.gitManager.status();
+ this.setState(PluginState.idle);
+ new ChangedFilesModal(this, status.changed).open();
+ })
+ });
+ if (this.settings.showStatusBar) {
+ let statusBarEl = this.addStatusBarItem();
+ this.statusBar = new StatusBar(statusBarEl, this);
+ this.registerInterval(window.setInterval(() => this.statusBar.display(), 1e3));
+ }
+ this.app.workspace.onLayoutReady(() => this.init());
+ });
+ }
+ migrateSettings() {
+ if (this.settings.mergeOnPull != void 0) {
+ this.settings.syncMethod = this.settings.mergeOnPull ? "merge" : "rebase";
+ this.settings.mergeOnPull = void 0;
+ return this.saveSettings();
+ }
+ if (this.settings.autoCommitMessage === void 0) {
+ this.settings.autoCommitMessage = this.settings.commitMessage;
+ this.saveSettings();
+ }
+ }
+ onunload() {
+ return __async(this, null, function* () {
+ this.app.workspace.unregisterHoverLinkSource(GIT_VIEW_CONFIG.type);
+ this.app.workspace.detachLeavesOfType(GIT_VIEW_CONFIG.type);
+ this.app.workspace.detachLeavesOfType(DIFF_VIEW_CONFIG.type);
+ this.clearAutoPull();
+ this.clearAutoBackup();
+ removeEventListener("git-refresh", this.refresh.bind(this));
+ this.app.metadataCache.offref(this.modifyEvent);
+ this.app.metadataCache.offref(this.deleteEvent);
+ this.app.metadataCache.offref(this.createEvent);
+ this.app.metadataCache.offref(this.renameEvent);
+ console.log("unloading " + this.manifest.name + " plugin");
+ });
+ }
+ loadSettings() {
+ return __async(this, null, function* () {
+ this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData());
+ });
+ }
+ saveSettings() {
+ return __async(this, null, function* () {
+ yield this.saveData(this.settings);
+ });
+ }
+ saveLastAuto(date, mode) {
+ return __async(this, null, function* () {
+ 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());
+ } else if (mode === "push") {
+ window.localStorage.setItem(this.manifest.id + ":lastAutoPush", date.toString());
+ }
+ });
+ }
+ loadLastAuto() {
+ return __async(this, null, function* () {
+ var _a2, _b, _c;
+ return {
+ "backup": new Date((_a2 = window.localStorage.getItem(this.manifest.id + ":lastAutoBackup")) != null ? _a2 : ""),
+ "pull": new Date((_b = window.localStorage.getItem(this.manifest.id + ":lastAutoPull")) != null ? _b : ""),
+ "push": new Date((_c = window.localStorage.getItem(this.manifest.id + ":lastAutoPush")) != null ? _c : "")
+ };
+ });
+ }
+ init() {
+ return __async(this, null, function* () {
+ try {
+ this.gitManager = new SimpleGit(this);
+ if (this.gitManager instanceof SimpleGit) {
+ yield this.gitManager.setGitInstance();
+ }
+ const result = yield this.gitManager.checkRequirements();
+ switch (result) {
+ case "missing-git":
+ this.displayError("Cannot run git command");
+ break;
+ case "missing-repo":
+ new import_obsidian15.Notice("Can't find a valid git repository. Please create one via the given command.");
+ break;
+ case "valid":
+ this.gitReady = true;
+ this.setState(PluginState.idle);
+ dispatchEvent(new CustomEvent("git-refresh"));
+ if (this.settings.autoPullOnBoot) {
+ this.promiseQueue.addTask(() => this.pullChangesFromRemote());
+ }
+ const lastAutos = yield this.loadLastAuto();
+ if (this.settings.autoSaveInterval > 0) {
+ const now2 = new Date();
+ const diff = this.settings.autoSaveInterval - Math.round((now2.getTime() - lastAutos.backup.getTime()) / 1e3 / 60);
+ this.startAutoBackup(diff <= 0 ? 0 : diff);
+ }
+ if (this.settings.differentIntervalCommitAndPush && this.settings.autoPushInterval > 0) {
+ const now2 = new Date();
+ const diff = this.settings.autoPushInterval - Math.round((now2.getTime() - lastAutos.push.getTime()) / 1e3 / 60);
+ this.startAutoPush(diff <= 0 ? 0 : diff);
+ }
+ if (this.settings.autoPullInterval > 0) {
+ const now2 = new Date();
+ const diff = this.settings.autoPullInterval - Math.round((now2.getTime() - lastAutos.pull.getTime()) / 1e3 / 60);
+ this.startAutoPull(diff <= 0 ? 0 : diff);
+ }
+ break;
+ default:
+ console.log("Something weird happened. The 'checkRequirements' result is " + result);
+ }
+ } catch (error) {
+ this.displayError(error);
+ console.error(error);
+ }
+ });
+ }
+ createNewRepo() {
+ return __async(this, null, function* () {
+ yield this.gitManager.init();
+ new import_obsidian15.Notice("Initialized new repo");
+ });
+ }
+ cloneNewRepo() {
+ return __async(this, null, function* () {
+ const modal = new GeneralModal(this.app, [], "Enter remote URL");
+ const url = yield modal.open();
+ if (url) {
+ let dir = yield new GeneralModal(this.app, [], "Enter directory for clone. It needs to be empty or not existent.").open();
+ if (dir) {
+ dir = path2.normalize(dir);
+ new import_obsidian15.Notice(`Cloning new repo into "${dir}"`);
+ yield this.gitManager.clone(url, dir);
+ new import_obsidian15.Notice("Cloned new repo");
+ }
+ }
+ });
+ }
+ isAllInitialized() {
+ return __async(this, null, function* () {
+ if (!this.gitReady) {
+ yield this.init();
+ }
+ return this.gitReady;
+ });
+ }
+ pullChangesFromRemote() {
+ return __async(this, null, function* () {
+ if (!(yield this.isAllInitialized()))
+ return;
+ const filesUpdated = yield this.pull();
+ if (!filesUpdated) {
+ this.displayMessage("Everything is up-to-date");
+ }
+ if (this.gitManager instanceof SimpleGit) {
+ const status = yield this.gitManager.status();
+ if (status.conflicted.length > 0) {
+ this.displayError(`You have ${status.conflicted.length} conflict ${status.conflicted.length > 1 ? "files" : "file"}`);
+ this.handleConflict(status.conflicted);
+ }
+ }
+ dispatchEvent(new CustomEvent("git-refresh"));
+ this.lastUpdate = Date.now();
+ this.setState(PluginState.idle);
+ });
+ }
+ createBackup(fromAutoBackup, requestCustomMessage = false) {
+ return __async(this, null, function* () {
+ if (!(yield this.isAllInitialized()))
+ return;
+ if (!(yield this.commit(fromAutoBackup, requestCustomMessage)))
+ return;
+ if (!this.settings.disablePush) {
+ if (yield this.gitManager.canPush()) {
+ if (this.settings.pullBeforePush) {
+ yield this.pull();
+ }
+ yield this.push();
+ } else {
+ this.displayMessage("No changes to push");
+ }
+ }
+ this.setState(PluginState.idle);
+ });
+ }
+ commit(fromAutoBackup, requestCustomMessage = false) {
+ return __async(this, null, function* () {
+ if (!(yield this.isAllInitialized()))
+ return false;
+ const file = this.app.vault.getAbstractFileByPath(this.conflictOutputFile);
+ if (file)
+ yield this.app.vault.delete(file);
+ let status;
+ if (this.gitManager instanceof SimpleGit) {
+ status = yield this.gitManager.status();
+ if (fromAutoBackup && status.conflicted.length > 0) {
+ this.displayError(`Did not commit, because you have ${status.conflicted.length} conflict ${status.conflicted.length > 1 ? "files" : "file"}. Please resolve them and commit per command.`);
+ this.handleConflict(status.conflicted);
+ return;
+ }
+ } else {
+ status = yield this.gitManager.status();
+ }
+ const changedFiles = status.changed;
+ if (changedFiles.length !== 0) {
+ let commitMessage = fromAutoBackup ? this.settings.autoCommitMessage : this.settings.commitMessage;
+ if (fromAutoBackup && this.settings.customMessageOnAutoBackup || requestCustomMessage) {
+ if (!this.settings.disablePopups && fromAutoBackup) {
+ new import_obsidian15.Notice("Auto backup: Please enter a custom commit message. Leave empty to abort");
+ }
+ const tempMessage = yield new CustomMessageModal(this, true).open();
+ if (tempMessage != void 0 && tempMessage != "" && tempMessage != "...") {
+ commitMessage = tempMessage;
+ } else {
+ this.setState(PluginState.idle);
+ return false;
+ }
+ }
+ const committedFiles = yield this.gitManager.commitAll(commitMessage);
+ this.displayMessage(`Committed ${committedFiles} ${committedFiles > 1 ? "files" : "file"}`);
+ } else {
+ this.displayMessage("No changes to commit");
+ }
+ dispatchEvent(new CustomEvent("git-refresh"));
+ this.setState(PluginState.idle);
+ return true;
+ });
+ }
+ push() {
+ return __async(this, null, function* () {
+ if (!(yield this.isAllInitialized()))
+ return false;
+ if (!this.remotesAreSet()) {
+ return false;
+ }
+ const file = this.app.vault.getAbstractFileByPath(this.conflictOutputFile);
+ if (file)
+ yield this.app.vault.delete(file);
+ let status;
+ if (this.gitManager instanceof SimpleGit && (status = yield this.gitManager.status()).conflicted.length > 0) {
+ this.displayError(`Cannot push. You have ${status.conflicted.length} conflict ${status.conflicted.length > 1 ? "files" : "file"}`);
+ this.handleConflict(status.conflicted);
+ return false;
+ } else {
+ const pushedFiles = yield this.gitManager.push();
+ this.lastUpdate = Date.now();
+ if (pushedFiles > 0) {
+ this.displayMessage(`Pushed ${pushedFiles} ${pushedFiles > 1 ? "files" : "file"} to remote`);
+ } else {
+ this.displayMessage(`No changes to push`);
+ }
+ this.offlineMode = false;
+ this.setState(PluginState.idle);
+ return true;
+ }
+ });
+ }
+ pull() {
+ return __async(this, null, function* () {
+ const pulledFilesLength = yield this.gitManager.pull();
+ this.offlineMode = false;
+ if (pulledFilesLength > 0) {
+ this.displayMessage(`Pulled ${pulledFilesLength} ${pulledFilesLength > 1 ? "files" : "file"} from remote`);
+ }
+ return pulledFilesLength != 0;
+ });
+ }
+ remotesAreSet() {
+ return __async(this, null, function* () {
+ if (!(yield this.gitManager.branchInfo()).tracking) {
+ new import_obsidian15.Notice("No upstream branch is set. Please select one.");
+ const remoteBranch = yield this.selectRemoteBranch();
+ if (remoteBranch == void 0) {
+ this.displayError("Did not push. No upstream-branch is set!", 1e4);
+ this.setState(PluginState.idle);
+ return false;
+ } else {
+ yield this.gitManager.updateUpstreamBranch(remoteBranch);
+ return true;
+ }
+ }
+ return true;
+ });
+ }
+ startAutoBackup(minutes) {
+ const time = (minutes != null ? minutes : this.settings.autoSaveInterval) * 6e4;
+ if (this.settings.autoBackupAfterFileChange) {
+ if (minutes === 0) {
+ this.doAutoBackup();
+ } else {
+ this.onFileModifyEventRef = this.app.vault.on("modify", () => this.autoBackupDebouncer());
+ this.autoBackupDebouncer = (0, import_obsidian15.debounce)(() => this.doAutoBackup(), time, true);
+ }
+ } else {
+ this.timeoutIDBackup = window.setTimeout(() => this.doAutoBackup(), time);
+ }
+ }
+ doAutoBackup() {
+ this.promiseQueue.addTask(() => {
+ if (this.settings.differentIntervalCommitAndPush) {
+ return this.commit(true);
+ } else {
+ return this.createBackup(true);
+ }
+ });
+ this.saveLastAuto(new Date(), "backup");
+ this.saveSettings();
+ this.startAutoBackup();
+ }
+ startAutoPull(minutes) {
+ this.timeoutIDPull = window.setTimeout(() => {
+ this.promiseQueue.addTask(() => this.pullChangesFromRemote());
+ this.saveLastAuto(new Date(), "pull");
+ this.saveSettings();
+ this.startAutoPull();
+ }, (minutes != null ? minutes : this.settings.autoPullInterval) * 6e4);
+ }
+ startAutoPush(minutes) {
+ this.timeoutIDPush = window.setTimeout(() => {
+ this.promiseQueue.addTask(() => this.push());
+ this.saveLastAuto(new Date(), "push");
+ this.saveSettings();
+ this.startAutoPush();
+ }, (minutes != null ? minutes : this.settings.autoPushInterval) * 6e4);
+ }
+ clearAutoBackup() {
+ var _a2;
+ let wasActive = false;
+ if (this.timeoutIDBackup) {
+ window.clearTimeout(this.timeoutIDBackup);
+ this.timeoutIDBackup = void 0;
+ wasActive = true;
+ }
+ if (this.onFileModifyEventRef) {
+ (_a2 = this.autoBackupDebouncer) == null ? void 0 : _a2.cancel();
+ this.app.vault.offref(this.onFileModifyEventRef);
+ this.onFileModifyEventRef = void 0;
+ wasActive = true;
+ }
+ return wasActive;
+ }
+ clearAutoPull() {
+ if (this.timeoutIDPull) {
+ window.clearTimeout(this.timeoutIDPull);
+ this.timeoutIDPull = void 0;
+ return true;
+ }
+ return false;
+ }
+ clearAutoPush() {
+ if (this.timeoutIDPush) {
+ window.clearTimeout(this.timeoutIDPush);
+ this.timeoutIDPush = void 0;
+ return true;
+ }
+ return false;
+ }
+ handleConflict(conflicted) {
+ return __async(this, null, function* () {
+ this.setState(PluginState.conflicted);
+ const lines = [
+ "# Conflict files",
+ "Please resolve them and commit per command (This file will be deleted before the commit).",
+ ...conflicted.map((e) => {
+ const file = this.app.vault.getAbstractFileByPath(e);
+ if (file instanceof import_obsidian15.TFile) {
+ const link = this.app.metadataCache.fileToLinktext(file, "/");
+ return `- [[${link}]]`;
+ } else {
+ return `- Not a file: ${e}`;
+ }
+ })
+ ];
+ this.writeAndOpenFile(lines.join("\n"));
+ });
+ }
+ editRemotes() {
+ return __async(this, null, function* () {
+ if (!(yield this.isAllInitialized()))
+ return;
+ const remotes = yield this.gitManager.getRemotes();
+ const nameModal = new GeneralModal(this.app, remotes, "Select or create a new remote by typing its name and selecting it");
+ const remoteName = yield nameModal.open();
+ if (remoteName) {
+ const urlModal = new GeneralModal(this.app, [], "Enter the remote URL");
+ const remoteURL = yield urlModal.open();
+ yield this.gitManager.setRemote(remoteName, remoteURL);
+ return remoteName;
+ }
+ });
+ }
+ selectRemoteBranch() {
+ return __async(this, null, function* () {
+ let remotes = yield this.gitManager.getRemotes();
+ let selectedRemote;
+ if (remotes.length === 0) {
+ selectedRemote = yield this.editRemotes();
+ if (selectedRemote == void 0) {
+ remotes = yield this.gitManager.getRemotes();
+ }
+ }
+ const nameModal = new GeneralModal(this.app, remotes, "Select or create a new remote by typing its name and selecting it");
+ const remoteName = selectedRemote != null ? selectedRemote : yield nameModal.open();
+ if (remoteName) {
+ this.displayMessage("Fetching remote branches");
+ yield this.gitManager.fetch(remoteName);
+ const branches = yield this.gitManager.getRemoteBranches(remoteName);
+ const branchModal = new GeneralModal(this.app, branches, "Select or create a new remote branch by typing its name and selecting it");
+ return yield branchModal.open();
+ }
+ });
+ }
+ removeRemote() {
+ return __async(this, null, function* () {
+ if (!(yield this.isAllInitialized()))
+ return;
+ const remotes = yield this.gitManager.getRemotes();
+ const nameModal = new GeneralModal(this.app, remotes, "Select a remote");
+ const remoteName = yield nameModal.open();
+ if (remoteName) {
+ this.gitManager.removeRemote(remoteName);
+ }
+ });
+ }
+ writeAndOpenFile(text2) {
+ return __async(this, null, function* () {
+ yield this.app.vault.adapter.write(this.conflictOutputFile, text2);
+ let fileIsAlreadyOpened = false;
+ this.app.workspace.iterateAllLeaves((leaf) => {
+ if (leaf.getDisplayText() != "" && this.conflictOutputFile.startsWith(leaf.getDisplayText())) {
+ fileIsAlreadyOpened = true;
+ }
+ });
+ if (!fileIsAlreadyOpened) {
+ this.app.workspace.openLinkText(this.conflictOutputFile, "/", true);
+ }
+ });
+ }
+ displayMessage(message, timeout = 4 * 1e3) {
+ var _a2;
+ (_a2 = this.statusBar) == null ? void 0 : _a2.displayMessage(message.toLowerCase(), timeout);
+ if (!this.settings.disablePopups) {
+ new import_obsidian15.Notice(message, 5 * 1e3);
+ }
+ console.log(`git obsidian message: ${message}`);
+ }
+ displayError(message, timeout = 10 * 1e3) {
+ var _a2;
+ message = message.toString();
+ new import_obsidian15.Notice(message, timeout);
+ console.log(`git obsidian error: ${message}`);
+ (_a2 = this.statusBar) == null ? void 0 : _a2.displayMessage(message.toLowerCase(), timeout);
+ }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});
+/*!
+ Copyright (c) 2016 Jed Watson.
+ Licensed under the MIT License (MIT), see
+ http://jedwatson.github.io/classnames
+*/
+/*! *****************************************************************************
+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.
+***************************************************************************** */
diff --git a/.obsidian/plugins/obsidian-git/manifest.json b/.obsidian/plugins/obsidian-git/manifest.json
new file mode 100644
index 0000000..f09ed67
--- /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.26.1"
+}
diff --git a/.obsidian/plugins/obsidian-git/styles.css b/.obsidian/plugins/obsidian-git/styles.css
new file mode 100644
index 0000000..68a06f0
--- /dev/null
+++ b/.obsidian/plugins/obsidian-git/styles.css
@@ -0,0 +1,413 @@
+@keyframes loading {
+ 0% {
+ transform: rotate(0deg);
+ }
+ 100% {
+ transform: rotate(360deg);
+ }
+}
+.loading > svg {
+ animation: 2s linear infinite loading;
+ transform-origin: 50% 50%;
+ display: inline-block;
+}
+
+.obsidian-git-center {
+ margin: auto;
+ width: 50%;
+}
+
+.tooltip.mod-left {
+ overflow-wrap: break-word;
+}
+
+.tooltip.mod-right {
+ overflow-wrap: break-word;
+}
+
+.obsidian-git-shortcuts {
+ margin: 10px;
+}
+
+.diff-err {
+ height: 100%;
+ display: flex;
+ justify-content: center;
+ flex-direction: column;
+ align-items: center;
+}
+
+.diff-err-sign {
+ font-size: 2em;
+}
+
+.workspace-leaf-content[data-type="diff-view"] .d2h-d-none {
+ display: none;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-wrapper {
+ text-align: left;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-header {
+ background-color: var(--background-primary);
+ border-bottom: 1px solid var(--interactive-accent);
+ font-family: var(--font-monospace);
+ height: 35px;
+ padding: 5px 10px;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-header,
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-stats {
+ display: -webkit-box;
+ display: -ms-flexbox;
+ display: flex;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-stats {
+ font-size: 14px;
+ margin-left: auto;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-lines-added {
+ border: 1px solid #b4e2b4;
+ border-radius: 5px 0 0 5px;
+ color: #399839;
+ padding: 2px;
+ text-align: right;
+ vertical-align: middle;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-lines-deleted {
+ border: 1px solid #e9aeae;
+ border-radius: 0 5px 5px 0;
+ color: #c33;
+ margin-left: 1px;
+ padding: 2px;
+ text-align: left;
+ vertical-align: middle;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-name-wrapper {
+ -webkit-box-align: center;
+ -ms-flex-align: center;
+ align-items: center;
+ display: -webkit-box;
+ display: -ms-flexbox;
+ display: flex;
+ font-size: 15px;
+ width: 100%;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-name {
+ overflow-x: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-wrapper {
+ border: 1px solid var(--background-modifier-border);
+ border-radius: 3px;
+ margin-bottom: 1em;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-collapse {
+ -webkit-box-pack: end;
+ -ms-flex-pack: end;
+ -webkit-box-align: center;
+ -ms-flex-align: center;
+ align-items: center;
+ border: 1px solid var(--background-modifier-border);
+ border-radius: 3px;
+ cursor: pointer;
+ display: none;
+ font-size: 12px;
+ justify-content: flex-end;
+ padding: 4px 8px;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-collapse.d2h-selected {
+ background-color: #c8e1ff;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-collapse-input {
+ margin: 0 4px 0 0;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-diff-table {
+ border-collapse: collapse;
+ font-family: Menlo, Consolas, monospace;
+ font-size: 13px;
+ width: 100%;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-files-diff {
+ width: 100%;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-diff {
+ overflow-y: hidden;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-side-diff {
+ display: inline-block;
+ margin-bottom: -8px;
+ margin-right: -4px;
+ overflow-x: scroll;
+ overflow-y: hidden;
+ width: 50%;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-line {
+ padding: 0 8em;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-line,
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-line {
+ display: inline-block;
+ -webkit-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+ white-space: nowrap;
+ width: 100%;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-line {
+ padding: 0 4.5em;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-line-ctn {
+ word-wrap: normal;
+ background: none;
+ display: inline-block;
+ padding: 0;
+ -webkit-user-select: text;
+ -moz-user-select: text;
+ -ms-user-select: text;
+ user-select: text;
+ vertical-align: middle;
+ white-space: pre;
+ width: 100%;
+}
+.theme-light .workspace-leaf-content[data-type="diff-view"] .d2h-code-line del,
+.theme-light
+ .workspace-leaf-content[data-type="diff-view"]
+ .d2h-code-side-line
+ del {
+ background-color: #ffb6ba;
+}
+.theme-dark .workspace-leaf-content[data-type="diff-view"] .d2h-code-line del,
+.theme-dark
+ .workspace-leaf-content[data-type="diff-view"]
+ .d2h-code-side-line
+ del {
+ background-color: #8d232881;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-line del,
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-line ins,
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-line del,
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-line ins {
+ border-radius: 0.2em;
+ display: inline-block;
+ margin-top: -1px;
+ text-decoration: none;
+ vertical-align: middle;
+}
+.theme-light .workspace-leaf-content[data-type="diff-view"] .d2h-code-line ins,
+.theme-light
+ .workspace-leaf-content[data-type="diff-view"]
+ .d2h-code-side-line
+ ins {
+ background-color: #97f295;
+ text-align: left;
+}
+.theme-dark .workspace-leaf-content[data-type="diff-view"] .d2h-code-line ins,
+.theme-dark
+ .workspace-leaf-content[data-type="diff-view"]
+ .d2h-code-side-line
+ ins {
+ background-color: #1d921996;
+ text-align: left;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-line-prefix {
+ word-wrap: normal;
+ background: none;
+ display: inline;
+ padding: 0;
+ white-space: pre;
+}
+.workspace-leaf-content[data-type="diff-view"] .line-num1 {
+ float: left;
+}
+.workspace-leaf-content[data-type="diff-view"] .line-num1,
+.workspace-leaf-content[data-type="diff-view"] .line-num2 {
+ -webkit-box-sizing: border-box;
+ box-sizing: border-box;
+ overflow: hidden;
+ padding: 0 0.5em;
+ text-overflow: ellipsis;
+ width: 3.5em;
+}
+.workspace-leaf-content[data-type="diff-view"] .line-num2 {
+ float: right;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-linenumber {
+ background-color: var(--background-primary);
+ border: solid var(--background-modifier-border);
+ border-width: 0 1px;
+ -webkit-box-sizing: border-box;
+ box-sizing: border-box;
+ color: var(--text-muted);
+ cursor: pointer;
+ display: inline-block;
+ position: absolute;
+ text-align: right;
+ width: 7.5em;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-linenumber:after {
+ content: "\200b";
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-linenumber {
+ background-color: var(--background-primary);
+ border: solid var(--background-modifier-border);
+ border-width: 0 1px;
+ -webkit-box-sizing: border-box;
+ box-sizing: border-box;
+ color: var(--text-muted);
+ cursor: pointer;
+ display: inline-block;
+ overflow: hidden;
+ padding: 0 0.5em;
+ position: absolute;
+ text-align: right;
+ text-overflow: ellipsis;
+ width: 4em;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-linenumber:after {
+ content: "\200b";
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-emptyplaceholder,
+.workspace-leaf-content[data-type="diff-view"] .d2h-emptyplaceholder {
+ background-color: var(--background-primary);
+ border-color: var(--background-modifier-border);
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-line-prefix,
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-linenumber,
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-linenumber,
+.workspace-leaf-content[data-type="diff-view"] .d2h-emptyplaceholder {
+ -webkit-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-linenumber,
+.workspace-leaf-content[data-type="diff-view"] .d2h-code-side-linenumber {
+ direction: rtl;
+}
+.theme-light .workspace-leaf-content[data-type="diff-view"] .d2h-del {
+ background-color: #fee8e9;
+ border-color: #e9aeae;
+}
+.theme-light .workspace-leaf-content[data-type="diff-view"] .d2h-ins {
+ background-color: #dfd;
+ border-color: #b4e2b4;
+}
+.theme-dark .workspace-leaf-content[data-type="diff-view"] .d2h-del {
+ background-color: #521b1d83;
+ border-color: #691d1d73;
+}
+.theme-dark .workspace-leaf-content[data-type="diff-view"] .d2h-ins {
+ background-color: rgba(30, 71, 30, 0.5);
+ border-color: #13501381;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-info {
+ background-color: var(--background-primary);
+ border-color: var(--background-modifier-border);
+ color: var(--text-normal);
+}
+.theme-light
+ .workspace-leaf-content[data-type="diff-view"]
+ .d2h-file-diff
+ .d2h-del.d2h-change {
+ background-color: #fdf2d0;
+}
+.theme-dark
+ .workspace-leaf-content[data-type="diff-view"]
+ .d2h-file-diff
+ .d2h-del.d2h-change {
+ background-color: #55492480;
+}
+.theme-light
+ .workspace-leaf-content[data-type="diff-view"]
+ .d2h-file-diff
+ .d2h-ins.d2h-change {
+ background-color: #ded;
+}
+.theme-dark
+ .workspace-leaf-content[data-type="diff-view"]
+ .d2h-file-diff
+ .d2h-ins.d2h-change {
+ background-color: rgba(37, 78, 37, 0.418);
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-list-wrapper {
+ margin-bottom: 10px;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-list-wrapper a {
+ color: #3572b0;
+ text-decoration: none;
+}
+.workspace-leaf-content[data-type="diff-view"]
+ .d2h-file-list-wrapper
+ a:visited {
+ color: #3572b0;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-list-header {
+ text-align: left;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-list-title {
+ font-weight: 700;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-list-line {
+ display: -webkit-box;
+ display: -ms-flexbox;
+ display: flex;
+ text-align: left;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-list {
+ display: block;
+ list-style: none;
+ margin: 0;
+ padding: 0;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-list > li {
+ border-bottom: 1px solid var(--background-modifier-border);
+ margin: 0;
+ padding: 5px 10px;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-list > li:last-child {
+ border-bottom: none;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-file-switch {
+ cursor: pointer;
+ display: none;
+ font-size: 10px;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-icon {
+ fill: currentColor;
+ margin-right: 10px;
+ vertical-align: middle;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-deleted {
+ color: #c33;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-added {
+ color: #399839;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-changed {
+ color: #d0b44c;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-moved {
+ color: #3572b0;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-tag {
+ background-color: var(--background-primary);
+ display: -webkit-box;
+ display: -ms-flexbox;
+ display: flex;
+ font-size: 10px;
+ margin-left: 5px;
+ padding: 0 2px;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-deleted-tag {
+ border: 2px solid #c33;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-added-tag {
+ border: 1px solid #399839;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-changed-tag {
+ border: 1px solid #d0b44c;
+}
+.workspace-leaf-content[data-type="diff-view"] .d2h-moved-tag {
+ border: 1px solid #3572b0;
+}
diff --git a/.obsidian/plugins/table-editor-obsidian/data.json b/.obsidian/plugins/table-editor-obsidian/data.json
new file mode 100644
index 0000000..9009465
--- /dev/null
+++ b/.obsidian/plugins/table-editor-obsidian/data.json
@@ -0,0 +1,6 @@
+{
+ "formatType": "normal",
+ "showRibbonIcon": true,
+ "bindEnter": true,
+ "bindTab": true
+}
\ No newline at end of file
diff --git a/.obsidian/plugins/table-editor-obsidian/main.js b/.obsidian/plugins/table-editor-obsidian/main.js
new file mode 100644
index 0000000..193b689
--- /dev/null
+++ b/.obsidian/plugins/table-editor-obsidian/main.js
@@ -0,0 +1,24029 @@
+'use strict';
+
+var obsidian = require('obsidian');
+var state = require('@codemirror/state');
+var view = require('@codemirror/view');
+
+/*! *****************************************************************************
+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) {
+ 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 };
+ }
+}
+
+var icons = {
+ spreadsheet: "\n",
+ alignLeft: "\n",
+ alignCenter: "\n",
+ alignRight: "\n",
+ deleteColumn: "\n",
+ deleteRow: "\n",
+ insertColumn: "\n",
+ insertRow: "\n",
+ moveColumnLeft: "\n",
+ moveColumnRight: "\n",
+ moveRowDown: "\n",
+ moveRowUp: "\n",
+ sortAsc: "\n",
+ sortDesc: "\n",
+ formula: "\n",
+ help: "\n",
+ csv: "\n",
+ arrowenter: "\n",
+ arrowtab: "\n",
+};
+var addIcons = function () {
+ Object.keys(icons).forEach(function (key) {
+ // Don't add the 'help' icon here as it will overwrite the native one.
+ if (key !== 'help') {
+ obsidian.addIcon(key, icons[key]);
+ }
+ });
+};
+
+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 getAugmentedNamespace(n) {
+ if (n.__esModule) return n;
+ var a = Object.defineProperty({}, '__esModule', {value: true});
+ Object.keys(n).forEach(function (k) {
+ var d = Object.getOwnPropertyDescriptor(n, k);
+ Object.defineProperty(a, k, d.get ? d : {
+ enumerable: true,
+ get: function () {
+ return n[k];
+ }
+ });
+ });
+ return a;
+}
+
+function commonjsRequire () {
+ throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+}
+
+var point = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Point = void 0;
+/**
+ * A `Point` represents a point in the text editor.
+ */
+class Point {
+ /**
+ * Creates a new `Point` object.
+ *
+ * @param row - Row of the point, starts from 0.
+ * @param column - Column of the point, starts from 0.
+ */
+ constructor(row, column) {
+ this.row = row;
+ this.column = column;
+ }
+ /**
+ * Checks if the point is equal to another point.
+ */
+ equals(point) {
+ return this.row === point.row && this.column === point.column;
+ }
+}
+exports.Point = Point;
+});
+
+var range = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Range = void 0;
+/**
+ * A `Range` object represents a range in the text editor.
+ */
+class Range {
+ /**
+ * Creates a new `Range` object.
+ *
+ * @param start - The start point of the range.
+ * @param end - The end point of the range.
+ */
+ constructor(start, end) {
+ this.start = start;
+ this.end = end;
+ }
+}
+exports.Range = Range;
+});
+
+var focus = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Focus = void 0;
+/**
+ * A `Focus` object represents which cell is focused in the table.
+ *
+ * Note that `row` and `column` properties specifiy a cell's position in the
+ * table, not the cursor's position in the text editor as {@link Point} class.
+ *
+ * @private
+ */
+class Focus {
+ /**
+ * Creates a new `Focus` object.
+ *
+ * @param row - Row of the focused cell.
+ * @param column - Column of the focused cell.
+ * @param offset - Raw offset in the cell.
+ */
+ constructor(row, column, offset) {
+ this.row = row;
+ this.column = column;
+ this.offset = offset;
+ }
+ /**
+ * Checks if two focuses point the same cell.
+ * Offsets are ignored.
+ */
+ posEquals(focus) {
+ return this.row === focus.row && this.column === focus.column;
+ }
+ /**
+ * Creates a copy of the focus object by setting its row to the specified value.
+ *
+ * @param row - Row of the focused cell.
+ * @returns A new focus object with the specified row.
+ */
+ setRow(row) {
+ return new Focus(row, this.column, this.offset);
+ }
+ /**
+ * Creates a copy of the focus object by setting its column to the specified value.
+ *
+ * @param column - Column of the focused cell.
+ * @returns A new focus object with the specified column.
+ */
+ setColumn(column) {
+ return new Focus(this.row, column, this.offset);
+ }
+ /**
+ * Creates a copy of the focus object by setting its offset to the specified value.
+ *
+ * @param offset - Offset in the focused cell.
+ * @returns A new focus object with the specified offset.
+ */
+ setOffset(offset) {
+ return new Focus(this.row, this.column, offset);
+ }
+}
+exports.Focus = Focus;
+});
+
+var alignment = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderAlignment = exports.DefaultAlignment = exports.Alignment = void 0;
+/**
+ * Represents column alignment.
+ *
+ * - `Alignment.NONE` - Use default alignment.
+ * - `Alignment.LEFT` - Align left.
+ * - `Alignment.RIGHT` - Align right.
+ * - `Alignment.CENTER` - Align center.
+ *
+ */
+var Alignment;
+(function (Alignment) {
+ Alignment["NONE"] = "none";
+ Alignment["LEFT"] = "left";
+ Alignment["RIGHT"] = "right";
+ Alignment["CENTER"] = "center";
+})(Alignment = exports.Alignment || (exports.Alignment = {}));
+/**
+ * Represents default column alignment
+ *
+ * - `DefaultAlignment.LEFT` - Align left.
+ * - `DefaultAlignment.RIGHT` - Align right.
+ * - `DefaultAlignment.CENTER` - Align center.
+ *
+ */
+var DefaultAlignment;
+(function (DefaultAlignment) {
+ DefaultAlignment["LEFT"] = "left";
+ DefaultAlignment["RIGHT"] = "right";
+ DefaultAlignment["CENTER"] = "center";
+})(DefaultAlignment = exports.DefaultAlignment || (exports.DefaultAlignment = {}));
+/**
+ * Represents alignment of header cells.
+ *
+ * - `HeaderAlignment.FOLLOW` - Follow column's alignment.
+ * - `HeaderAlignment.LEFT` - Align left.
+ * - `HeaderAlignment.RIGHT` - Align right.
+ * - `HeaderAlignment.CENTER` - Align center.
+ *
+ */
+var HeaderAlignment;
+(function (HeaderAlignment) {
+ HeaderAlignment["FOLLOW"] = "follow";
+ HeaderAlignment["LEFT"] = "left";
+ HeaderAlignment["RIGHT"] = "right";
+ HeaderAlignment["CENTER"] = "center";
+})(HeaderAlignment = exports.HeaderAlignment || (exports.HeaderAlignment = {}));
+});
+
+var tableCell = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableCell = void 0;
+
+/**
+ * A `TableCell` object represents a table cell.
+ *
+ * @private
+ */
+class TableCell {
+ /**
+ * Creates a new `TableCell` object.
+ *
+ * @param rawContent - Raw content of the cell.
+ */
+ constructor(rawContent) {
+ this.rawContent = rawContent;
+ this.content = rawContent.trim();
+ this.paddingLeft =
+ this.content === ''
+ ? this.rawContent === ''
+ ? 0
+ : 1
+ : this.rawContent.length - this.rawContent.trimLeft().length;
+ this.paddingRight =
+ this.rawContent.length - this.content.length - this.paddingLeft;
+ }
+ /**
+ * Convers the cell to a text representation.
+ *
+ * @returns The raw content of the cell.
+ */
+ toText() {
+ return this.rawContent;
+ }
+ /**
+ * Checks if the cell is a delimiter i.e. it only contains hyphens `-` with optional one
+ * leading and trailing colons `:`.
+ *
+ * @returns `true` if the cell is a delimiter.
+ */
+ isDelimiter() {
+ return /^\s*:?-+:?\s*$/.test(this.rawContent);
+ }
+ /**
+ * Returns the alignment the cell represents.
+ *
+ * @returns The alignment the cell represents; `undefined` if the cell is not a delimiter.
+ */
+ getAlignment() {
+ if (!this.isDelimiter()) {
+ return undefined;
+ }
+ if (this.content[0] === ':') {
+ if (this.content[this.content.length - 1] === ':') {
+ return alignment.Alignment.CENTER;
+ }
+ return alignment.Alignment.LEFT;
+ }
+ if (this.content[this.content.length - 1] === ':') {
+ return alignment.Alignment.RIGHT;
+ }
+ return alignment.Alignment.NONE;
+ }
+ /**
+ * Computes a relative position in the trimmed content from that in the raw content.
+ *
+ * @param rawOffset - Relative position in the raw content.
+ * @returns - Relative position in the trimmed content.
+ */
+ computeContentOffset(rawOffset) {
+ if (this.content === '') {
+ return 0;
+ }
+ if (rawOffset < this.paddingLeft) {
+ return 0;
+ }
+ if (rawOffset < this.paddingLeft + this.content.length) {
+ return rawOffset - this.paddingLeft;
+ }
+ return this.content.length;
+ }
+ /**
+ * Computes a relative position in the raw content from that in the trimmed content.
+ *
+ * @param contentOffset - Relative position in the trimmed content.
+ * @returns - Relative position in the raw content.
+ */
+ computeRawOffset(contentOffset) {
+ return contentOffset + this.paddingLeft;
+ }
+}
+exports.TableCell = TableCell;
+});
+
+var tableRow = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableRow = void 0;
+
+/**
+ * A `TableRow` object represents a table row.
+ *
+ * @private
+ */
+class TableRow {
+ /**
+ * Creates a new `TableRow` objec.
+ *
+ * @param cells - Cells that the row contains.
+ * @param marginLeft - Margin string at the left of the row.
+ * @param marginRight - Margin string at the right of the row.
+ */
+ constructor(cells, marginLeft, marginRight) {
+ this._cells = cells.slice();
+ this.marginLeft = marginLeft;
+ this.marginRight = marginRight;
+ }
+ /**
+ * Gets the number of the cells in the row.
+ */
+ getWidth() {
+ return this._cells.length;
+ }
+ /**
+ * Returns the cells that the row contains.
+ */
+ getCells() {
+ return this._cells.slice();
+ }
+ /**
+ * Gets a cell at the specified index.
+ *
+ * @param index - Index.
+ * @returns The cell at the specified index if exists; `undefined` if no cell is found.
+ */
+ getCellAt(index) {
+ return this._cells[index];
+ }
+ /**
+ * Sets a cell in the row to a new value, returning a copy of the row
+ * with the modified value.
+ *
+ * If an invalid index is provided, the row will be unchanged.
+ */
+ setCellAt(index, value) {
+ const cells = this.getCells(); // a copy
+ cells[index] = new tableCell.TableCell(value);
+ return new TableRow(cells, this.marginLeft, this.marginRight);
+ }
+ /**
+ * Convers the row to a text representation.
+ */
+ toText() {
+ if (this._cells.length === 0) {
+ return this.marginLeft;
+ }
+ const cells = this._cells.map((cell) => cell.toText()).join('|');
+ return `${this.marginLeft}|${cells}|${this.marginRight}`;
+ }
+ /**
+ * Checks if the row is a delimiter or not.
+ *
+ * @returns `true` if the row is a delimiter i.e. all the cells contained are delimiters.
+ */
+ isDelimiter() {
+ return this._cells.every((cell) => cell.isDelimiter());
+ }
+}
+exports.TableRow = TableRow;
+});
+
+var neverthrow = createCommonjsModule(function (module, exports) {
+/**
+ * Retrieved from
+ * https://github.com/supermacro/neverthrow
+ *
+ * MIT License
+ * Copyright (c) 2019 Giorgio Delgado
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Err = exports.Ok = exports.err = exports.ok = void 0;
+const ok = (value) => new Ok(value);
+exports.ok = ok;
+const err = (err) => new Err(err);
+exports.err = err;
+class Ok {
+ constructor(value) {
+ this.value = value;
+ this.match = (ok, _err) => ok(this.value);
+ }
+ isOk() {
+ return true;
+ }
+ isErr() {
+ return !this.isOk();
+ }
+ map(f) {
+ return exports.ok(f(this.value));
+ }
+ mapErr(_f) {
+ return exports.ok(this.value);
+ }
+ // add info on how this is really useful for converting a
+ // Result, E1>
+ // into a Result
+ andThen(f) {
+ return f(this.value);
+ }
+ unwrapOr(_v) {
+ return this.value;
+ }
+ _unsafeUnwrap() {
+ return this.value;
+ }
+ _unsafeUnwrapErr() {
+ throw new Error('Called `_unsafeUnwrapErr` on an Ok');
+ }
+}
+exports.Ok = Ok;
+class Err {
+ constructor(error) {
+ this.error = error;
+ this.match = (_ok, err) => err(this.error);
+ }
+ isOk() {
+ return false;
+ }
+ isErr() {
+ return !this.isOk();
+ }
+ map(_f) {
+ return exports.err(this.error);
+ }
+ mapErr(f) {
+ return exports.err(f(this.error));
+ }
+ andThen(_f) {
+ return exports.err(this.error);
+ }
+ unwrapOr(v) {
+ return v;
+ }
+ _unsafeUnwrap() {
+ throw new Error('Called `_unsafeUnwrap` on an Err');
+ }
+ _unsafeUnwrapErr() {
+ return this.error;
+ }
+}
+exports.Err = Err;
+});
+
+var ast_utils = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyPrintAST = exports.checkChildLength = exports.checkType = exports.errRelativeReferenceIndex = exports.errIndex0 = void 0;
+exports.errIndex0 = new Error('Index 0 used to create a reference');
+exports.errRelativeReferenceIndex = new Error('Can not use relative reference where absolute reference is required');
+const checkType = (ast, ...expectedTypes) => {
+ if (expectedTypes.indexOf(ast.type) >= 0) {
+ return;
+ }
+ return new Error(`Formula element '${ast.text}' is a ${ast.type} but expected ` +
+ `one of ${expectedTypes} in this position.`);
+};
+exports.checkType = checkType;
+const checkChildLength = (ast, len) => {
+ if (ast.children.length === len) {
+ return;
+ }
+ return new Error(`Formula element '${ast.text}' was expected to have ${len} ` +
+ `elements, but had ${ast.children.length}`);
+};
+exports.checkChildLength = checkChildLength;
+const prettyPrintAST = (token, level = 0) => {
+ console.log(' '.repeat(level) +
+ `|-${token.type}${token.children.length === 0 ? '=' + token.text : ''}`);
+ if (token.children) {
+ token.children.forEach((c) => {
+ exports.prettyPrintAST(c, level + 1);
+ });
+ }
+};
+exports.prettyPrintAST = prettyPrintAST;
+});
+
+var lodash = createCommonjsModule(function (module, exports) {
+(function() {
+
+ /** Used as a safe reference for `undefined` in pre-ES5 environments. */
+ var undefined$1;
+
+ /** Used as the semantic version number. */
+ var VERSION = '4.17.20';
+
+ /** Used as the size to enable large array optimizations. */
+ var LARGE_ARRAY_SIZE = 200;
+
+ /** Error message constants. */
+ var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',
+ FUNC_ERROR_TEXT = 'Expected a function';
+
+ /** Used to stand-in for `undefined` hash values. */
+ var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+ /** Used as the maximum memoize cache size. */
+ var MAX_MEMOIZE_SIZE = 500;
+
+ /** Used as the internal argument placeholder. */
+ var PLACEHOLDER = '__lodash_placeholder__';
+
+ /** Used to compose bitmasks for cloning. */
+ var CLONE_DEEP_FLAG = 1,
+ CLONE_FLAT_FLAG = 2,
+ CLONE_SYMBOLS_FLAG = 4;
+
+ /** Used to compose bitmasks for value comparisons. */
+ var COMPARE_PARTIAL_FLAG = 1,
+ COMPARE_UNORDERED_FLAG = 2;
+
+ /** Used to compose bitmasks for function metadata. */
+ var WRAP_BIND_FLAG = 1,
+ WRAP_BIND_KEY_FLAG = 2,
+ WRAP_CURRY_BOUND_FLAG = 4,
+ WRAP_CURRY_FLAG = 8,
+ WRAP_CURRY_RIGHT_FLAG = 16,
+ WRAP_PARTIAL_FLAG = 32,
+ WRAP_PARTIAL_RIGHT_FLAG = 64,
+ WRAP_ARY_FLAG = 128,
+ WRAP_REARG_FLAG = 256,
+ WRAP_FLIP_FLAG = 512;
+
+ /** Used as default options for `_.truncate`. */
+ var DEFAULT_TRUNC_LENGTH = 30,
+ DEFAULT_TRUNC_OMISSION = '...';
+
+ /** Used to detect hot functions by number of calls within a span of milliseconds. */
+ var HOT_COUNT = 800,
+ HOT_SPAN = 16;
+
+ /** Used to indicate the type of lazy iteratees. */
+ var LAZY_FILTER_FLAG = 1,
+ LAZY_MAP_FLAG = 2,
+ LAZY_WHILE_FLAG = 3;
+
+ /** Used as references for various `Number` constants. */
+ var INFINITY = 1 / 0,
+ MAX_SAFE_INTEGER = 9007199254740991,
+ MAX_INTEGER = 1.7976931348623157e+308,
+ NAN = 0 / 0;
+
+ /** Used as references for the maximum length and index of an array. */
+ var MAX_ARRAY_LENGTH = 4294967295,
+ MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,
+ HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
+
+ /** Used to associate wrap methods with their bit flags. */
+ var wrapFlags = [
+ ['ary', WRAP_ARY_FLAG],
+ ['bind', WRAP_BIND_FLAG],
+ ['bindKey', WRAP_BIND_KEY_FLAG],
+ ['curry', WRAP_CURRY_FLAG],
+ ['curryRight', WRAP_CURRY_RIGHT_FLAG],
+ ['flip', WRAP_FLIP_FLAG],
+ ['partial', WRAP_PARTIAL_FLAG],
+ ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
+ ['rearg', WRAP_REARG_FLAG]
+ ];
+
+ /** `Object#toString` result references. */
+ var argsTag = '[object Arguments]',
+ arrayTag = '[object Array]',
+ asyncTag = '[object AsyncFunction]',
+ boolTag = '[object Boolean]',
+ dateTag = '[object Date]',
+ domExcTag = '[object DOMException]',
+ errorTag = '[object Error]',
+ funcTag = '[object Function]',
+ genTag = '[object GeneratorFunction]',
+ mapTag = '[object Map]',
+ numberTag = '[object Number]',
+ nullTag = '[object Null]',
+ objectTag = '[object Object]',
+ promiseTag = '[object Promise]',
+ proxyTag = '[object Proxy]',
+ regexpTag = '[object RegExp]',
+ setTag = '[object Set]',
+ stringTag = '[object String]',
+ symbolTag = '[object Symbol]',
+ undefinedTag = '[object Undefined]',
+ weakMapTag = '[object WeakMap]',
+ weakSetTag = '[object WeakSet]';
+
+ var arrayBufferTag = '[object ArrayBuffer]',
+ dataViewTag = '[object DataView]',
+ float32Tag = '[object Float32Array]',
+ float64Tag = '[object Float64Array]',
+ int8Tag = '[object Int8Array]',
+ int16Tag = '[object Int16Array]',
+ int32Tag = '[object Int32Array]',
+ uint8Tag = '[object Uint8Array]',
+ uint8ClampedTag = '[object Uint8ClampedArray]',
+ uint16Tag = '[object Uint16Array]',
+ uint32Tag = '[object Uint32Array]';
+
+ /** Used to match empty string literals in compiled template source. */
+ var reEmptyStringLeading = /\b__p \+= '';/g,
+ reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
+ reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
+
+ /** Used to match HTML entities and HTML characters. */
+ var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,
+ reUnescapedHtml = /[&<>"']/g,
+ reHasEscapedHtml = RegExp(reEscapedHtml.source),
+ reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
+
+ /** Used to match template delimiters. */
+ var reEscape = /<%-([\s\S]+?)%>/g,
+ reEvaluate = /<%([\s\S]+?)%>/g,
+ reInterpolate = /<%=([\s\S]+?)%>/g;
+
+ /** Used to match property names within property paths. */
+ var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
+ reIsPlainProp = /^\w*$/,
+ rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+
+ /**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+ var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,
+ reHasRegExpChar = RegExp(reRegExpChar.source);
+
+ /** Used to match leading and trailing whitespace. */
+ var reTrim = /^\s+|\s+$/g,
+ reTrimStart = /^\s+/,
+ reTrimEnd = /\s+$/;
+
+ /** Used to match wrap detail comments. */
+ var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
+ reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,
+ reSplitDetails = /,? & /;
+
+ /** Used to match words composed of alphanumeric characters. */
+ var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+
+ /** Used to match backslashes in property paths. */
+ var reEscapeChar = /\\(\\)?/g;
+
+ /**
+ * Used to match
+ * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).
+ */
+ var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
+
+ /** Used to match `RegExp` flags from their coerced string values. */
+ var reFlags = /\w*$/;
+
+ /** Used to detect bad signed hexadecimal string values. */
+ var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+ /** Used to detect binary string values. */
+ var reIsBinary = /^0b[01]+$/i;
+
+ /** Used to detect host constructors (Safari). */
+ var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+ /** Used to detect octal string values. */
+ var reIsOctal = /^0o[0-7]+$/i;
+
+ /** Used to detect unsigned integer values. */
+ var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+ /** Used to match Latin Unicode letters (excluding mathematical operators). */
+ var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+
+ /** Used to ensure capturing order of template delimiters. */
+ var reNoMatch = /($^)/;
+
+ /** Used to match unescaped characters in compiled string literals. */
+ var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
+
+ /** Used to compose unicode character classes. */
+ var rsAstralRange = '\\ud800-\\udfff',
+ rsComboMarksRange = '\\u0300-\\u036f',
+ reComboHalfMarksRange = '\\ufe20-\\ufe2f',
+ rsComboSymbolsRange = '\\u20d0-\\u20ff',
+ rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
+ rsDingbatRange = '\\u2700-\\u27bf',
+ rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
+ rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
+ rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
+ rsPunctuationRange = '\\u2000-\\u206f',
+ rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',
+ rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
+ rsVarRange = '\\ufe0e\\ufe0f',
+ rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
+
+ /** Used to compose unicode capture groups. */
+ var rsApos = "['\u2019]",
+ rsAstral = '[' + rsAstralRange + ']',
+ rsBreak = '[' + rsBreakRange + ']',
+ rsCombo = '[' + rsComboRange + ']',
+ rsDigits = '\\d+',
+ rsDingbat = '[' + rsDingbatRange + ']',
+ rsLower = '[' + rsLowerRange + ']',
+ rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
+ rsFitz = '\\ud83c[\\udffb-\\udfff]',
+ rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
+ rsNonAstral = '[^' + rsAstralRange + ']',
+ rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
+ rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
+ rsUpper = '[' + rsUpperRange + ']',
+ rsZWJ = '\\u200d';
+
+ /** Used to compose unicode regexes. */
+ var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',
+ rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',
+ rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
+ rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
+ reOptMod = rsModifier + '?',
+ rsOptVar = '[' + rsVarRange + ']?',
+ rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
+ rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',
+ rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',
+ rsSeq = rsOptVar + reOptMod + rsOptJoin,
+ rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,
+ rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
+
+ /** Used to match apostrophes. */
+ var reApos = RegExp(rsApos, 'g');
+
+ /**
+ * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
+ * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
+ */
+ var reComboMark = RegExp(rsCombo, 'g');
+
+ /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
+ var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
+
+ /** Used to match complex or compound words. */
+ var reUnicodeWord = RegExp([
+ rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
+ rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',
+ rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
+ rsUpper + '+' + rsOptContrUpper,
+ rsOrdUpper,
+ rsOrdLower,
+ rsDigits,
+ rsEmoji
+ ].join('|'), 'g');
+
+ /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
+ var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']');
+
+ /** Used to detect strings that need a more robust regexp to match words. */
+ var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+
+ /** Used to assign default `context` object properties. */
+ var contextProps = [
+ 'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',
+ 'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',
+ 'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',
+ 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',
+ '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'
+ ];
+
+ /** Used to make template sourceURLs easier to identify. */
+ var templateCounter = -1;
+
+ /** Used to identify `toStringTag` values of typed arrays. */
+ var typedArrayTags = {};
+ typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+ typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+ typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+ typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+ typedArrayTags[uint32Tag] = true;
+ typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
+ typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
+ typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
+ typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+ typedArrayTags[mapTag] = typedArrayTags[numberTag] =
+ typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
+ typedArrayTags[setTag] = typedArrayTags[stringTag] =
+ typedArrayTags[weakMapTag] = false;
+
+ /** Used to identify `toStringTag` values supported by `_.clone`. */
+ var cloneableTags = {};
+ cloneableTags[argsTag] = cloneableTags[arrayTag] =
+ cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
+ cloneableTags[boolTag] = cloneableTags[dateTag] =
+ cloneableTags[float32Tag] = cloneableTags[float64Tag] =
+ cloneableTags[int8Tag] = cloneableTags[int16Tag] =
+ cloneableTags[int32Tag] = cloneableTags[mapTag] =
+ cloneableTags[numberTag] = cloneableTags[objectTag] =
+ cloneableTags[regexpTag] = cloneableTags[setTag] =
+ cloneableTags[stringTag] = cloneableTags[symbolTag] =
+ cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+ cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+ cloneableTags[errorTag] = cloneableTags[funcTag] =
+ cloneableTags[weakMapTag] = false;
+
+ /** Used to map Latin Unicode letters to basic Latin letters. */
+ var deburredLetters = {
+ // Latin-1 Supplement block.
+ '\xc0': 'A', '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
+ '\xe0': 'a', '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
+ '\xc7': 'C', '\xe7': 'c',
+ '\xd0': 'D', '\xf0': 'd',
+ '\xc8': 'E', '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
+ '\xe8': 'e', '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
+ '\xcc': 'I', '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
+ '\xec': 'i', '\xed': 'i', '\xee': 'i', '\xef': 'i',
+ '\xd1': 'N', '\xf1': 'n',
+ '\xd2': 'O', '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
+ '\xf2': 'o', '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
+ '\xd9': 'U', '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
+ '\xf9': 'u', '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
+ '\xdd': 'Y', '\xfd': 'y', '\xff': 'y',
+ '\xc6': 'Ae', '\xe6': 'ae',
+ '\xde': 'Th', '\xfe': 'th',
+ '\xdf': 'ss',
+ // Latin Extended-A block.
+ '\u0100': 'A', '\u0102': 'A', '\u0104': 'A',
+ '\u0101': 'a', '\u0103': 'a', '\u0105': 'a',
+ '\u0106': 'C', '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
+ '\u0107': 'c', '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
+ '\u010e': 'D', '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
+ '\u0112': 'E', '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
+ '\u0113': 'e', '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
+ '\u011c': 'G', '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
+ '\u011d': 'g', '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
+ '\u0124': 'H', '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
+ '\u0128': 'I', '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
+ '\u0129': 'i', '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
+ '\u0134': 'J', '\u0135': 'j',
+ '\u0136': 'K', '\u0137': 'k', '\u0138': 'k',
+ '\u0139': 'L', '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
+ '\u013a': 'l', '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
+ '\u0143': 'N', '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
+ '\u0144': 'n', '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
+ '\u014c': 'O', '\u014e': 'O', '\u0150': 'O',
+ '\u014d': 'o', '\u014f': 'o', '\u0151': 'o',
+ '\u0154': 'R', '\u0156': 'R', '\u0158': 'R',
+ '\u0155': 'r', '\u0157': 'r', '\u0159': 'r',
+ '\u015a': 'S', '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
+ '\u015b': 's', '\u015d': 's', '\u015f': 's', '\u0161': 's',
+ '\u0162': 'T', '\u0164': 'T', '\u0166': 'T',
+ '\u0163': 't', '\u0165': 't', '\u0167': 't',
+ '\u0168': 'U', '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
+ '\u0169': 'u', '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
+ '\u0174': 'W', '\u0175': 'w',
+ '\u0176': 'Y', '\u0177': 'y', '\u0178': 'Y',
+ '\u0179': 'Z', '\u017b': 'Z', '\u017d': 'Z',
+ '\u017a': 'z', '\u017c': 'z', '\u017e': 'z',
+ '\u0132': 'IJ', '\u0133': 'ij',
+ '\u0152': 'Oe', '\u0153': 'oe',
+ '\u0149': "'n", '\u017f': 's'
+ };
+
+ /** Used to map characters to HTML entities. */
+ var htmlEscapes = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": '''
+ };
+
+ /** Used to map HTML entities to characters. */
+ var htmlUnescapes = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ ''': "'"
+ };
+
+ /** Used to escape characters for inclusion in compiled string literals. */
+ var stringEscapes = {
+ '\\': '\\',
+ "'": "'",
+ '\n': 'n',
+ '\r': 'r',
+ '\u2028': 'u2028',
+ '\u2029': 'u2029'
+ };
+
+ /** Built-in method references without a dependency on `root`. */
+ var freeParseFloat = parseFloat,
+ freeParseInt = parseInt;
+
+ /** Detect free variable `global` from Node.js. */
+ var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+
+ /** Detect free variable `self`. */
+ var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+ /** Used as a reference to the global object. */
+ var root = freeGlobal || freeSelf || Function('return this')();
+
+ /** Detect free variable `exports`. */
+ var freeExports = exports && !exports.nodeType && exports;
+
+ /** Detect free variable `module`. */
+ var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
+
+ /** Detect the popular CommonJS extension `module.exports`. */
+ var moduleExports = freeModule && freeModule.exports === freeExports;
+
+ /** Detect free variable `process` from Node.js. */
+ var freeProcess = moduleExports && freeGlobal.process;
+
+ /** Used to access faster Node.js helpers. */
+ var nodeUtil = (function() {
+ try {
+ // Use `util.types` for Node.js 10+.
+ var types = freeModule && freeModule.require && freeModule.require('util').types;
+
+ if (types) {
+ return types;
+ }
+
+ // Legacy `process.binding('util')` for Node.js < 10.
+ return freeProcess && freeProcess.binding && freeProcess.binding('util');
+ } catch (e) {}
+ }());
+
+ /* Node.js helper references. */
+ var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,
+ nodeIsDate = nodeUtil && nodeUtil.isDate,
+ nodeIsMap = nodeUtil && nodeUtil.isMap,
+ nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,
+ nodeIsSet = nodeUtil && nodeUtil.isSet,
+ nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * A faster alternative to `Function#apply`, this function invokes `func`
+ * with the `this` binding of `thisArg` and the arguments of `args`.
+ *
+ * @private
+ * @param {Function} func The function to invoke.
+ * @param {*} thisArg The `this` binding of `func`.
+ * @param {Array} args The arguments to invoke `func` with.
+ * @returns {*} Returns the result of `func`.
+ */
+ function apply(func, thisArg, args) {
+ switch (args.length) {
+ case 0: return func.call(thisArg);
+ case 1: return func.call(thisArg, args[0]);
+ case 2: return func.call(thisArg, args[0], args[1]);
+ case 3: return func.call(thisArg, args[0], args[1], args[2]);
+ }
+ return func.apply(thisArg, args);
+ }
+
+ /**
+ * A specialized version of `baseAggregator` for arrays.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} setter The function to set `accumulator` values.
+ * @param {Function} iteratee The iteratee to transform keys.
+ * @param {Object} accumulator The initial aggregated object.
+ * @returns {Function} Returns `accumulator`.
+ */
+ function arrayAggregator(array, setter, iteratee, accumulator) {
+ var index = -1,
+ length = array == null ? 0 : array.length;
+
+ while (++index < length) {
+ var value = array[index];
+ setter(accumulator, value, iteratee(value), array);
+ }
+ return accumulator;
+ }
+
+ /**
+ * A specialized version of `_.forEach` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns `array`.
+ */
+ function arrayEach(array, iteratee) {
+ var index = -1,
+ length = array == null ? 0 : array.length;
+
+ while (++index < length) {
+ if (iteratee(array[index], index, array) === false) {
+ break;
+ }
+ }
+ return array;
+ }
+
+ /**
+ * A specialized version of `_.forEachRight` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns `array`.
+ */
+ function arrayEachRight(array, iteratee) {
+ var length = array == null ? 0 : array.length;
+
+ while (length--) {
+ if (iteratee(array[length], length, array) === false) {
+ break;
+ }
+ }
+ return array;
+ }
+
+ /**
+ * A specialized version of `_.every` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if all elements pass the predicate check,
+ * else `false`.
+ */
+ function arrayEvery(array, predicate) {
+ var index = -1,
+ length = array == null ? 0 : array.length;
+
+ while (++index < length) {
+ if (!predicate(array[index], index, array)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * A specialized version of `_.filter` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+ function arrayFilter(array, predicate) {
+ var index = -1,
+ length = array == null ? 0 : array.length,
+ resIndex = 0,
+ result = [];
+
+ while (++index < length) {
+ var value = array[index];
+ if (predicate(value, index, array)) {
+ result[resIndex++] = value;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * A specialized version of `_.includes` for arrays without support for
+ * specifying an index to search from.
+ *
+ * @private
+ * @param {Array} [array] The array to inspect.
+ * @param {*} target The value to search for.
+ * @returns {boolean} Returns `true` if `target` is found, else `false`.
+ */
+ function arrayIncludes(array, value) {
+ var length = array == null ? 0 : array.length;
+ return !!length && baseIndexOf(array, value, 0) > -1;
+ }
+
+ /**
+ * This function is like `arrayIncludes` except that it accepts a comparator.
+ *
+ * @private
+ * @param {Array} [array] The array to inspect.
+ * @param {*} target The value to search for.
+ * @param {Function} comparator The comparator invoked per element.
+ * @returns {boolean} Returns `true` if `target` is found, else `false`.
+ */
+ function arrayIncludesWith(array, value, comparator) {
+ var index = -1,
+ length = array == null ? 0 : array.length;
+
+ while (++index < length) {
+ if (comparator(value, array[index])) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * A specialized version of `_.map` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+ function arrayMap(array, iteratee) {
+ var index = -1,
+ length = array == null ? 0 : array.length,
+ result = Array(length);
+
+ while (++index < length) {
+ result[index] = iteratee(array[index], index, array);
+ }
+ return result;
+ }
+
+ /**
+ * Appends the elements of `values` to `array`.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to append.
+ * @returns {Array} Returns `array`.
+ */
+ function arrayPush(array, values) {
+ var index = -1,
+ length = values.length,
+ offset = array.length;
+
+ while (++index < length) {
+ array[offset + index] = values[index];
+ }
+ return array;
+ }
+
+ /**
+ * A specialized version of `_.reduce` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @param {boolean} [initAccum] Specify using the first element of `array` as
+ * the initial value.
+ * @returns {*} Returns the accumulated value.
+ */
+ function arrayReduce(array, iteratee, accumulator, initAccum) {
+ var index = -1,
+ length = array == null ? 0 : array.length;
+
+ if (initAccum && length) {
+ accumulator = array[++index];
+ }
+ while (++index < length) {
+ accumulator = iteratee(accumulator, array[index], index, array);
+ }
+ return accumulator;
+ }
+
+ /**
+ * A specialized version of `_.reduceRight` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @param {boolean} [initAccum] Specify using the last element of `array` as
+ * the initial value.
+ * @returns {*} Returns the accumulated value.
+ */
+ function arrayReduceRight(array, iteratee, accumulator, initAccum) {
+ var length = array == null ? 0 : array.length;
+ if (initAccum && length) {
+ accumulator = array[--length];
+ }
+ while (length--) {
+ accumulator = iteratee(accumulator, array[length], length, array);
+ }
+ return accumulator;
+ }
+
+ /**
+ * A specialized version of `_.some` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ * else `false`.
+ */
+ function arraySome(array, predicate) {
+ var index = -1,
+ length = array == null ? 0 : array.length;
+
+ while (++index < length) {
+ if (predicate(array[index], index, array)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Gets the size of an ASCII `string`.
+ *
+ * @private
+ * @param {string} string The string inspect.
+ * @returns {number} Returns the string size.
+ */
+ var asciiSize = baseProperty('length');
+
+ /**
+ * Converts an ASCII `string` to an array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the converted array.
+ */
+ function asciiToArray(string) {
+ return string.split('');
+ }
+
+ /**
+ * Splits an ASCII `string` into an array of its words.
+ *
+ * @private
+ * @param {string} The string to inspect.
+ * @returns {Array} Returns the words of `string`.
+ */
+ function asciiWords(string) {
+ return string.match(reAsciiWord) || [];
+ }
+
+ /**
+ * The base implementation of methods like `_.findKey` and `_.findLastKey`,
+ * without support for iteratee shorthands, which iterates over `collection`
+ * using `eachFunc`.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to inspect.
+ * @param {Function} predicate The function invoked per iteration.
+ * @param {Function} eachFunc The function to iterate over `collection`.
+ * @returns {*} Returns the found element or its key, else `undefined`.
+ */
+ function baseFindKey(collection, predicate, eachFunc) {
+ var result;
+ eachFunc(collection, function(value, key, collection) {
+ if (predicate(value, key, collection)) {
+ result = key;
+ return false;
+ }
+ });
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.findIndex` and `_.findLastIndex` without
+ * support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Function} predicate The function invoked per iteration.
+ * @param {number} fromIndex The index to search from.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+ function baseFindIndex(array, predicate, fromIndex, fromRight) {
+ var length = array.length,
+ index = fromIndex + (fromRight ? 1 : -1);
+
+ while ((fromRight ? index-- : ++index < length)) {
+ if (predicate(array[index], index, array)) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} fromIndex The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+ function baseIndexOf(array, value, fromIndex) {
+ return value === value
+ ? strictIndexOf(array, value, fromIndex)
+ : baseFindIndex(array, baseIsNaN, fromIndex);
+ }
+
+ /**
+ * This function is like `baseIndexOf` except that it accepts a comparator.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} fromIndex The index to search from.
+ * @param {Function} comparator The comparator invoked per element.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+ function baseIndexOfWith(array, value, fromIndex, comparator) {
+ var index = fromIndex - 1,
+ length = array.length;
+
+ while (++index < length) {
+ if (comparator(array[index], value)) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * The base implementation of `_.isNaN` without support for number objects.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
+ */
+ function baseIsNaN(value) {
+ return value !== value;
+ }
+
+ /**
+ * The base implementation of `_.mean` and `_.meanBy` without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {number} Returns the mean.
+ */
+ function baseMean(array, iteratee) {
+ var length = array == null ? 0 : array.length;
+ return length ? (baseSum(array, iteratee) / length) : NAN;
+ }
+
+ /**
+ * The base implementation of `_.property` without support for deep paths.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+ function baseProperty(key) {
+ return function(object) {
+ return object == null ? undefined$1 : object[key];
+ };
+ }
+
+ /**
+ * The base implementation of `_.propertyOf` without support for deep paths.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Function} Returns the new accessor function.
+ */
+ function basePropertyOf(object) {
+ return function(key) {
+ return object == null ? undefined$1 : object[key];
+ };
+ }
+
+ /**
+ * The base implementation of `_.reduce` and `_.reduceRight`, without support
+ * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} accumulator The initial value.
+ * @param {boolean} initAccum Specify using the first or last element of
+ * `collection` as the initial value.
+ * @param {Function} eachFunc The function to iterate over `collection`.
+ * @returns {*} Returns the accumulated value.
+ */
+ function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
+ eachFunc(collection, function(value, index, collection) {
+ accumulator = initAccum
+ ? (initAccum = false, value)
+ : iteratee(accumulator, value, index, collection);
+ });
+ return accumulator;
+ }
+
+ /**
+ * The base implementation of `_.sortBy` which uses `comparer` to define the
+ * sort order of `array` and replaces criteria objects with their corresponding
+ * values.
+ *
+ * @private
+ * @param {Array} array The array to sort.
+ * @param {Function} comparer The function to define sort order.
+ * @returns {Array} Returns `array`.
+ */
+ function baseSortBy(array, comparer) {
+ var length = array.length;
+
+ array.sort(comparer);
+ while (length--) {
+ array[length] = array[length].value;
+ }
+ return array;
+ }
+
+ /**
+ * The base implementation of `_.sum` and `_.sumBy` without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {number} Returns the sum.
+ */
+ function baseSum(array, iteratee) {
+ var result,
+ index = -1,
+ length = array.length;
+
+ while (++index < length) {
+ var current = iteratee(array[index]);
+ if (current !== undefined$1) {
+ result = result === undefined$1 ? current : (result + current);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.times` without support for iteratee shorthands
+ * or max array length checks.
+ *
+ * @private
+ * @param {number} n The number of times to invoke `iteratee`.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the array of results.
+ */
+ function baseTimes(n, iteratee) {
+ var index = -1,
+ result = Array(n);
+
+ while (++index < n) {
+ result[index] = iteratee(index);
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array
+ * of key-value pairs for `object` corresponding to the property names of `props`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array} props The property names to get values for.
+ * @returns {Object} Returns the key-value pairs.
+ */
+ function baseToPairs(object, props) {
+ return arrayMap(props, function(key) {
+ return [key, object[key]];
+ });
+ }
+
+ /**
+ * The base implementation of `_.unary` without support for storing metadata.
+ *
+ * @private
+ * @param {Function} func The function to cap arguments for.
+ * @returns {Function} Returns the new capped function.
+ */
+ function baseUnary(func) {
+ return function(value) {
+ return func(value);
+ };
+ }
+
+ /**
+ * The base implementation of `_.values` and `_.valuesIn` which creates an
+ * array of `object` property values corresponding to the property names
+ * of `props`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array} props The property names to get values for.
+ * @returns {Object} Returns the array of property values.
+ */
+ function baseValues(object, props) {
+ return arrayMap(props, function(key) {
+ return object[key];
+ });
+ }
+
+ /**
+ * Checks if a `cache` value for `key` exists.
+ *
+ * @private
+ * @param {Object} cache The cache to query.
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+ function cacheHas(cache, key) {
+ return cache.has(key);
+ }
+
+ /**
+ * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol
+ * that is not found in the character symbols.
+ *
+ * @private
+ * @param {Array} strSymbols The string symbols to inspect.
+ * @param {Array} chrSymbols The character symbols to find.
+ * @returns {number} Returns the index of the first unmatched string symbol.
+ */
+ function charsStartIndex(strSymbols, chrSymbols) {
+ var index = -1,
+ length = strSymbols.length;
+
+ while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
+ return index;
+ }
+
+ /**
+ * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol
+ * that is not found in the character symbols.
+ *
+ * @private
+ * @param {Array} strSymbols The string symbols to inspect.
+ * @param {Array} chrSymbols The character symbols to find.
+ * @returns {number} Returns the index of the last unmatched string symbol.
+ */
+ function charsEndIndex(strSymbols, chrSymbols) {
+ var index = strSymbols.length;
+
+ while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
+ return index;
+ }
+
+ /**
+ * Gets the number of `placeholder` occurrences in `array`.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} placeholder The placeholder to search for.
+ * @returns {number} Returns the placeholder count.
+ */
+ function countHolders(array, placeholder) {
+ var length = array.length,
+ result = 0;
+
+ while (length--) {
+ if (array[length] === placeholder) {
+ ++result;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
+ * letters to basic Latin letters.
+ *
+ * @private
+ * @param {string} letter The matched letter to deburr.
+ * @returns {string} Returns the deburred letter.
+ */
+ var deburrLetter = basePropertyOf(deburredLetters);
+
+ /**
+ * Used by `_.escape` to convert characters to HTML entities.
+ *
+ * @private
+ * @param {string} chr The matched character to escape.
+ * @returns {string} Returns the escaped character.
+ */
+ var escapeHtmlChar = basePropertyOf(htmlEscapes);
+
+ /**
+ * Used by `_.template` to escape characters for inclusion in compiled string literals.
+ *
+ * @private
+ * @param {string} chr The matched character to escape.
+ * @returns {string} Returns the escaped character.
+ */
+ function escapeStringChar(chr) {
+ return '\\' + stringEscapes[chr];
+ }
+
+ /**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+ function getValue(object, key) {
+ return object == null ? undefined$1 : object[key];
+ }
+
+ /**
+ * Checks if `string` contains Unicode symbols.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {boolean} Returns `true` if a symbol is found, else `false`.
+ */
+ function hasUnicode(string) {
+ return reHasUnicode.test(string);
+ }
+
+ /**
+ * Checks if `string` contains a word composed of Unicode symbols.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {boolean} Returns `true` if a word is found, else `false`.
+ */
+ function hasUnicodeWord(string) {
+ return reHasUnicodeWord.test(string);
+ }
+
+ /**
+ * Converts `iterator` to an array.
+ *
+ * @private
+ * @param {Object} iterator The iterator to convert.
+ * @returns {Array} Returns the converted array.
+ */
+ function iteratorToArray(iterator) {
+ var data,
+ result = [];
+
+ while (!(data = iterator.next()).done) {
+ result.push(data.value);
+ }
+ return result;
+ }
+
+ /**
+ * Converts `map` to its key-value pairs.
+ *
+ * @private
+ * @param {Object} map The map to convert.
+ * @returns {Array} Returns the key-value pairs.
+ */
+ function mapToArray(map) {
+ var index = -1,
+ result = Array(map.size);
+
+ map.forEach(function(value, key) {
+ result[++index] = [key, value];
+ });
+ return result;
+ }
+
+ /**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+ function overArg(func, transform) {
+ return function(arg) {
+ return func(transform(arg));
+ };
+ }
+
+ /**
+ * Replaces all `placeholder` elements in `array` with an internal placeholder
+ * and returns an array of their indexes.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {*} placeholder The placeholder to replace.
+ * @returns {Array} Returns the new array of placeholder indexes.
+ */
+ function replaceHolders(array, placeholder) {
+ var index = -1,
+ length = array.length,
+ resIndex = 0,
+ result = [];
+
+ while (++index < length) {
+ var value = array[index];
+ if (value === placeholder || value === PLACEHOLDER) {
+ array[index] = PLACEHOLDER;
+ result[resIndex++] = index;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Converts `set` to an array of its values.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the values.
+ */
+ function setToArray(set) {
+ var index = -1,
+ result = Array(set.size);
+
+ set.forEach(function(value) {
+ result[++index] = value;
+ });
+ return result;
+ }
+
+ /**
+ * Converts `set` to its value-value pairs.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the value-value pairs.
+ */
+ function setToPairs(set) {
+ var index = -1,
+ result = Array(set.size);
+
+ set.forEach(function(value) {
+ result[++index] = [value, value];
+ });
+ return result;
+ }
+
+ /**
+ * A specialized version of `_.indexOf` which performs strict equality
+ * comparisons of values, i.e. `===`.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} fromIndex The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+ function strictIndexOf(array, value, fromIndex) {
+ var index = fromIndex - 1,
+ length = array.length;
+
+ while (++index < length) {
+ if (array[index] === value) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * A specialized version of `_.lastIndexOf` which performs strict equality
+ * comparisons of values, i.e. `===`.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} fromIndex The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+ function strictLastIndexOf(array, value, fromIndex) {
+ var index = fromIndex + 1;
+ while (index--) {
+ if (array[index] === value) {
+ return index;
+ }
+ }
+ return index;
+ }
+
+ /**
+ * Gets the number of symbols in `string`.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {number} Returns the string size.
+ */
+ function stringSize(string) {
+ return hasUnicode(string)
+ ? unicodeSize(string)
+ : asciiSize(string);
+ }
+
+ /**
+ * Converts `string` to an array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the converted array.
+ */
+ function stringToArray(string) {
+ return hasUnicode(string)
+ ? unicodeToArray(string)
+ : asciiToArray(string);
+ }
+
+ /**
+ * Used by `_.unescape` to convert HTML entities to characters.
+ *
+ * @private
+ * @param {string} chr The matched character to unescape.
+ * @returns {string} Returns the unescaped character.
+ */
+ var unescapeHtmlChar = basePropertyOf(htmlUnescapes);
+
+ /**
+ * Gets the size of a Unicode `string`.
+ *
+ * @private
+ * @param {string} string The string inspect.
+ * @returns {number} Returns the string size.
+ */
+ function unicodeSize(string) {
+ var result = reUnicode.lastIndex = 0;
+ while (reUnicode.test(string)) {
+ ++result;
+ }
+ return result;
+ }
+
+ /**
+ * Converts a Unicode `string` to an array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the converted array.
+ */
+ function unicodeToArray(string) {
+ return string.match(reUnicode) || [];
+ }
+
+ /**
+ * Splits a Unicode `string` into an array of its words.
+ *
+ * @private
+ * @param {string} The string to inspect.
+ * @returns {Array} Returns the words of `string`.
+ */
+ function unicodeWords(string) {
+ return string.match(reUnicodeWord) || [];
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Create a new pristine `lodash` function using the `context` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.1.0
+ * @category Util
+ * @param {Object} [context=root] The context object.
+ * @returns {Function} Returns a new `lodash` function.
+ * @example
+ *
+ * _.mixin({ 'foo': _.constant('foo') });
+ *
+ * var lodash = _.runInContext();
+ * lodash.mixin({ 'bar': lodash.constant('bar') });
+ *
+ * _.isFunction(_.foo);
+ * // => true
+ * _.isFunction(_.bar);
+ * // => false
+ *
+ * lodash.isFunction(lodash.foo);
+ * // => false
+ * lodash.isFunction(lodash.bar);
+ * // => true
+ *
+ * // Create a suped-up `defer` in Node.js.
+ * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;
+ */
+ var runInContext = (function runInContext(context) {
+ context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));
+
+ /** Built-in constructor references. */
+ var Array = context.Array,
+ Date = context.Date,
+ Error = context.Error,
+ Function = context.Function,
+ Math = context.Math,
+ Object = context.Object,
+ RegExp = context.RegExp,
+ String = context.String,
+ TypeError = context.TypeError;
+
+ /** Used for built-in method references. */
+ var arrayProto = Array.prototype,
+ funcProto = Function.prototype,
+ objectProto = Object.prototype;
+
+ /** Used to detect overreaching core-js shims. */
+ var coreJsData = context['__core-js_shared__'];
+
+ /** Used to resolve the decompiled source of functions. */
+ var funcToString = funcProto.toString;
+
+ /** Used to check objects for own properties. */
+ var hasOwnProperty = objectProto.hasOwnProperty;
+
+ /** Used to generate unique IDs. */
+ var idCounter = 0;
+
+ /** Used to detect methods masquerading as native. */
+ var maskSrcKey = (function() {
+ var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+ return uid ? ('Symbol(src)_1.' + uid) : '';
+ }());
+
+ /**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+ var nativeObjectToString = objectProto.toString;
+
+ /** Used to infer the `Object` constructor. */
+ var objectCtorString = funcToString.call(Object);
+
+ /** Used to restore the original `_` reference in `_.noConflict`. */
+ var oldDash = root._;
+
+ /** Used to detect if a method is native. */
+ var reIsNative = RegExp('^' +
+ funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+ .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+ );
+
+ /** Built-in value references. */
+ var Buffer = moduleExports ? context.Buffer : undefined$1,
+ Symbol = context.Symbol,
+ Uint8Array = context.Uint8Array,
+ allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined$1,
+ getPrototype = overArg(Object.getPrototypeOf, Object),
+ objectCreate = Object.create,
+ propertyIsEnumerable = objectProto.propertyIsEnumerable,
+ splice = arrayProto.splice,
+ spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined$1,
+ symIterator = Symbol ? Symbol.iterator : undefined$1,
+ symToStringTag = Symbol ? Symbol.toStringTag : undefined$1;
+
+ var defineProperty = (function() {
+ try {
+ var func = getNative(Object, 'defineProperty');
+ func({}, '', {});
+ return func;
+ } catch (e) {}
+ }());
+
+ /** Mocked built-ins. */
+ var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,
+ ctxNow = Date && Date.now !== root.Date.now && Date.now,
+ ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;
+
+ /* Built-in method references for those with the same name as other `lodash` methods. */
+ var nativeCeil = Math.ceil,
+ nativeFloor = Math.floor,
+ nativeGetSymbols = Object.getOwnPropertySymbols,
+ nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined$1,
+ nativeIsFinite = context.isFinite,
+ nativeJoin = arrayProto.join,
+ nativeKeys = overArg(Object.keys, Object),
+ nativeMax = Math.max,
+ nativeMin = Math.min,
+ nativeNow = Date.now,
+ nativeParseInt = context.parseInt,
+ nativeRandom = Math.random,
+ nativeReverse = arrayProto.reverse;
+
+ /* Built-in method references that are verified to be native. */
+ var DataView = getNative(context, 'DataView'),
+ Map = getNative(context, 'Map'),
+ Promise = getNative(context, 'Promise'),
+ Set = getNative(context, 'Set'),
+ WeakMap = getNative(context, 'WeakMap'),
+ nativeCreate = getNative(Object, 'create');
+
+ /** Used to store function metadata. */
+ var metaMap = WeakMap && new WeakMap;
+
+ /** Used to lookup unminified function names. */
+ var realNames = {};
+
+ /** Used to detect maps, sets, and weakmaps. */
+ var dataViewCtorString = toSource(DataView),
+ mapCtorString = toSource(Map),
+ promiseCtorString = toSource(Promise),
+ setCtorString = toSource(Set),
+ weakMapCtorString = toSource(WeakMap);
+
+ /** Used to convert symbols to primitives and strings. */
+ var symbolProto = Symbol ? Symbol.prototype : undefined$1,
+ symbolValueOf = symbolProto ? symbolProto.valueOf : undefined$1,
+ symbolToString = symbolProto ? symbolProto.toString : undefined$1;
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Creates a `lodash` object which wraps `value` to enable implicit method
+ * chain sequences. Methods that operate on and return arrays, collections,
+ * and functions can be chained together. Methods that retrieve a single value
+ * or may return a primitive value will automatically end the chain sequence
+ * and return the unwrapped value. Otherwise, the value must be unwrapped
+ * with `_#value`.
+ *
+ * Explicit chain sequences, which must be unwrapped with `_#value`, may be
+ * enabled using `_.chain`.
+ *
+ * The execution of chained methods is lazy, that is, it's deferred until
+ * `_#value` is implicitly or explicitly called.
+ *
+ * Lazy evaluation allows several methods to support shortcut fusion.
+ * Shortcut fusion is an optimization to merge iteratee calls; this avoids
+ * the creation of intermediate arrays and can greatly reduce the number of
+ * iteratee executions. Sections of a chain sequence qualify for shortcut
+ * fusion if the section is applied to an array and iteratees accept only
+ * one argument. The heuristic for whether a section qualifies for shortcut
+ * fusion is subject to change.
+ *
+ * Chaining is supported in custom builds as long as the `_#value` method is
+ * directly or indirectly included in the build.
+ *
+ * In addition to lodash methods, wrappers have `Array` and `String` methods.
+ *
+ * The wrapper `Array` methods are:
+ * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`
+ *
+ * The wrapper `String` methods are:
+ * `replace` and `split`
+ *
+ * The wrapper methods that support shortcut fusion are:
+ * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,
+ * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,
+ * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`
+ *
+ * The chainable wrapper methods are:
+ * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,
+ * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,
+ * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,
+ * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,
+ * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,
+ * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,
+ * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,
+ * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,
+ * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,
+ * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,
+ * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,
+ * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,
+ * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,
+ * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,
+ * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,
+ * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,
+ * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,
+ * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,
+ * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,
+ * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,
+ * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,
+ * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,
+ * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,
+ * `zipObject`, `zipObjectDeep`, and `zipWith`
+ *
+ * The wrapper methods that are **not** chainable by default are:
+ * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,
+ * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,
+ * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,
+ * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,
+ * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,
+ * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,
+ * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,
+ * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,
+ * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,
+ * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,
+ * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,
+ * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,
+ * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,
+ * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,
+ * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,
+ * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,
+ * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,
+ * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
+ * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,
+ * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,
+ * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,
+ * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,
+ * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,
+ * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,
+ * `upperFirst`, `value`, and `words`
+ *
+ * @name _
+ * @constructor
+ * @category Seq
+ * @param {*} value The value to wrap in a `lodash` instance.
+ * @returns {Object} Returns the new `lodash` wrapper instance.
+ * @example
+ *
+ * function square(n) {
+ * return n * n;
+ * }
+ *
+ * var wrapped = _([1, 2, 3]);
+ *
+ * // Returns an unwrapped value.
+ * wrapped.reduce(_.add);
+ * // => 6
+ *
+ * // Returns a wrapped value.
+ * var squares = wrapped.map(square);
+ *
+ * _.isArray(squares);
+ * // => false
+ *
+ * _.isArray(squares.value());
+ * // => true
+ */
+ function lodash(value) {
+ if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
+ if (value instanceof LodashWrapper) {
+ return value;
+ }
+ if (hasOwnProperty.call(value, '__wrapped__')) {
+ return wrapperClone(value);
+ }
+ }
+ return new LodashWrapper(value);
+ }
+
+ /**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} proto The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+ var baseCreate = (function() {
+ function object() {}
+ return function(proto) {
+ if (!isObject(proto)) {
+ return {};
+ }
+ if (objectCreate) {
+ return objectCreate(proto);
+ }
+ object.prototype = proto;
+ var result = new object;
+ object.prototype = undefined$1;
+ return result;
+ };
+ }());
+
+ /**
+ * The function whose prototype chain sequence wrappers inherit from.
+ *
+ * @private
+ */
+ function baseLodash() {
+ // No operation performed.
+ }
+
+ /**
+ * The base constructor for creating `lodash` wrapper objects.
+ *
+ * @private
+ * @param {*} value The value to wrap.
+ * @param {boolean} [chainAll] Enable explicit method chain sequences.
+ */
+ function LodashWrapper(value, chainAll) {
+ this.__wrapped__ = value;
+ this.__actions__ = [];
+ this.__chain__ = !!chainAll;
+ this.__index__ = 0;
+ this.__values__ = undefined$1;
+ }
+
+ /**
+ * By default, the template delimiters used by lodash are like those in
+ * embedded Ruby (ERB) as well as ES2015 template strings. Change the
+ * following template settings to use alternative delimiters.
+ *
+ * @static
+ * @memberOf _
+ * @type {Object}
+ */
+ lodash.templateSettings = {
+
+ /**
+ * Used to detect `data` property values to be HTML-escaped.
+ *
+ * @memberOf _.templateSettings
+ * @type {RegExp}
+ */
+ 'escape': reEscape,
+
+ /**
+ * Used to detect code to be evaluated.
+ *
+ * @memberOf _.templateSettings
+ * @type {RegExp}
+ */
+ 'evaluate': reEvaluate,
+
+ /**
+ * Used to detect `data` property values to inject.
+ *
+ * @memberOf _.templateSettings
+ * @type {RegExp}
+ */
+ 'interpolate': reInterpolate,
+
+ /**
+ * Used to reference the data object in the template text.
+ *
+ * @memberOf _.templateSettings
+ * @type {string}
+ */
+ 'variable': '',
+
+ /**
+ * Used to import variables into the compiled template.
+ *
+ * @memberOf _.templateSettings
+ * @type {Object}
+ */
+ 'imports': {
+
+ /**
+ * A reference to the `lodash` function.
+ *
+ * @memberOf _.templateSettings.imports
+ * @type {Function}
+ */
+ '_': lodash
+ }
+ };
+
+ // Ensure wrappers are instances of `baseLodash`.
+ lodash.prototype = baseLodash.prototype;
+ lodash.prototype.constructor = lodash;
+
+ LodashWrapper.prototype = baseCreate(baseLodash.prototype);
+ LodashWrapper.prototype.constructor = LodashWrapper;
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
+ *
+ * @private
+ * @constructor
+ * @param {*} value The value to wrap.
+ */
+ function LazyWrapper(value) {
+ this.__wrapped__ = value;
+ this.__actions__ = [];
+ this.__dir__ = 1;
+ this.__filtered__ = false;
+ this.__iteratees__ = [];
+ this.__takeCount__ = MAX_ARRAY_LENGTH;
+ this.__views__ = [];
+ }
+
+ /**
+ * Creates a clone of the lazy wrapper object.
+ *
+ * @private
+ * @name clone
+ * @memberOf LazyWrapper
+ * @returns {Object} Returns the cloned `LazyWrapper` object.
+ */
+ function lazyClone() {
+ var result = new LazyWrapper(this.__wrapped__);
+ result.__actions__ = copyArray(this.__actions__);
+ result.__dir__ = this.__dir__;
+ result.__filtered__ = this.__filtered__;
+ result.__iteratees__ = copyArray(this.__iteratees__);
+ result.__takeCount__ = this.__takeCount__;
+ result.__views__ = copyArray(this.__views__);
+ return result;
+ }
+
+ /**
+ * Reverses the direction of lazy iteration.
+ *
+ * @private
+ * @name reverse
+ * @memberOf LazyWrapper
+ * @returns {Object} Returns the new reversed `LazyWrapper` object.
+ */
+ function lazyReverse() {
+ if (this.__filtered__) {
+ var result = new LazyWrapper(this);
+ result.__dir__ = -1;
+ result.__filtered__ = true;
+ } else {
+ result = this.clone();
+ result.__dir__ *= -1;
+ }
+ return result;
+ }
+
+ /**
+ * Extracts the unwrapped value from its lazy wrapper.
+ *
+ * @private
+ * @name value
+ * @memberOf LazyWrapper
+ * @returns {*} Returns the unwrapped value.
+ */
+ function lazyValue() {
+ var array = this.__wrapped__.value(),
+ dir = this.__dir__,
+ isArr = isArray(array),
+ isRight = dir < 0,
+ arrLength = isArr ? array.length : 0,
+ view = getView(0, arrLength, this.__views__),
+ start = view.start,
+ end = view.end,
+ length = end - start,
+ index = isRight ? end : (start - 1),
+ iteratees = this.__iteratees__,
+ iterLength = iteratees.length,
+ resIndex = 0,
+ takeCount = nativeMin(length, this.__takeCount__);
+
+ if (!isArr || (!isRight && arrLength == length && takeCount == length)) {
+ return baseWrapperValue(array, this.__actions__);
+ }
+ var result = [];
+
+ outer:
+ while (length-- && resIndex < takeCount) {
+ index += dir;
+
+ var iterIndex = -1,
+ value = array[index];
+
+ while (++iterIndex < iterLength) {
+ var data = iteratees[iterIndex],
+ iteratee = data.iteratee,
+ type = data.type,
+ computed = iteratee(value);
+
+ if (type == LAZY_MAP_FLAG) {
+ value = computed;
+ } else if (!computed) {
+ if (type == LAZY_FILTER_FLAG) {
+ continue outer;
+ } else {
+ break outer;
+ }
+ }
+ }
+ result[resIndex++] = value;
+ }
+ return result;
+ }
+
+ // Ensure `LazyWrapper` is an instance of `baseLodash`.
+ LazyWrapper.prototype = baseCreate(baseLodash.prototype);
+ LazyWrapper.prototype.constructor = LazyWrapper;
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+ function Hash(entries) {
+ var index = -1,
+ length = entries == null ? 0 : entries.length;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+ }
+
+ /**
+ * Removes all key-value entries from the hash.
+ *
+ * @private
+ * @name clear
+ * @memberOf Hash
+ */
+ function hashClear() {
+ this.__data__ = nativeCreate ? nativeCreate(null) : {};
+ this.size = 0;
+ }
+
+ /**
+ * Removes `key` and its value from the hash.
+ *
+ * @private
+ * @name delete
+ * @memberOf Hash
+ * @param {Object} hash The hash to modify.
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+ function hashDelete(key) {
+ var result = this.has(key) && delete this.__data__[key];
+ this.size -= result ? 1 : 0;
+ return result;
+ }
+
+ /**
+ * Gets the hash value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Hash
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+ function hashGet(key) {
+ var data = this.__data__;
+ if (nativeCreate) {
+ var result = data[key];
+ return result === HASH_UNDEFINED ? undefined$1 : result;
+ }
+ return hasOwnProperty.call(data, key) ? data[key] : undefined$1;
+ }
+
+ /**
+ * Checks if a hash value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Hash
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+ function hashHas(key) {
+ var data = this.__data__;
+ return nativeCreate ? (data[key] !== undefined$1) : hasOwnProperty.call(data, key);
+ }
+
+ /**
+ * Sets the hash `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Hash
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the hash instance.
+ */
+ function hashSet(key, value) {
+ var data = this.__data__;
+ this.size += this.has(key) ? 0 : 1;
+ data[key] = (nativeCreate && value === undefined$1) ? HASH_UNDEFINED : value;
+ return this;
+ }
+
+ // Add methods to `Hash`.
+ Hash.prototype.clear = hashClear;
+ Hash.prototype['delete'] = hashDelete;
+ Hash.prototype.get = hashGet;
+ Hash.prototype.has = hashHas;
+ Hash.prototype.set = hashSet;
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+ function ListCache(entries) {
+ var index = -1,
+ length = entries == null ? 0 : entries.length;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+ }
+
+ /**
+ * Removes all key-value entries from the list cache.
+ *
+ * @private
+ * @name clear
+ * @memberOf ListCache
+ */
+ function listCacheClear() {
+ this.__data__ = [];
+ this.size = 0;
+ }
+
+ /**
+ * Removes `key` and its value from the list cache.
+ *
+ * @private
+ * @name delete
+ * @memberOf ListCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+ function listCacheDelete(key) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ if (index < 0) {
+ return false;
+ }
+ var lastIndex = data.length - 1;
+ if (index == lastIndex) {
+ data.pop();
+ } else {
+ splice.call(data, index, 1);
+ }
+ --this.size;
+ return true;
+ }
+
+ /**
+ * Gets the list cache value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf ListCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+ function listCacheGet(key) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ return index < 0 ? undefined$1 : data[index][1];
+ }
+
+ /**
+ * Checks if a list cache value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf ListCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+ function listCacheHas(key) {
+ return assocIndexOf(this.__data__, key) > -1;
+ }
+
+ /**
+ * Sets the list cache `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf ListCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the list cache instance.
+ */
+ function listCacheSet(key, value) {
+ var data = this.__data__,
+ index = assocIndexOf(data, key);
+
+ if (index < 0) {
+ ++this.size;
+ data.push([key, value]);
+ } else {
+ data[index][1] = value;
+ }
+ return this;
+ }
+
+ // Add methods to `ListCache`.
+ ListCache.prototype.clear = listCacheClear;
+ ListCache.prototype['delete'] = listCacheDelete;
+ ListCache.prototype.get = listCacheGet;
+ ListCache.prototype.has = listCacheHas;
+ ListCache.prototype.set = listCacheSet;
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+ function MapCache(entries) {
+ var index = -1,
+ length = entries == null ? 0 : entries.length;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+ }
+
+ /**
+ * Removes all key-value entries from the map.
+ *
+ * @private
+ * @name clear
+ * @memberOf MapCache
+ */
+ function mapCacheClear() {
+ this.size = 0;
+ this.__data__ = {
+ 'hash': new Hash,
+ 'map': new (Map || ListCache),
+ 'string': new Hash
+ };
+ }
+
+ /**
+ * Removes `key` and its value from the map.
+ *
+ * @private
+ * @name delete
+ * @memberOf MapCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+ function mapCacheDelete(key) {
+ var result = getMapData(this, key)['delete'](key);
+ this.size -= result ? 1 : 0;
+ return result;
+ }
+
+ /**
+ * Gets the map value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf MapCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+ function mapCacheGet(key) {
+ return getMapData(this, key).get(key);
+ }
+
+ /**
+ * Checks if a map value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf MapCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+ function mapCacheHas(key) {
+ return getMapData(this, key).has(key);
+ }
+
+ /**
+ * Sets the map `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf MapCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the map cache instance.
+ */
+ function mapCacheSet(key, value) {
+ var data = getMapData(this, key),
+ size = data.size;
+
+ data.set(key, value);
+ this.size += data.size == size ? 0 : 1;
+ return this;
+ }
+
+ // Add methods to `MapCache`.
+ MapCache.prototype.clear = mapCacheClear;
+ MapCache.prototype['delete'] = mapCacheDelete;
+ MapCache.prototype.get = mapCacheGet;
+ MapCache.prototype.has = mapCacheHas;
+ MapCache.prototype.set = mapCacheSet;
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+ function SetCache(values) {
+ var index = -1,
+ length = values == null ? 0 : values.length;
+
+ this.__data__ = new MapCache;
+ while (++index < length) {
+ this.add(values[index]);
+ }
+ }
+
+ /**
+ * Adds `value` to the array cache.
+ *
+ * @private
+ * @name add
+ * @memberOf SetCache
+ * @alias push
+ * @param {*} value The value to cache.
+ * @returns {Object} Returns the cache instance.
+ */
+ function setCacheAdd(value) {
+ this.__data__.set(value, HASH_UNDEFINED);
+ return this;
+ }
+
+ /**
+ * Checks if `value` is in the array cache.
+ *
+ * @private
+ * @name has
+ * @memberOf SetCache
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `true` if `value` is found, else `false`.
+ */
+ function setCacheHas(value) {
+ return this.__data__.has(value);
+ }
+
+ // Add methods to `SetCache`.
+ SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+ SetCache.prototype.has = setCacheHas;
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+ function Stack(entries) {
+ var data = this.__data__ = new ListCache(entries);
+ this.size = data.size;
+ }
+
+ /**
+ * Removes all key-value entries from the stack.
+ *
+ * @private
+ * @name clear
+ * @memberOf Stack
+ */
+ function stackClear() {
+ this.__data__ = new ListCache;
+ this.size = 0;
+ }
+
+ /**
+ * Removes `key` and its value from the stack.
+ *
+ * @private
+ * @name delete
+ * @memberOf Stack
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+ function stackDelete(key) {
+ var data = this.__data__,
+ result = data['delete'](key);
+
+ this.size = data.size;
+ return result;
+ }
+
+ /**
+ * Gets the stack value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Stack
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+ function stackGet(key) {
+ return this.__data__.get(key);
+ }
+
+ /**
+ * Checks if a stack value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Stack
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+ function stackHas(key) {
+ return this.__data__.has(key);
+ }
+
+ /**
+ * Sets the stack `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Stack
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the stack cache instance.
+ */
+ function stackSet(key, value) {
+ var data = this.__data__;
+ if (data instanceof ListCache) {
+ var pairs = data.__data__;
+ if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+ pairs.push([key, value]);
+ this.size = ++data.size;
+ return this;
+ }
+ data = this.__data__ = new MapCache(pairs);
+ }
+ data.set(key, value);
+ this.size = data.size;
+ return this;
+ }
+
+ // Add methods to `Stack`.
+ Stack.prototype.clear = stackClear;
+ Stack.prototype['delete'] = stackDelete;
+ Stack.prototype.get = stackGet;
+ Stack.prototype.has = stackHas;
+ Stack.prototype.set = stackSet;
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+ function arrayLikeKeys(value, inherited) {
+ var isArr = isArray(value),
+ isArg = !isArr && isArguments(value),
+ isBuff = !isArr && !isArg && isBuffer(value),
+ isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+ skipIndexes = isArr || isArg || isBuff || isType,
+ result = skipIndexes ? baseTimes(value.length, String) : [],
+ length = result.length;
+
+ for (var key in value) {
+ if ((inherited || hasOwnProperty.call(value, key)) &&
+ !(skipIndexes && (
+ // Safari 9 has enumerable `arguments.length` in strict mode.
+ key == 'length' ||
+ // Node.js 0.10 has enumerable non-index properties on buffers.
+ (isBuff && (key == 'offset' || key == 'parent')) ||
+ // PhantomJS 2 has enumerable non-index properties on typed arrays.
+ (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
+ // Skip index properties.
+ isIndex(key, length)
+ ))) {
+ result.push(key);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * A specialized version of `_.sample` for arrays.
+ *
+ * @private
+ * @param {Array} array The array to sample.
+ * @returns {*} Returns the random element.
+ */
+ function arraySample(array) {
+ var length = array.length;
+ return length ? array[baseRandom(0, length - 1)] : undefined$1;
+ }
+
+ /**
+ * A specialized version of `_.sampleSize` for arrays.
+ *
+ * @private
+ * @param {Array} array The array to sample.
+ * @param {number} n The number of elements to sample.
+ * @returns {Array} Returns the random elements.
+ */
+ function arraySampleSize(array, n) {
+ return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
+ }
+
+ /**
+ * A specialized version of `_.shuffle` for arrays.
+ *
+ * @private
+ * @param {Array} array The array to shuffle.
+ * @returns {Array} Returns the new shuffled array.
+ */
+ function arrayShuffle(array) {
+ return shuffleSelf(copyArray(array));
+ }
+
+ /**
+ * This function is like `assignValue` except that it doesn't assign
+ * `undefined` values.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+ function assignMergeValue(object, key, value) {
+ if ((value !== undefined$1 && !eq(object[key], value)) ||
+ (value === undefined$1 && !(key in object))) {
+ baseAssignValue(object, key, value);
+ }
+ }
+
+ /**
+ * Assigns `value` to `key` of `object` if the existing value is not equivalent
+ * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+ function assignValue(object, key, value) {
+ var objValue = object[key];
+ if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
+ (value === undefined$1 && !(key in object))) {
+ baseAssignValue(object, key, value);
+ }
+ }
+
+ /**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+ function assocIndexOf(array, key) {
+ var length = array.length;
+ while (length--) {
+ if (eq(array[length][0], key)) {
+ return length;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Aggregates elements of `collection` on `accumulator` with keys transformed
+ * by `iteratee` and values set by `setter`.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} setter The function to set `accumulator` values.
+ * @param {Function} iteratee The iteratee to transform keys.
+ * @param {Object} accumulator The initial aggregated object.
+ * @returns {Function} Returns `accumulator`.
+ */
+ function baseAggregator(collection, setter, iteratee, accumulator) {
+ baseEach(collection, function(value, key, collection) {
+ setter(accumulator, value, iteratee(value), collection);
+ });
+ return accumulator;
+ }
+
+ /**
+ * The base implementation of `_.assign` without support for multiple sources
+ * or `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @returns {Object} Returns `object`.
+ */
+ function baseAssign(object, source) {
+ return object && copyObject(source, keys(source), object);
+ }
+
+ /**
+ * The base implementation of `_.assignIn` without support for multiple sources
+ * or `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @returns {Object} Returns `object`.
+ */
+ function baseAssignIn(object, source) {
+ return object && copyObject(source, keysIn(source), object);
+ }
+
+ /**
+ * The base implementation of `assignValue` and `assignMergeValue` without
+ * value checks.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+ function baseAssignValue(object, key, value) {
+ if (key == '__proto__' && defineProperty) {
+ defineProperty(object, key, {
+ 'configurable': true,
+ 'enumerable': true,
+ 'value': value,
+ 'writable': true
+ });
+ } else {
+ object[key] = value;
+ }
+ }
+
+ /**
+ * The base implementation of `_.at` without support for individual paths.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {string[]} paths The property paths to pick.
+ * @returns {Array} Returns the picked elements.
+ */
+ function baseAt(object, paths) {
+ var index = -1,
+ length = paths.length,
+ result = Array(length),
+ skip = object == null;
+
+ while (++index < length) {
+ result[index] = skip ? undefined$1 : get(object, paths[index]);
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.clamp` which doesn't coerce arguments.
+ *
+ * @private
+ * @param {number} number The number to clamp.
+ * @param {number} [lower] The lower bound.
+ * @param {number} upper The upper bound.
+ * @returns {number} Returns the clamped number.
+ */
+ function baseClamp(number, lower, upper) {
+ if (number === number) {
+ if (upper !== undefined$1) {
+ number = number <= upper ? number : upper;
+ }
+ if (lower !== undefined$1) {
+ number = number >= lower ? number : lower;
+ }
+ }
+ return number;
+ }
+
+ /**
+ * The base implementation of `_.clone` and `_.cloneDeep` which tracks
+ * traversed objects.
+ *
+ * @private
+ * @param {*} value The value to clone.
+ * @param {boolean} bitmask The bitmask flags.
+ * 1 - Deep clone
+ * 2 - Flatten inherited properties
+ * 4 - Clone symbols
+ * @param {Function} [customizer] The function to customize cloning.
+ * @param {string} [key] The key of `value`.
+ * @param {Object} [object] The parent object of `value`.
+ * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
+ * @returns {*} Returns the cloned value.
+ */
+ function baseClone(value, bitmask, customizer, key, object, stack) {
+ var result,
+ isDeep = bitmask & CLONE_DEEP_FLAG,
+ isFlat = bitmask & CLONE_FLAT_FLAG,
+ isFull = bitmask & CLONE_SYMBOLS_FLAG;
+
+ if (customizer) {
+ result = object ? customizer(value, key, object, stack) : customizer(value);
+ }
+ if (result !== undefined$1) {
+ return result;
+ }
+ if (!isObject(value)) {
+ return value;
+ }
+ var isArr = isArray(value);
+ if (isArr) {
+ result = initCloneArray(value);
+ if (!isDeep) {
+ return copyArray(value, result);
+ }
+ } else {
+ var tag = getTag(value),
+ isFunc = tag == funcTag || tag == genTag;
+
+ if (isBuffer(value)) {
+ return cloneBuffer(value, isDeep);
+ }
+ if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
+ result = (isFlat || isFunc) ? {} : initCloneObject(value);
+ if (!isDeep) {
+ return isFlat
+ ? copySymbolsIn(value, baseAssignIn(result, value))
+ : copySymbols(value, baseAssign(result, value));
+ }
+ } else {
+ if (!cloneableTags[tag]) {
+ return object ? value : {};
+ }
+ result = initCloneByTag(value, tag, isDeep);
+ }
+ }
+ // Check for circular references and return its corresponding clone.
+ stack || (stack = new Stack);
+ var stacked = stack.get(value);
+ if (stacked) {
+ return stacked;
+ }
+ stack.set(value, result);
+
+ if (isSet(value)) {
+ value.forEach(function(subValue) {
+ result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+ });
+ } else if (isMap(value)) {
+ value.forEach(function(subValue, key) {
+ result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
+ });
+ }
+
+ var keysFunc = isFull
+ ? (isFlat ? getAllKeysIn : getAllKeys)
+ : (isFlat ? keysIn : keys);
+
+ var props = isArr ? undefined$1 : keysFunc(value);
+ arrayEach(props || value, function(subValue, key) {
+ if (props) {
+ key = subValue;
+ subValue = value[key];
+ }
+ // Recursively populate clone (susceptible to call stack limits).
+ assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
+ });
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.conforms` which doesn't clone `source`.
+ *
+ * @private
+ * @param {Object} source The object of property predicates to conform to.
+ * @returns {Function} Returns the new spec function.
+ */
+ function baseConforms(source) {
+ var props = keys(source);
+ return function(object) {
+ return baseConformsTo(object, source, props);
+ };
+ }
+
+ /**
+ * The base implementation of `_.conformsTo` which accepts `props` to check.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property predicates to conform to.
+ * @returns {boolean} Returns `true` if `object` conforms, else `false`.
+ */
+ function baseConformsTo(object, source, props) {
+ var length = props.length;
+ if (object == null) {
+ return !length;
+ }
+ object = Object(object);
+ while (length--) {
+ var key = props[length],
+ predicate = source[key],
+ value = object[key];
+
+ if ((value === undefined$1 && !(key in object)) || !predicate(value)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * The base implementation of `_.delay` and `_.defer` which accepts `args`
+ * to provide to `func`.
+ *
+ * @private
+ * @param {Function} func The function to delay.
+ * @param {number} wait The number of milliseconds to delay invocation.
+ * @param {Array} args The arguments to provide to `func`.
+ * @returns {number|Object} Returns the timer id or timeout object.
+ */
+ function baseDelay(func, wait, args) {
+ if (typeof func != 'function') {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ return setTimeout(function() { func.apply(undefined$1, args); }, wait);
+ }
+
+ /**
+ * The base implementation of methods like `_.difference` without support
+ * for excluding multiple arrays or iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Array} values The values to exclude.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of filtered values.
+ */
+ function baseDifference(array, values, iteratee, comparator) {
+ var index = -1,
+ includes = arrayIncludes,
+ isCommon = true,
+ length = array.length,
+ result = [],
+ valuesLength = values.length;
+
+ if (!length) {
+ return result;
+ }
+ if (iteratee) {
+ values = arrayMap(values, baseUnary(iteratee));
+ }
+ if (comparator) {
+ includes = arrayIncludesWith;
+ isCommon = false;
+ }
+ else if (values.length >= LARGE_ARRAY_SIZE) {
+ includes = cacheHas;
+ isCommon = false;
+ values = new SetCache(values);
+ }
+ outer:
+ while (++index < length) {
+ var value = array[index],
+ computed = iteratee == null ? value : iteratee(value);
+
+ value = (comparator || value !== 0) ? value : 0;
+ if (isCommon && computed === computed) {
+ var valuesIndex = valuesLength;
+ while (valuesIndex--) {
+ if (values[valuesIndex] === computed) {
+ continue outer;
+ }
+ }
+ result.push(value);
+ }
+ else if (!includes(values, computed, comparator)) {
+ result.push(value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.forEach` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ */
+ var baseEach = createBaseEach(baseForOwn);
+
+ /**
+ * The base implementation of `_.forEachRight` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ */
+ var baseEachRight = createBaseEach(baseForOwnRight, true);
+
+ /**
+ * The base implementation of `_.every` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if all elements pass the predicate check,
+ * else `false`
+ */
+ function baseEvery(collection, predicate) {
+ var result = true;
+ baseEach(collection, function(value, index, collection) {
+ result = !!predicate(value, index, collection);
+ return result;
+ });
+ return result;
+ }
+
+ /**
+ * The base implementation of methods like `_.max` and `_.min` which accepts a
+ * `comparator` to determine the extremum value.
+ *
+ * @private
+ * @param {Array} array The array to iterate over.
+ * @param {Function} iteratee The iteratee invoked per iteration.
+ * @param {Function} comparator The comparator used to compare values.
+ * @returns {*} Returns the extremum value.
+ */
+ function baseExtremum(array, iteratee, comparator) {
+ var index = -1,
+ length = array.length;
+
+ while (++index < length) {
+ var value = array[index],
+ current = iteratee(value);
+
+ if (current != null && (computed === undefined$1
+ ? (current === current && !isSymbol(current))
+ : comparator(current, computed)
+ )) {
+ var computed = current,
+ result = value;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.fill` without an iteratee call guard.
+ *
+ * @private
+ * @param {Array} array The array to fill.
+ * @param {*} value The value to fill `array` with.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns `array`.
+ */
+ function baseFill(array, value, start, end) {
+ var length = array.length;
+
+ start = toInteger(start);
+ if (start < 0) {
+ start = -start > length ? 0 : (length + start);
+ }
+ end = (end === undefined$1 || end > length) ? length : toInteger(end);
+ if (end < 0) {
+ end += length;
+ }
+ end = start > end ? 0 : toLength(end);
+ while (start < end) {
+ array[start++] = value;
+ }
+ return array;
+ }
+
+ /**
+ * The base implementation of `_.filter` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+ function baseFilter(collection, predicate) {
+ var result = [];
+ baseEach(collection, function(value, index, collection) {
+ if (predicate(value, index, collection)) {
+ result.push(value);
+ }
+ });
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.flatten` with support for restricting flattening.
+ *
+ * @private
+ * @param {Array} array The array to flatten.
+ * @param {number} depth The maximum recursion depth.
+ * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
+ * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
+ * @param {Array} [result=[]] The initial result value.
+ * @returns {Array} Returns the new flattened array.
+ */
+ function baseFlatten(array, depth, predicate, isStrict, result) {
+ var index = -1,
+ length = array.length;
+
+ predicate || (predicate = isFlattenable);
+ result || (result = []);
+
+ while (++index < length) {
+ var value = array[index];
+ if (depth > 0 && predicate(value)) {
+ if (depth > 1) {
+ // Recursively flatten arrays (susceptible to call stack limits).
+ baseFlatten(value, depth - 1, predicate, isStrict, result);
+ } else {
+ arrayPush(result, value);
+ }
+ } else if (!isStrict) {
+ result[result.length] = value;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `baseForOwn` which iterates over `object`
+ * properties returned by `keysFunc` and invokes `iteratee` for each property.
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+ var baseFor = createBaseFor();
+
+ /**
+ * This function is like `baseFor` except that it iterates over properties
+ * in the opposite order.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+ var baseForRight = createBaseFor(true);
+
+ /**
+ * The base implementation of `_.forOwn` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+ function baseForOwn(object, iteratee) {
+ return object && baseFor(object, iteratee, keys);
+ }
+
+ /**
+ * The base implementation of `_.forOwnRight` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+ function baseForOwnRight(object, iteratee) {
+ return object && baseForRight(object, iteratee, keys);
+ }
+
+ /**
+ * The base implementation of `_.functions` which creates an array of
+ * `object` function property names filtered from `props`.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Array} props The property names to filter.
+ * @returns {Array} Returns the function names.
+ */
+ function baseFunctions(object, props) {
+ return arrayFilter(props, function(key) {
+ return isFunction(object[key]);
+ });
+ }
+
+ /**
+ * The base implementation of `_.get` without support for default values.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @returns {*} Returns the resolved value.
+ */
+ function baseGet(object, path) {
+ path = castPath(path, object);
+
+ var index = 0,
+ length = path.length;
+
+ while (object != null && index < length) {
+ object = object[toKey(path[index++])];
+ }
+ return (index && index == length) ? object : undefined$1;
+ }
+
+ /**
+ * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+ * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @param {Function} symbolsFunc The function to get the symbols of `object`.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+ function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+ var result = keysFunc(object);
+ return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+ }
+
+ /**
+ * The base implementation of `getTag` without fallbacks for buggy environments.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+ function baseGetTag(value) {
+ if (value == null) {
+ return value === undefined$1 ? undefinedTag : nullTag;
+ }
+ return (symToStringTag && symToStringTag in Object(value))
+ ? getRawTag(value)
+ : objectToString(value);
+ }
+
+ /**
+ * The base implementation of `_.gt` which doesn't coerce arguments.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if `value` is greater than `other`,
+ * else `false`.
+ */
+ function baseGt(value, other) {
+ return value > other;
+ }
+
+ /**
+ * The base implementation of `_.has` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+ function baseHas(object, key) {
+ return object != null && hasOwnProperty.call(object, key);
+ }
+
+ /**
+ * The base implementation of `_.hasIn` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+ function baseHasIn(object, key) {
+ return object != null && key in Object(object);
+ }
+
+ /**
+ * The base implementation of `_.inRange` which doesn't coerce arguments.
+ *
+ * @private
+ * @param {number} number The number to check.
+ * @param {number} start The start of the range.
+ * @param {number} end The end of the range.
+ * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
+ */
+ function baseInRange(number, start, end) {
+ return number >= nativeMin(start, end) && number < nativeMax(start, end);
+ }
+
+ /**
+ * The base implementation of methods like `_.intersection`, without support
+ * for iteratee shorthands, that accepts an array of arrays to inspect.
+ *
+ * @private
+ * @param {Array} arrays The arrays to inspect.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of shared values.
+ */
+ function baseIntersection(arrays, iteratee, comparator) {
+ var includes = comparator ? arrayIncludesWith : arrayIncludes,
+ length = arrays[0].length,
+ othLength = arrays.length,
+ othIndex = othLength,
+ caches = Array(othLength),
+ maxLength = Infinity,
+ result = [];
+
+ while (othIndex--) {
+ var array = arrays[othIndex];
+ if (othIndex && iteratee) {
+ array = arrayMap(array, baseUnary(iteratee));
+ }
+ maxLength = nativeMin(array.length, maxLength);
+ caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
+ ? new SetCache(othIndex && array)
+ : undefined$1;
+ }
+ array = arrays[0];
+
+ var index = -1,
+ seen = caches[0];
+
+ outer:
+ while (++index < length && result.length < maxLength) {
+ var value = array[index],
+ computed = iteratee ? iteratee(value) : value;
+
+ value = (comparator || value !== 0) ? value : 0;
+ if (!(seen
+ ? cacheHas(seen, computed)
+ : includes(result, computed, comparator)
+ )) {
+ othIndex = othLength;
+ while (--othIndex) {
+ var cache = caches[othIndex];
+ if (!(cache
+ ? cacheHas(cache, computed)
+ : includes(arrays[othIndex], computed, comparator))
+ ) {
+ continue outer;
+ }
+ }
+ if (seen) {
+ seen.push(computed);
+ }
+ result.push(value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.invert` and `_.invertBy` which inverts
+ * `object` with values transformed by `iteratee` and set by `setter`.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} setter The function to set `accumulator` values.
+ * @param {Function} iteratee The iteratee to transform values.
+ * @param {Object} accumulator The initial inverted object.
+ * @returns {Function} Returns `accumulator`.
+ */
+ function baseInverter(object, setter, iteratee, accumulator) {
+ baseForOwn(object, function(value, key, object) {
+ setter(accumulator, iteratee(value), key, object);
+ });
+ return accumulator;
+ }
+
+ /**
+ * The base implementation of `_.invoke` without support for individual
+ * method arguments.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the method to invoke.
+ * @param {Array} args The arguments to invoke the method with.
+ * @returns {*} Returns the result of the invoked method.
+ */
+ function baseInvoke(object, path, args) {
+ path = castPath(path, object);
+ object = parent(object, path);
+ var func = object == null ? object : object[toKey(last(path))];
+ return func == null ? undefined$1 : apply(func, object, args);
+ }
+
+ /**
+ * The base implementation of `_.isArguments`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ */
+ function baseIsArguments(value) {
+ return isObjectLike(value) && baseGetTag(value) == argsTag;
+ }
+
+ /**
+ * The base implementation of `_.isArrayBuffer` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
+ */
+ function baseIsArrayBuffer(value) {
+ return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
+ }
+
+ /**
+ * The base implementation of `_.isDate` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
+ */
+ function baseIsDate(value) {
+ return isObjectLike(value) && baseGetTag(value) == dateTag;
+ }
+
+ /**
+ * The base implementation of `_.isEqual` which supports partial comparisons
+ * and tracks traversed objects.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @param {boolean} bitmask The bitmask flags.
+ * 1 - Unordered comparison
+ * 2 - Partial comparison
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @param {Object} [stack] Tracks traversed `value` and `other` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ */
+ function baseIsEqual(value, other, bitmask, customizer, stack) {
+ if (value === other) {
+ return true;
+ }
+ if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
+ return value !== value && other !== other;
+ }
+ return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+ }
+
+ /**
+ * A specialized version of `baseIsEqual` for arrays and objects which performs
+ * deep comparisons and tracks traversed objects enabling objects with circular
+ * references to be compared.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+ function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+ var objIsArr = isArray(object),
+ othIsArr = isArray(other),
+ objTag = objIsArr ? arrayTag : getTag(object),
+ othTag = othIsArr ? arrayTag : getTag(other);
+
+ objTag = objTag == argsTag ? objectTag : objTag;
+ othTag = othTag == argsTag ? objectTag : othTag;
+
+ var objIsObj = objTag == objectTag,
+ othIsObj = othTag == objectTag,
+ isSameTag = objTag == othTag;
+
+ if (isSameTag && isBuffer(object)) {
+ if (!isBuffer(other)) {
+ return false;
+ }
+ objIsArr = true;
+ objIsObj = false;
+ }
+ if (isSameTag && !objIsObj) {
+ stack || (stack = new Stack);
+ return (objIsArr || isTypedArray(object))
+ ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
+ : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+ }
+ if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+ var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
+ othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+
+ if (objIsWrapped || othIsWrapped) {
+ var objUnwrapped = objIsWrapped ? object.value() : object,
+ othUnwrapped = othIsWrapped ? other.value() : other;
+
+ stack || (stack = new Stack);
+ return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+ }
+ }
+ if (!isSameTag) {
+ return false;
+ }
+ stack || (stack = new Stack);
+ return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+ }
+
+ /**
+ * The base implementation of `_.isMap` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+ */
+ function baseIsMap(value) {
+ return isObjectLike(value) && getTag(value) == mapTag;
+ }
+
+ /**
+ * The base implementation of `_.isMatch` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property values to match.
+ * @param {Array} matchData The property names, values, and compare flags to match.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+ */
+ function baseIsMatch(object, source, matchData, customizer) {
+ var index = matchData.length,
+ length = index,
+ noCustomizer = !customizer;
+
+ if (object == null) {
+ return !length;
+ }
+ object = Object(object);
+ while (index--) {
+ var data = matchData[index];
+ if ((noCustomizer && data[2])
+ ? data[1] !== object[data[0]]
+ : !(data[0] in object)
+ ) {
+ return false;
+ }
+ }
+ while (++index < length) {
+ data = matchData[index];
+ var key = data[0],
+ objValue = object[key],
+ srcValue = data[1];
+
+ if (noCustomizer && data[2]) {
+ if (objValue === undefined$1 && !(key in object)) {
+ return false;
+ }
+ } else {
+ var stack = new Stack;
+ if (customizer) {
+ var result = customizer(objValue, srcValue, key, object, source, stack);
+ }
+ if (!(result === undefined$1
+ ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
+ : result
+ )) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ /**
+ * The base implementation of `_.isNative` without bad shim checks.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ * else `false`.
+ */
+ function baseIsNative(value) {
+ if (!isObject(value) || isMasked(value)) {
+ return false;
+ }
+ var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+ return pattern.test(toSource(value));
+ }
+
+ /**
+ * The base implementation of `_.isRegExp` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
+ */
+ function baseIsRegExp(value) {
+ return isObjectLike(value) && baseGetTag(value) == regexpTag;
+ }
+
+ /**
+ * The base implementation of `_.isSet` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+ */
+ function baseIsSet(value) {
+ return isObjectLike(value) && getTag(value) == setTag;
+ }
+
+ /**
+ * The base implementation of `_.isTypedArray` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ */
+ function baseIsTypedArray(value) {
+ return isObjectLike(value) &&
+ isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+ }
+
+ /**
+ * The base implementation of `_.iteratee`.
+ *
+ * @private
+ * @param {*} [value=_.identity] The value to convert to an iteratee.
+ * @returns {Function} Returns the iteratee.
+ */
+ function baseIteratee(value) {
+ // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
+ // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
+ if (typeof value == 'function') {
+ return value;
+ }
+ if (value == null) {
+ return identity;
+ }
+ if (typeof value == 'object') {
+ return isArray(value)
+ ? baseMatchesProperty(value[0], value[1])
+ : baseMatches(value);
+ }
+ return property(value);
+ }
+
+ /**
+ * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+ function baseKeys(object) {
+ if (!isPrototype(object)) {
+ return nativeKeys(object);
+ }
+ var result = [];
+ for (var key in Object(object)) {
+ if (hasOwnProperty.call(object, key) && key != 'constructor') {
+ result.push(key);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+ function baseKeysIn(object) {
+ if (!isObject(object)) {
+ return nativeKeysIn(object);
+ }
+ var isProto = isPrototype(object),
+ result = [];
+
+ for (var key in object) {
+ if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+ result.push(key);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.lt` which doesn't coerce arguments.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if `value` is less than `other`,
+ * else `false`.
+ */
+ function baseLt(value, other) {
+ return value < other;
+ }
+
+ /**
+ * The base implementation of `_.map` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+ function baseMap(collection, iteratee) {
+ var index = -1,
+ result = isArrayLike(collection) ? Array(collection.length) : [];
+
+ baseEach(collection, function(value, key, collection) {
+ result[++index] = iteratee(value, key, collection);
+ });
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.matches` which doesn't clone `source`.
+ *
+ * @private
+ * @param {Object} source The object of property values to match.
+ * @returns {Function} Returns the new spec function.
+ */
+ function baseMatches(source) {
+ var matchData = getMatchData(source);
+ if (matchData.length == 1 && matchData[0][2]) {
+ return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+ }
+ return function(object) {
+ return object === source || baseIsMatch(object, source, matchData);
+ };
+ }
+
+ /**
+ * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
+ *
+ * @private
+ * @param {string} path The path of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+ function baseMatchesProperty(path, srcValue) {
+ if (isKey(path) && isStrictComparable(srcValue)) {
+ return matchesStrictComparable(toKey(path), srcValue);
+ }
+ return function(object) {
+ var objValue = get(object, path);
+ return (objValue === undefined$1 && objValue === srcValue)
+ ? hasIn(object, path)
+ : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+ };
+ }
+
+ /**
+ * The base implementation of `_.merge` without support for multiple sources.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {number} srcIndex The index of `source`.
+ * @param {Function} [customizer] The function to customize merged values.
+ * @param {Object} [stack] Tracks traversed source values and their merged
+ * counterparts.
+ */
+ function baseMerge(object, source, srcIndex, customizer, stack) {
+ if (object === source) {
+ return;
+ }
+ baseFor(source, function(srcValue, key) {
+ stack || (stack = new Stack);
+ if (isObject(srcValue)) {
+ baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
+ }
+ else {
+ var newValue = customizer
+ ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
+ : undefined$1;
+
+ if (newValue === undefined$1) {
+ newValue = srcValue;
+ }
+ assignMergeValue(object, key, newValue);
+ }
+ }, keysIn);
+ }
+
+ /**
+ * A specialized version of `baseMerge` for arrays and objects which performs
+ * deep merges and tracks traversed objects enabling objects with circular
+ * references to be merged.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {string} key The key of the value to merge.
+ * @param {number} srcIndex The index of `source`.
+ * @param {Function} mergeFunc The function to merge values.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @param {Object} [stack] Tracks traversed source values and their merged
+ * counterparts.
+ */
+ function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+ var objValue = safeGet(object, key),
+ srcValue = safeGet(source, key),
+ stacked = stack.get(srcValue);
+
+ if (stacked) {
+ assignMergeValue(object, key, stacked);
+ return;
+ }
+ var newValue = customizer
+ ? customizer(objValue, srcValue, (key + ''), object, source, stack)
+ : undefined$1;
+
+ var isCommon = newValue === undefined$1;
+
+ if (isCommon) {
+ var isArr = isArray(srcValue),
+ isBuff = !isArr && isBuffer(srcValue),
+ isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+
+ newValue = srcValue;
+ if (isArr || isBuff || isTyped) {
+ if (isArray(objValue)) {
+ newValue = objValue;
+ }
+ else if (isArrayLikeObject(objValue)) {
+ newValue = copyArray(objValue);
+ }
+ else if (isBuff) {
+ isCommon = false;
+ newValue = cloneBuffer(srcValue, true);
+ }
+ else if (isTyped) {
+ isCommon = false;
+ newValue = cloneTypedArray(srcValue, true);
+ }
+ else {
+ newValue = [];
+ }
+ }
+ else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+ newValue = objValue;
+ if (isArguments(objValue)) {
+ newValue = toPlainObject(objValue);
+ }
+ else if (!isObject(objValue) || isFunction(objValue)) {
+ newValue = initCloneObject(srcValue);
+ }
+ }
+ else {
+ isCommon = false;
+ }
+ }
+ if (isCommon) {
+ // Recursively merge objects and arrays (susceptible to call stack limits).
+ stack.set(srcValue, newValue);
+ mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+ stack['delete'](srcValue);
+ }
+ assignMergeValue(object, key, newValue);
+ }
+
+ /**
+ * The base implementation of `_.nth` which doesn't coerce arguments.
+ *
+ * @private
+ * @param {Array} array The array to query.
+ * @param {number} n The index of the element to return.
+ * @returns {*} Returns the nth element of `array`.
+ */
+ function baseNth(array, n) {
+ var length = array.length;
+ if (!length) {
+ return;
+ }
+ n += n < 0 ? length : 0;
+ return isIndex(n, length) ? array[n] : undefined$1;
+ }
+
+ /**
+ * The base implementation of `_.orderBy` without param guards.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
+ * @param {string[]} orders The sort orders of `iteratees`.
+ * @returns {Array} Returns the new sorted array.
+ */
+ function baseOrderBy(collection, iteratees, orders) {
+ if (iteratees.length) {
+ iteratees = arrayMap(iteratees, function(iteratee) {
+ if (isArray(iteratee)) {
+ return function(value) {
+ return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
+ }
+ }
+ return iteratee;
+ });
+ } else {
+ iteratees = [identity];
+ }
+
+ var index = -1;
+ iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
+
+ var result = baseMap(collection, function(value, key, collection) {
+ var criteria = arrayMap(iteratees, function(iteratee) {
+ return iteratee(value);
+ });
+ return { 'criteria': criteria, 'index': ++index, 'value': value };
+ });
+
+ return baseSortBy(result, function(object, other) {
+ return compareMultiple(object, other, orders);
+ });
+ }
+
+ /**
+ * The base implementation of `_.pick` without support for individual
+ * property identifiers.
+ *
+ * @private
+ * @param {Object} object The source object.
+ * @param {string[]} paths The property paths to pick.
+ * @returns {Object} Returns the new object.
+ */
+ function basePick(object, paths) {
+ return basePickBy(object, paths, function(value, path) {
+ return hasIn(object, path);
+ });
+ }
+
+ /**
+ * The base implementation of `_.pickBy` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The source object.
+ * @param {string[]} paths The property paths to pick.
+ * @param {Function} predicate The function invoked per property.
+ * @returns {Object} Returns the new object.
+ */
+ function basePickBy(object, paths, predicate) {
+ var index = -1,
+ length = paths.length,
+ result = {};
+
+ while (++index < length) {
+ var path = paths[index],
+ value = baseGet(object, path);
+
+ if (predicate(value, path)) {
+ baseSet(result, castPath(path, object), value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * A specialized version of `baseProperty` which supports deep paths.
+ *
+ * @private
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+ function basePropertyDeep(path) {
+ return function(object) {
+ return baseGet(object, path);
+ };
+ }
+
+ /**
+ * The base implementation of `_.pullAllBy` without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to remove.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns `array`.
+ */
+ function basePullAll(array, values, iteratee, comparator) {
+ var indexOf = comparator ? baseIndexOfWith : baseIndexOf,
+ index = -1,
+ length = values.length,
+ seen = array;
+
+ if (array === values) {
+ values = copyArray(values);
+ }
+ if (iteratee) {
+ seen = arrayMap(array, baseUnary(iteratee));
+ }
+ while (++index < length) {
+ var fromIndex = 0,
+ value = values[index],
+ computed = iteratee ? iteratee(value) : value;
+
+ while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
+ if (seen !== array) {
+ splice.call(seen, fromIndex, 1);
+ }
+ splice.call(array, fromIndex, 1);
+ }
+ }
+ return array;
+ }
+
+ /**
+ * The base implementation of `_.pullAt` without support for individual
+ * indexes or capturing the removed elements.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {number[]} indexes The indexes of elements to remove.
+ * @returns {Array} Returns `array`.
+ */
+ function basePullAt(array, indexes) {
+ var length = array ? indexes.length : 0,
+ lastIndex = length - 1;
+
+ while (length--) {
+ var index = indexes[length];
+ if (length == lastIndex || index !== previous) {
+ var previous = index;
+ if (isIndex(index)) {
+ splice.call(array, index, 1);
+ } else {
+ baseUnset(array, index);
+ }
+ }
+ }
+ return array;
+ }
+
+ /**
+ * The base implementation of `_.random` without support for returning
+ * floating-point numbers.
+ *
+ * @private
+ * @param {number} lower The lower bound.
+ * @param {number} upper The upper bound.
+ * @returns {number} Returns the random number.
+ */
+ function baseRandom(lower, upper) {
+ return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
+ }
+
+ /**
+ * The base implementation of `_.range` and `_.rangeRight` which doesn't
+ * coerce arguments.
+ *
+ * @private
+ * @param {number} start The start of the range.
+ * @param {number} end The end of the range.
+ * @param {number} step The value to increment or decrement by.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Array} Returns the range of numbers.
+ */
+ function baseRange(start, end, step, fromRight) {
+ var index = -1,
+ length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
+ result = Array(length);
+
+ while (length--) {
+ result[fromRight ? length : ++index] = start;
+ start += step;
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.repeat` which doesn't coerce arguments.
+ *
+ * @private
+ * @param {string} string The string to repeat.
+ * @param {number} n The number of times to repeat the string.
+ * @returns {string} Returns the repeated string.
+ */
+ function baseRepeat(string, n) {
+ var result = '';
+ if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
+ return result;
+ }
+ // Leverage the exponentiation by squaring algorithm for a faster repeat.
+ // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
+ do {
+ if (n % 2) {
+ result += string;
+ }
+ n = nativeFloor(n / 2);
+ if (n) {
+ string += string;
+ }
+ } while (n);
+
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.rest` which doesn't validate or coerce arguments.
+ *
+ * @private
+ * @param {Function} func The function to apply a rest parameter to.
+ * @param {number} [start=func.length-1] The start position of the rest parameter.
+ * @returns {Function} Returns the new function.
+ */
+ function baseRest(func, start) {
+ return setToString(overRest(func, start, identity), func + '');
+ }
+
+ /**
+ * The base implementation of `_.sample`.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to sample.
+ * @returns {*} Returns the random element.
+ */
+ function baseSample(collection) {
+ return arraySample(values(collection));
+ }
+
+ /**
+ * The base implementation of `_.sampleSize` without param guards.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to sample.
+ * @param {number} n The number of elements to sample.
+ * @returns {Array} Returns the random elements.
+ */
+ function baseSampleSize(collection, n) {
+ var array = values(collection);
+ return shuffleSelf(array, baseClamp(n, 0, array.length));
+ }
+
+ /**
+ * The base implementation of `_.set`.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {*} value The value to set.
+ * @param {Function} [customizer] The function to customize path creation.
+ * @returns {Object} Returns `object`.
+ */
+ function baseSet(object, path, value, customizer) {
+ if (!isObject(object)) {
+ return object;
+ }
+ path = castPath(path, object);
+
+ var index = -1,
+ length = path.length,
+ lastIndex = length - 1,
+ nested = object;
+
+ while (nested != null && ++index < length) {
+ var key = toKey(path[index]),
+ newValue = value;
+
+ if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+ return object;
+ }
+
+ if (index != lastIndex) {
+ var objValue = nested[key];
+ newValue = customizer ? customizer(objValue, key, nested) : undefined$1;
+ if (newValue === undefined$1) {
+ newValue = isObject(objValue)
+ ? objValue
+ : (isIndex(path[index + 1]) ? [] : {});
+ }
+ }
+ assignValue(nested, key, newValue);
+ nested = nested[key];
+ }
+ return object;
+ }
+
+ /**
+ * The base implementation of `setData` without support for hot loop shorting.
+ *
+ * @private
+ * @param {Function} func The function to associate metadata with.
+ * @param {*} data The metadata.
+ * @returns {Function} Returns `func`.
+ */
+ var baseSetData = !metaMap ? identity : function(func, data) {
+ metaMap.set(func, data);
+ return func;
+ };
+
+ /**
+ * The base implementation of `setToString` without support for hot loop shorting.
+ *
+ * @private
+ * @param {Function} func The function to modify.
+ * @param {Function} string The `toString` result.
+ * @returns {Function} Returns `func`.
+ */
+ var baseSetToString = !defineProperty ? identity : function(func, string) {
+ return defineProperty(func, 'toString', {
+ 'configurable': true,
+ 'enumerable': false,
+ 'value': constant(string),
+ 'writable': true
+ });
+ };
+
+ /**
+ * The base implementation of `_.shuffle`.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to shuffle.
+ * @returns {Array} Returns the new shuffled array.
+ */
+ function baseShuffle(collection) {
+ return shuffleSelf(values(collection));
+ }
+
+ /**
+ * The base implementation of `_.slice` without an iteratee call guard.
+ *
+ * @private
+ * @param {Array} array The array to slice.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns the slice of `array`.
+ */
+ function baseSlice(array, start, end) {
+ var index = -1,
+ length = array.length;
+
+ if (start < 0) {
+ start = -start > length ? 0 : (length + start);
+ }
+ end = end > length ? length : end;
+ if (end < 0) {
+ end += length;
+ }
+ length = start > end ? 0 : ((end - start) >>> 0);
+ start >>>= 0;
+
+ var result = Array(length);
+ while (++index < length) {
+ result[index] = array[index + start];
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.some` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ * else `false`.
+ */
+ function baseSome(collection, predicate) {
+ var result;
+
+ baseEach(collection, function(value, index, collection) {
+ result = predicate(value, index, collection);
+ return !result;
+ });
+ return !!result;
+ }
+
+ /**
+ * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which
+ * performs a binary search of `array` to determine the index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
+ *
+ * @private
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {boolean} [retHighest] Specify returning the highest qualified index.
+ * @returns {number} Returns the index at which `value` should be inserted
+ * into `array`.
+ */
+ function baseSortedIndex(array, value, retHighest) {
+ var low = 0,
+ high = array == null ? low : array.length;
+
+ if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
+ while (low < high) {
+ var mid = (low + high) >>> 1,
+ computed = array[mid];
+
+ if (computed !== null && !isSymbol(computed) &&
+ (retHighest ? (computed <= value) : (computed < value))) {
+ low = mid + 1;
+ } else {
+ high = mid;
+ }
+ }
+ return high;
+ }
+ return baseSortedIndexBy(array, value, identity, retHighest);
+ }
+
+ /**
+ * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
+ * which invokes `iteratee` for `value` and each element of `array` to compute
+ * their sort ranking. The iteratee is invoked with one argument; (value).
+ *
+ * @private
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {Function} iteratee The iteratee invoked per element.
+ * @param {boolean} [retHighest] Specify returning the highest qualified index.
+ * @returns {number} Returns the index at which `value` should be inserted
+ * into `array`.
+ */
+ function baseSortedIndexBy(array, value, iteratee, retHighest) {
+ var low = 0,
+ high = array == null ? 0 : array.length;
+ if (high === 0) {
+ return 0;
+ }
+
+ value = iteratee(value);
+ var valIsNaN = value !== value,
+ valIsNull = value === null,
+ valIsSymbol = isSymbol(value),
+ valIsUndefined = value === undefined$1;
+
+ while (low < high) {
+ var mid = nativeFloor((low + high) / 2),
+ computed = iteratee(array[mid]),
+ othIsDefined = computed !== undefined$1,
+ othIsNull = computed === null,
+ othIsReflexive = computed === computed,
+ othIsSymbol = isSymbol(computed);
+
+ if (valIsNaN) {
+ var setLow = retHighest || othIsReflexive;
+ } else if (valIsUndefined) {
+ setLow = othIsReflexive && (retHighest || othIsDefined);
+ } else if (valIsNull) {
+ setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
+ } else if (valIsSymbol) {
+ setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
+ } else if (othIsNull || othIsSymbol) {
+ setLow = false;
+ } else {
+ setLow = retHighest ? (computed <= value) : (computed < value);
+ }
+ if (setLow) {
+ low = mid + 1;
+ } else {
+ high = mid;
+ }
+ }
+ return nativeMin(high, MAX_ARRAY_INDEX);
+ }
+
+ /**
+ * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without
+ * support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @returns {Array} Returns the new duplicate free array.
+ */
+ function baseSortedUniq(array, iteratee) {
+ var index = -1,
+ length = array.length,
+ resIndex = 0,
+ result = [];
+
+ while (++index < length) {
+ var value = array[index],
+ computed = iteratee ? iteratee(value) : value;
+
+ if (!index || !eq(computed, seen)) {
+ var seen = computed;
+ result[resIndex++] = value === 0 ? 0 : value;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.toNumber` which doesn't ensure correct
+ * conversions of binary, hexadecimal, or octal string values.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ */
+ function baseToNumber(value) {
+ if (typeof value == 'number') {
+ return value;
+ }
+ if (isSymbol(value)) {
+ return NAN;
+ }
+ return +value;
+ }
+
+ /**
+ * The base implementation of `_.toString` which doesn't convert nullish
+ * values to empty strings.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+ function baseToString(value) {
+ // Exit early for strings to avoid a performance hit in some environments.
+ if (typeof value == 'string') {
+ return value;
+ }
+ if (isArray(value)) {
+ // Recursively convert values (susceptible to call stack limits).
+ return arrayMap(value, baseToString) + '';
+ }
+ if (isSymbol(value)) {
+ return symbolToString ? symbolToString.call(value) : '';
+ }
+ var result = (value + '');
+ return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+ }
+
+ /**
+ * The base implementation of `_.uniqBy` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new duplicate free array.
+ */
+ function baseUniq(array, iteratee, comparator) {
+ var index = -1,
+ includes = arrayIncludes,
+ length = array.length,
+ isCommon = true,
+ result = [],
+ seen = result;
+
+ if (comparator) {
+ isCommon = false;
+ includes = arrayIncludesWith;
+ }
+ else if (length >= LARGE_ARRAY_SIZE) {
+ var set = iteratee ? null : createSet(array);
+ if (set) {
+ return setToArray(set);
+ }
+ isCommon = false;
+ includes = cacheHas;
+ seen = new SetCache;
+ }
+ else {
+ seen = iteratee ? [] : result;
+ }
+ outer:
+ while (++index < length) {
+ var value = array[index],
+ computed = iteratee ? iteratee(value) : value;
+
+ value = (comparator || value !== 0) ? value : 0;
+ if (isCommon && computed === computed) {
+ var seenIndex = seen.length;
+ while (seenIndex--) {
+ if (seen[seenIndex] === computed) {
+ continue outer;
+ }
+ }
+ if (iteratee) {
+ seen.push(computed);
+ }
+ result.push(value);
+ }
+ else if (!includes(seen, computed, comparator)) {
+ if (seen !== result) {
+ seen.push(computed);
+ }
+ result.push(value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.unset`.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The property path to unset.
+ * @returns {boolean} Returns `true` if the property is deleted, else `false`.
+ */
+ function baseUnset(object, path) {
+ path = castPath(path, object);
+ object = parent(object, path);
+ return object == null || delete object[toKey(last(path))];
+ }
+
+ /**
+ * The base implementation of `_.update`.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to update.
+ * @param {Function} updater The function to produce the updated value.
+ * @param {Function} [customizer] The function to customize path creation.
+ * @returns {Object} Returns `object`.
+ */
+ function baseUpdate(object, path, updater, customizer) {
+ return baseSet(object, path, updater(baseGet(object, path)), customizer);
+ }
+
+ /**
+ * The base implementation of methods like `_.dropWhile` and `_.takeWhile`
+ * without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to query.
+ * @param {Function} predicate The function invoked per iteration.
+ * @param {boolean} [isDrop] Specify dropping elements instead of taking them.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Array} Returns the slice of `array`.
+ */
+ function baseWhile(array, predicate, isDrop, fromRight) {
+ var length = array.length,
+ index = fromRight ? length : -1;
+
+ while ((fromRight ? index-- : ++index < length) &&
+ predicate(array[index], index, array)) {}
+
+ return isDrop
+ ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))
+ : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));
+ }
+
+ /**
+ * The base implementation of `wrapperValue` which returns the result of
+ * performing a sequence of actions on the unwrapped `value`, where each
+ * successive action is supplied the return value of the previous.
+ *
+ * @private
+ * @param {*} value The unwrapped value.
+ * @param {Array} actions Actions to perform to resolve the unwrapped value.
+ * @returns {*} Returns the resolved value.
+ */
+ function baseWrapperValue(value, actions) {
+ var result = value;
+ if (result instanceof LazyWrapper) {
+ result = result.value();
+ }
+ return arrayReduce(actions, function(result, action) {
+ return action.func.apply(action.thisArg, arrayPush([result], action.args));
+ }, result);
+ }
+
+ /**
+ * The base implementation of methods like `_.xor`, without support for
+ * iteratee shorthands, that accepts an array of arrays to inspect.
+ *
+ * @private
+ * @param {Array} arrays The arrays to inspect.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of values.
+ */
+ function baseXor(arrays, iteratee, comparator) {
+ var length = arrays.length;
+ if (length < 2) {
+ return length ? baseUniq(arrays[0]) : [];
+ }
+ var index = -1,
+ result = Array(length);
+
+ while (++index < length) {
+ var array = arrays[index],
+ othIndex = -1;
+
+ while (++othIndex < length) {
+ if (othIndex != index) {
+ result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
+ }
+ }
+ }
+ return baseUniq(baseFlatten(result, 1), iteratee, comparator);
+ }
+
+ /**
+ * This base implementation of `_.zipObject` which assigns values using `assignFunc`.
+ *
+ * @private
+ * @param {Array} props The property identifiers.
+ * @param {Array} values The property values.
+ * @param {Function} assignFunc The function to assign values.
+ * @returns {Object} Returns the new object.
+ */
+ function baseZipObject(props, values, assignFunc) {
+ var index = -1,
+ length = props.length,
+ valsLength = values.length,
+ result = {};
+
+ while (++index < length) {
+ var value = index < valsLength ? values[index] : undefined$1;
+ assignFunc(result, props[index], value);
+ }
+ return result;
+ }
+
+ /**
+ * Casts `value` to an empty array if it's not an array like object.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {Array|Object} Returns the cast array-like object.
+ */
+ function castArrayLikeObject(value) {
+ return isArrayLikeObject(value) ? value : [];
+ }
+
+ /**
+ * Casts `value` to `identity` if it's not a function.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {Function} Returns cast function.
+ */
+ function castFunction(value) {
+ return typeof value == 'function' ? value : identity;
+ }
+
+ /**
+ * Casts `value` to a path array if it's not one.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {Array} Returns the cast property path array.
+ */
+ function castPath(value, object) {
+ if (isArray(value)) {
+ return value;
+ }
+ return isKey(value, object) ? [value] : stringToPath(toString(value));
+ }
+
+ /**
+ * A `baseRest` alias which can be replaced with `identity` by module
+ * replacement plugins.
+ *
+ * @private
+ * @type {Function}
+ * @param {Function} func The function to apply a rest parameter to.
+ * @returns {Function} Returns the new function.
+ */
+ var castRest = baseRest;
+
+ /**
+ * Casts `array` to a slice if it's needed.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {number} start The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns the cast slice.
+ */
+ function castSlice(array, start, end) {
+ var length = array.length;
+ end = end === undefined$1 ? length : end;
+ return (!start && end >= length) ? array : baseSlice(array, start, end);
+ }
+
+ /**
+ * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).
+ *
+ * @private
+ * @param {number|Object} id The timer id or timeout object of the timer to clear.
+ */
+ var clearTimeout = ctxClearTimeout || function(id) {
+ return root.clearTimeout(id);
+ };
+
+ /**
+ * Creates a clone of `buffer`.
+ *
+ * @private
+ * @param {Buffer} buffer The buffer to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Buffer} Returns the cloned buffer.
+ */
+ function cloneBuffer(buffer, isDeep) {
+ if (isDeep) {
+ return buffer.slice();
+ }
+ var length = buffer.length,
+ result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+
+ buffer.copy(result);
+ return result;
+ }
+
+ /**
+ * Creates a clone of `arrayBuffer`.
+ *
+ * @private
+ * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+ * @returns {ArrayBuffer} Returns the cloned array buffer.
+ */
+ function cloneArrayBuffer(arrayBuffer) {
+ var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+ new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+ return result;
+ }
+
+ /**
+ * Creates a clone of `dataView`.
+ *
+ * @private
+ * @param {Object} dataView The data view to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned data view.
+ */
+ function cloneDataView(dataView, isDeep) {
+ var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+ return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+ }
+
+ /**
+ * Creates a clone of `regexp`.
+ *
+ * @private
+ * @param {Object} regexp The regexp to clone.
+ * @returns {Object} Returns the cloned regexp.
+ */
+ function cloneRegExp(regexp) {
+ var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+ result.lastIndex = regexp.lastIndex;
+ return result;
+ }
+
+ /**
+ * Creates a clone of the `symbol` object.
+ *
+ * @private
+ * @param {Object} symbol The symbol object to clone.
+ * @returns {Object} Returns the cloned symbol object.
+ */
+ function cloneSymbol(symbol) {
+ return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+ }
+
+ /**
+ * Creates a clone of `typedArray`.
+ *
+ * @private
+ * @param {Object} typedArray The typed array to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned typed array.
+ */
+ function cloneTypedArray(typedArray, isDeep) {
+ var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+ return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+ }
+
+ /**
+ * Compares values to sort them in ascending order.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {number} Returns the sort order indicator for `value`.
+ */
+ function compareAscending(value, other) {
+ if (value !== other) {
+ var valIsDefined = value !== undefined$1,
+ valIsNull = value === null,
+ valIsReflexive = value === value,
+ valIsSymbol = isSymbol(value);
+
+ var othIsDefined = other !== undefined$1,
+ othIsNull = other === null,
+ othIsReflexive = other === other,
+ othIsSymbol = isSymbol(other);
+
+ if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
+ (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
+ (valIsNull && othIsDefined && othIsReflexive) ||
+ (!valIsDefined && othIsReflexive) ||
+ !valIsReflexive) {
+ return 1;
+ }
+ if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
+ (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
+ (othIsNull && valIsDefined && valIsReflexive) ||
+ (!othIsDefined && valIsReflexive) ||
+ !othIsReflexive) {
+ return -1;
+ }
+ }
+ return 0;
+ }
+
+ /**
+ * Used by `_.orderBy` to compare multiple properties of a value to another
+ * and stable sort them.
+ *
+ * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
+ * specify an order of "desc" for descending or "asc" for ascending sort order
+ * of corresponding values.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {boolean[]|string[]} orders The order to sort by for each property.
+ * @returns {number} Returns the sort order indicator for `object`.
+ */
+ function compareMultiple(object, other, orders) {
+ var index = -1,
+ objCriteria = object.criteria,
+ othCriteria = other.criteria,
+ length = objCriteria.length,
+ ordersLength = orders.length;
+
+ while (++index < length) {
+ var result = compareAscending(objCriteria[index], othCriteria[index]);
+ if (result) {
+ if (index >= ordersLength) {
+ return result;
+ }
+ var order = orders[index];
+ return result * (order == 'desc' ? -1 : 1);
+ }
+ }
+ // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
+ // that causes it, under certain circumstances, to provide the same value for
+ // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247
+ // for more details.
+ //
+ // This also ensures a stable sort in V8 and other engines.
+ // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
+ return object.index - other.index;
+ }
+
+ /**
+ * Creates an array that is the composition of partially applied arguments,
+ * placeholders, and provided arguments into a single array of arguments.
+ *
+ * @private
+ * @param {Array} args The provided arguments.
+ * @param {Array} partials The arguments to prepend to those provided.
+ * @param {Array} holders The `partials` placeholder indexes.
+ * @params {boolean} [isCurried] Specify composing for a curried function.
+ * @returns {Array} Returns the new array of composed arguments.
+ */
+ function composeArgs(args, partials, holders, isCurried) {
+ var argsIndex = -1,
+ argsLength = args.length,
+ holdersLength = holders.length,
+ leftIndex = -1,
+ leftLength = partials.length,
+ rangeLength = nativeMax(argsLength - holdersLength, 0),
+ result = Array(leftLength + rangeLength),
+ isUncurried = !isCurried;
+
+ while (++leftIndex < leftLength) {
+ result[leftIndex] = partials[leftIndex];
+ }
+ while (++argsIndex < holdersLength) {
+ if (isUncurried || argsIndex < argsLength) {
+ result[holders[argsIndex]] = args[argsIndex];
+ }
+ }
+ while (rangeLength--) {
+ result[leftIndex++] = args[argsIndex++];
+ }
+ return result;
+ }
+
+ /**
+ * This function is like `composeArgs` except that the arguments composition
+ * is tailored for `_.partialRight`.
+ *
+ * @private
+ * @param {Array} args The provided arguments.
+ * @param {Array} partials The arguments to append to those provided.
+ * @param {Array} holders The `partials` placeholder indexes.
+ * @params {boolean} [isCurried] Specify composing for a curried function.
+ * @returns {Array} Returns the new array of composed arguments.
+ */
+ function composeArgsRight(args, partials, holders, isCurried) {
+ var argsIndex = -1,
+ argsLength = args.length,
+ holdersIndex = -1,
+ holdersLength = holders.length,
+ rightIndex = -1,
+ rightLength = partials.length,
+ rangeLength = nativeMax(argsLength - holdersLength, 0),
+ result = Array(rangeLength + rightLength),
+ isUncurried = !isCurried;
+
+ while (++argsIndex < rangeLength) {
+ result[argsIndex] = args[argsIndex];
+ }
+ var offset = argsIndex;
+ while (++rightIndex < rightLength) {
+ result[offset + rightIndex] = partials[rightIndex];
+ }
+ while (++holdersIndex < holdersLength) {
+ if (isUncurried || argsIndex < argsLength) {
+ result[offset + holders[holdersIndex]] = args[argsIndex++];
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Copies the values of `source` to `array`.
+ *
+ * @private
+ * @param {Array} source The array to copy values from.
+ * @param {Array} [array=[]] The array to copy values to.
+ * @returns {Array} Returns `array`.
+ */
+ function copyArray(source, array) {
+ var index = -1,
+ length = source.length;
+
+ array || (array = Array(length));
+ while (++index < length) {
+ array[index] = source[index];
+ }
+ return array;
+ }
+
+ /**
+ * Copies properties of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy properties from.
+ * @param {Array} props The property identifiers to copy.
+ * @param {Object} [object={}] The object to copy properties to.
+ * @param {Function} [customizer] The function to customize copied values.
+ * @returns {Object} Returns `object`.
+ */
+ function copyObject(source, props, object, customizer) {
+ var isNew = !object;
+ object || (object = {});
+
+ var index = -1,
+ length = props.length;
+
+ while (++index < length) {
+ var key = props[index];
+
+ var newValue = customizer
+ ? customizer(object[key], source[key], key, object, source)
+ : undefined$1;
+
+ if (newValue === undefined$1) {
+ newValue = source[key];
+ }
+ if (isNew) {
+ baseAssignValue(object, key, newValue);
+ } else {
+ assignValue(object, key, newValue);
+ }
+ }
+ return object;
+ }
+
+ /**
+ * Copies own symbols of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy symbols from.
+ * @param {Object} [object={}] The object to copy symbols to.
+ * @returns {Object} Returns `object`.
+ */
+ function copySymbols(source, object) {
+ return copyObject(source, getSymbols(source), object);
+ }
+
+ /**
+ * Copies own and inherited symbols of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy symbols from.
+ * @param {Object} [object={}] The object to copy symbols to.
+ * @returns {Object} Returns `object`.
+ */
+ function copySymbolsIn(source, object) {
+ return copyObject(source, getSymbolsIn(source), object);
+ }
+
+ /**
+ * Creates a function like `_.groupBy`.
+ *
+ * @private
+ * @param {Function} setter The function to set accumulator values.
+ * @param {Function} [initializer] The accumulator object initializer.
+ * @returns {Function} Returns the new aggregator function.
+ */
+ function createAggregator(setter, initializer) {
+ return function(collection, iteratee) {
+ var func = isArray(collection) ? arrayAggregator : baseAggregator,
+ accumulator = initializer ? initializer() : {};
+
+ return func(collection, setter, getIteratee(iteratee, 2), accumulator);
+ };
+ }
+
+ /**
+ * Creates a function like `_.assign`.
+ *
+ * @private
+ * @param {Function} assigner The function to assign values.
+ * @returns {Function} Returns the new assigner function.
+ */
+ function createAssigner(assigner) {
+ return baseRest(function(object, sources) {
+ var index = -1,
+ length = sources.length,
+ customizer = length > 1 ? sources[length - 1] : undefined$1,
+ guard = length > 2 ? sources[2] : undefined$1;
+
+ customizer = (assigner.length > 3 && typeof customizer == 'function')
+ ? (length--, customizer)
+ : undefined$1;
+
+ if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+ customizer = length < 3 ? undefined$1 : customizer;
+ length = 1;
+ }
+ object = Object(object);
+ while (++index < length) {
+ var source = sources[index];
+ if (source) {
+ assigner(object, source, index, customizer);
+ }
+ }
+ return object;
+ });
+ }
+
+ /**
+ * Creates a `baseEach` or `baseEachRight` function.
+ *
+ * @private
+ * @param {Function} eachFunc The function to iterate over a collection.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+ function createBaseEach(eachFunc, fromRight) {
+ return function(collection, iteratee) {
+ if (collection == null) {
+ return collection;
+ }
+ if (!isArrayLike(collection)) {
+ return eachFunc(collection, iteratee);
+ }
+ var length = collection.length,
+ index = fromRight ? length : -1,
+ iterable = Object(collection);
+
+ while ((fromRight ? index-- : ++index < length)) {
+ if (iteratee(iterable[index], index, iterable) === false) {
+ break;
+ }
+ }
+ return collection;
+ };
+ }
+
+ /**
+ * Creates a base function for methods like `_.forIn` and `_.forOwn`.
+ *
+ * @private
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+ function createBaseFor(fromRight) {
+ return function(object, iteratee, keysFunc) {
+ var index = -1,
+ iterable = Object(object),
+ props = keysFunc(object),
+ length = props.length;
+
+ while (length--) {
+ var key = props[fromRight ? length : ++index];
+ if (iteratee(iterable[key], key, iterable) === false) {
+ break;
+ }
+ }
+ return object;
+ };
+ }
+
+ /**
+ * Creates a function that wraps `func` to invoke it with the optional `this`
+ * binding of `thisArg`.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @returns {Function} Returns the new wrapped function.
+ */
+ function createBind(func, bitmask, thisArg) {
+ var isBind = bitmask & WRAP_BIND_FLAG,
+ Ctor = createCtor(func);
+
+ function wrapper() {
+ var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
+ return fn.apply(isBind ? thisArg : this, arguments);
+ }
+ return wrapper;
+ }
+
+ /**
+ * Creates a function like `_.lowerFirst`.
+ *
+ * @private
+ * @param {string} methodName The name of the `String` case method to use.
+ * @returns {Function} Returns the new case function.
+ */
+ function createCaseFirst(methodName) {
+ return function(string) {
+ string = toString(string);
+
+ var strSymbols = hasUnicode(string)
+ ? stringToArray(string)
+ : undefined$1;
+
+ var chr = strSymbols
+ ? strSymbols[0]
+ : string.charAt(0);
+
+ var trailing = strSymbols
+ ? castSlice(strSymbols, 1).join('')
+ : string.slice(1);
+
+ return chr[methodName]() + trailing;
+ };
+ }
+
+ /**
+ * Creates a function like `_.camelCase`.
+ *
+ * @private
+ * @param {Function} callback The function to combine each word.
+ * @returns {Function} Returns the new compounder function.
+ */
+ function createCompounder(callback) {
+ return function(string) {
+ return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
+ };
+ }
+
+ /**
+ * Creates a function that produces an instance of `Ctor` regardless of
+ * whether it was invoked as part of a `new` expression or by `call` or `apply`.
+ *
+ * @private
+ * @param {Function} Ctor The constructor to wrap.
+ * @returns {Function} Returns the new wrapped function.
+ */
+ function createCtor(Ctor) {
+ return function() {
+ // Use a `switch` statement to work with class constructors. See
+ // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
+ // for more details.
+ var args = arguments;
+ switch (args.length) {
+ case 0: return new Ctor;
+ case 1: return new Ctor(args[0]);
+ case 2: return new Ctor(args[0], args[1]);
+ case 3: return new Ctor(args[0], args[1], args[2]);
+ case 4: return new Ctor(args[0], args[1], args[2], args[3]);
+ case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);
+ case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
+ case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
+ }
+ var thisBinding = baseCreate(Ctor.prototype),
+ result = Ctor.apply(thisBinding, args);
+
+ // Mimic the constructor's `return` behavior.
+ // See https://es5.github.io/#x13.2.2 for more details.
+ return isObject(result) ? result : thisBinding;
+ };
+ }
+
+ /**
+ * Creates a function that wraps `func` to enable currying.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
+ * @param {number} arity The arity of `func`.
+ * @returns {Function} Returns the new wrapped function.
+ */
+ function createCurry(func, bitmask, arity) {
+ var Ctor = createCtor(func);
+
+ function wrapper() {
+ var length = arguments.length,
+ args = Array(length),
+ index = length,
+ placeholder = getHolder(wrapper);
+
+ while (index--) {
+ args[index] = arguments[index];
+ }
+ var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)
+ ? []
+ : replaceHolders(args, placeholder);
+
+ length -= holders.length;
+ if (length < arity) {
+ return createRecurry(
+ func, bitmask, createHybrid, wrapper.placeholder, undefined$1,
+ args, holders, undefined$1, undefined$1, arity - length);
+ }
+ var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
+ return apply(fn, this, args);
+ }
+ return wrapper;
+ }
+
+ /**
+ * Creates a `_.find` or `_.findLast` function.
+ *
+ * @private
+ * @param {Function} findIndexFunc The function to find the collection index.
+ * @returns {Function} Returns the new find function.
+ */
+ function createFind(findIndexFunc) {
+ return function(collection, predicate, fromIndex) {
+ var iterable = Object(collection);
+ if (!isArrayLike(collection)) {
+ var iteratee = getIteratee(predicate, 3);
+ collection = keys(collection);
+ predicate = function(key) { return iteratee(iterable[key], key, iterable); };
+ }
+ var index = findIndexFunc(collection, predicate, fromIndex);
+ return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined$1;
+ };
+ }
+
+ /**
+ * Creates a `_.flow` or `_.flowRight` function.
+ *
+ * @private
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new flow function.
+ */
+ function createFlow(fromRight) {
+ return flatRest(function(funcs) {
+ var length = funcs.length,
+ index = length,
+ prereq = LodashWrapper.prototype.thru;
+
+ if (fromRight) {
+ funcs.reverse();
+ }
+ while (index--) {
+ var func = funcs[index];
+ if (typeof func != 'function') {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ if (prereq && !wrapper && getFuncName(func) == 'wrapper') {
+ var wrapper = new LodashWrapper([], true);
+ }
+ }
+ index = wrapper ? index : length;
+ while (++index < length) {
+ func = funcs[index];
+
+ var funcName = getFuncName(func),
+ data = funcName == 'wrapper' ? getData(func) : undefined$1;
+
+ if (data && isLaziable(data[0]) &&
+ data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&
+ !data[4].length && data[9] == 1
+ ) {
+ wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
+ } else {
+ wrapper = (func.length == 1 && isLaziable(func))
+ ? wrapper[funcName]()
+ : wrapper.thru(func);
+ }
+ }
+ return function() {
+ var args = arguments,
+ value = args[0];
+
+ if (wrapper && args.length == 1 && isArray(value)) {
+ return wrapper.plant(value).value();
+ }
+ var index = 0,
+ result = length ? funcs[index].apply(this, args) : value;
+
+ while (++index < length) {
+ result = funcs[index].call(this, result);
+ }
+ return result;
+ };
+ });
+ }
+
+ /**
+ * Creates a function that wraps `func` to invoke it with optional `this`
+ * binding of `thisArg`, partial application, and currying.
+ *
+ * @private
+ * @param {Function|string} func The function or method name to wrap.
+ * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {Array} [partials] The arguments to prepend to those provided to
+ * the new function.
+ * @param {Array} [holders] The `partials` placeholder indexes.
+ * @param {Array} [partialsRight] The arguments to append to those provided
+ * to the new function.
+ * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
+ * @param {Array} [argPos] The argument positions of the new function.
+ * @param {number} [ary] The arity cap of `func`.
+ * @param {number} [arity] The arity of `func`.
+ * @returns {Function} Returns the new wrapped function.
+ */
+ function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
+ var isAry = bitmask & WRAP_ARY_FLAG,
+ isBind = bitmask & WRAP_BIND_FLAG,
+ isBindKey = bitmask & WRAP_BIND_KEY_FLAG,
+ isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),
+ isFlip = bitmask & WRAP_FLIP_FLAG,
+ Ctor = isBindKey ? undefined$1 : createCtor(func);
+
+ function wrapper() {
+ var length = arguments.length,
+ args = Array(length),
+ index = length;
+
+ while (index--) {
+ args[index] = arguments[index];
+ }
+ if (isCurried) {
+ var placeholder = getHolder(wrapper),
+ holdersCount = countHolders(args, placeholder);
+ }
+ if (partials) {
+ args = composeArgs(args, partials, holders, isCurried);
+ }
+ if (partialsRight) {
+ args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
+ }
+ length -= holdersCount;
+ if (isCurried && length < arity) {
+ var newHolders = replaceHolders(args, placeholder);
+ return createRecurry(
+ func, bitmask, createHybrid, wrapper.placeholder, thisArg,
+ args, newHolders, argPos, ary, arity - length
+ );
+ }
+ var thisBinding = isBind ? thisArg : this,
+ fn = isBindKey ? thisBinding[func] : func;
+
+ length = args.length;
+ if (argPos) {
+ args = reorder(args, argPos);
+ } else if (isFlip && length > 1) {
+ args.reverse();
+ }
+ if (isAry && ary < length) {
+ args.length = ary;
+ }
+ if (this && this !== root && this instanceof wrapper) {
+ fn = Ctor || createCtor(fn);
+ }
+ return fn.apply(thisBinding, args);
+ }
+ return wrapper;
+ }
+
+ /**
+ * Creates a function like `_.invertBy`.
+ *
+ * @private
+ * @param {Function} setter The function to set accumulator values.
+ * @param {Function} toIteratee The function to resolve iteratees.
+ * @returns {Function} Returns the new inverter function.
+ */
+ function createInverter(setter, toIteratee) {
+ return function(object, iteratee) {
+ return baseInverter(object, setter, toIteratee(iteratee), {});
+ };
+ }
+
+ /**
+ * Creates a function that performs a mathematical operation on two values.
+ *
+ * @private
+ * @param {Function} operator The function to perform the operation.
+ * @param {number} [defaultValue] The value used for `undefined` arguments.
+ * @returns {Function} Returns the new mathematical operation function.
+ */
+ function createMathOperation(operator, defaultValue) {
+ return function(value, other) {
+ var result;
+ if (value === undefined$1 && other === undefined$1) {
+ return defaultValue;
+ }
+ if (value !== undefined$1) {
+ result = value;
+ }
+ if (other !== undefined$1) {
+ if (result === undefined$1) {
+ return other;
+ }
+ if (typeof value == 'string' || typeof other == 'string') {
+ value = baseToString(value);
+ other = baseToString(other);
+ } else {
+ value = baseToNumber(value);
+ other = baseToNumber(other);
+ }
+ result = operator(value, other);
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Creates a function like `_.over`.
+ *
+ * @private
+ * @param {Function} arrayFunc The function to iterate over iteratees.
+ * @returns {Function} Returns the new over function.
+ */
+ function createOver(arrayFunc) {
+ return flatRest(function(iteratees) {
+ iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
+ return baseRest(function(args) {
+ var thisArg = this;
+ return arrayFunc(iteratees, function(iteratee) {
+ return apply(iteratee, thisArg, args);
+ });
+ });
+ });
+ }
+
+ /**
+ * Creates the padding for `string` based on `length`. The `chars` string
+ * is truncated if the number of characters exceeds `length`.
+ *
+ * @private
+ * @param {number} length The padding length.
+ * @param {string} [chars=' '] The string used as padding.
+ * @returns {string} Returns the padding for `string`.
+ */
+ function createPadding(length, chars) {
+ chars = chars === undefined$1 ? ' ' : baseToString(chars);
+
+ var charsLength = chars.length;
+ if (charsLength < 2) {
+ return charsLength ? baseRepeat(chars, length) : chars;
+ }
+ var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
+ return hasUnicode(chars)
+ ? castSlice(stringToArray(result), 0, length).join('')
+ : result.slice(0, length);
+ }
+
+ /**
+ * Creates a function that wraps `func` to invoke it with the `this` binding
+ * of `thisArg` and `partials` prepended to the arguments it receives.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
+ * @param {*} thisArg The `this` binding of `func`.
+ * @param {Array} partials The arguments to prepend to those provided to
+ * the new function.
+ * @returns {Function} Returns the new wrapped function.
+ */
+ function createPartial(func, bitmask, thisArg, partials) {
+ var isBind = bitmask & WRAP_BIND_FLAG,
+ Ctor = createCtor(func);
+
+ function wrapper() {
+ var argsIndex = -1,
+ argsLength = arguments.length,
+ leftIndex = -1,
+ leftLength = partials.length,
+ args = Array(leftLength + argsLength),
+ fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
+
+ while (++leftIndex < leftLength) {
+ args[leftIndex] = partials[leftIndex];
+ }
+ while (argsLength--) {
+ args[leftIndex++] = arguments[++argsIndex];
+ }
+ return apply(fn, isBind ? thisArg : this, args);
+ }
+ return wrapper;
+ }
+
+ /**
+ * Creates a `_.range` or `_.rangeRight` function.
+ *
+ * @private
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new range function.
+ */
+ function createRange(fromRight) {
+ return function(start, end, step) {
+ if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {
+ end = step = undefined$1;
+ }
+ // Ensure the sign of `-0` is preserved.
+ start = toFinite(start);
+ if (end === undefined$1) {
+ end = start;
+ start = 0;
+ } else {
+ end = toFinite(end);
+ }
+ step = step === undefined$1 ? (start < end ? 1 : -1) : toFinite(step);
+ return baseRange(start, end, step, fromRight);
+ };
+ }
+
+ /**
+ * Creates a function that performs a relational operation on two values.
+ *
+ * @private
+ * @param {Function} operator The function to perform the operation.
+ * @returns {Function} Returns the new relational operation function.
+ */
+ function createRelationalOperation(operator) {
+ return function(value, other) {
+ if (!(typeof value == 'string' && typeof other == 'string')) {
+ value = toNumber(value);
+ other = toNumber(other);
+ }
+ return operator(value, other);
+ };
+ }
+
+ /**
+ * Creates a function that wraps `func` to continue currying.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
+ * @param {Function} wrapFunc The function to create the `func` wrapper.
+ * @param {*} placeholder The placeholder value.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {Array} [partials] The arguments to prepend to those provided to
+ * the new function.
+ * @param {Array} [holders] The `partials` placeholder indexes.
+ * @param {Array} [argPos] The argument positions of the new function.
+ * @param {number} [ary] The arity cap of `func`.
+ * @param {number} [arity] The arity of `func`.
+ * @returns {Function} Returns the new wrapped function.
+ */
+ function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
+ var isCurry = bitmask & WRAP_CURRY_FLAG,
+ newHolders = isCurry ? holders : undefined$1,
+ newHoldersRight = isCurry ? undefined$1 : holders,
+ newPartials = isCurry ? partials : undefined$1,
+ newPartialsRight = isCurry ? undefined$1 : partials;
+
+ bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);
+ bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
+
+ if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
+ bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
+ }
+ var newData = [
+ func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
+ newHoldersRight, argPos, ary, arity
+ ];
+
+ var result = wrapFunc.apply(undefined$1, newData);
+ if (isLaziable(func)) {
+ setData(result, newData);
+ }
+ result.placeholder = placeholder;
+ return setWrapToString(result, func, bitmask);
+ }
+
+ /**
+ * Creates a function like `_.round`.
+ *
+ * @private
+ * @param {string} methodName The name of the `Math` method to use when rounding.
+ * @returns {Function} Returns the new round function.
+ */
+ function createRound(methodName) {
+ var func = Math[methodName];
+ return function(number, precision) {
+ number = toNumber(number);
+ precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
+ if (precision && nativeIsFinite(number)) {
+ // Shift with exponential notation to avoid floating-point issues.
+ // See [MDN](https://mdn.io/round#Examples) for more details.
+ var pair = (toString(number) + 'e').split('e'),
+ value = func(pair[0] + 'e' + (+pair[1] + precision));
+
+ pair = (toString(value) + 'e').split('e');
+ return +(pair[0] + 'e' + (+pair[1] - precision));
+ }
+ return func(number);
+ };
+ }
+
+ /**
+ * Creates a set object of `values`.
+ *
+ * @private
+ * @param {Array} values The values to add to the set.
+ * @returns {Object} Returns the new set.
+ */
+ var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {
+ return new Set(values);
+ };
+
+ /**
+ * Creates a `_.toPairs` or `_.toPairsIn` function.
+ *
+ * @private
+ * @param {Function} keysFunc The function to get the keys of a given object.
+ * @returns {Function} Returns the new pairs function.
+ */
+ function createToPairs(keysFunc) {
+ return function(object) {
+ var tag = getTag(object);
+ if (tag == mapTag) {
+ return mapToArray(object);
+ }
+ if (tag == setTag) {
+ return setToPairs(object);
+ }
+ return baseToPairs(object, keysFunc(object));
+ };
+ }
+
+ /**
+ * Creates a function that either curries or invokes `func` with optional
+ * `this` binding and partially applied arguments.
+ *
+ * @private
+ * @param {Function|string} func The function or method name to wrap.
+ * @param {number} bitmask The bitmask flags.
+ * 1 - `_.bind`
+ * 2 - `_.bindKey`
+ * 4 - `_.curry` or `_.curryRight` of a bound function
+ * 8 - `_.curry`
+ * 16 - `_.curryRight`
+ * 32 - `_.partial`
+ * 64 - `_.partialRight`
+ * 128 - `_.rearg`
+ * 256 - `_.ary`
+ * 512 - `_.flip`
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {Array} [partials] The arguments to be partially applied.
+ * @param {Array} [holders] The `partials` placeholder indexes.
+ * @param {Array} [argPos] The argument positions of the new function.
+ * @param {number} [ary] The arity cap of `func`.
+ * @param {number} [arity] The arity of `func`.
+ * @returns {Function} Returns the new wrapped function.
+ */
+ function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
+ var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
+ if (!isBindKey && typeof func != 'function') {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ var length = partials ? partials.length : 0;
+ if (!length) {
+ bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
+ partials = holders = undefined$1;
+ }
+ ary = ary === undefined$1 ? ary : nativeMax(toInteger(ary), 0);
+ arity = arity === undefined$1 ? arity : toInteger(arity);
+ length -= holders ? holders.length : 0;
+
+ if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
+ var partialsRight = partials,
+ holdersRight = holders;
+
+ partials = holders = undefined$1;
+ }
+ var data = isBindKey ? undefined$1 : getData(func);
+
+ var newData = [
+ func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,
+ argPos, ary, arity
+ ];
+
+ if (data) {
+ mergeData(newData, data);
+ }
+ func = newData[0];
+ bitmask = newData[1];
+ thisArg = newData[2];
+ partials = newData[3];
+ holders = newData[4];
+ arity = newData[9] = newData[9] === undefined$1
+ ? (isBindKey ? 0 : func.length)
+ : nativeMax(newData[9] - length, 0);
+
+ if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
+ bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
+ }
+ if (!bitmask || bitmask == WRAP_BIND_FLAG) {
+ var result = createBind(func, bitmask, thisArg);
+ } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
+ result = createCurry(func, bitmask, arity);
+ } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
+ result = createPartial(func, bitmask, thisArg, partials);
+ } else {
+ result = createHybrid.apply(undefined$1, newData);
+ }
+ var setter = data ? baseSetData : setData;
+ return setWrapToString(setter(result, newData), func, bitmask);
+ }
+
+ /**
+ * Used by `_.defaults` to customize its `_.assignIn` use to assign properties
+ * of source objects to the destination object for all destination properties
+ * that resolve to `undefined`.
+ *
+ * @private
+ * @param {*} objValue The destination value.
+ * @param {*} srcValue The source value.
+ * @param {string} key The key of the property to assign.
+ * @param {Object} object The parent object of `objValue`.
+ * @returns {*} Returns the value to assign.
+ */
+ function customDefaultsAssignIn(objValue, srcValue, key, object) {
+ if (objValue === undefined$1 ||
+ (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {
+ return srcValue;
+ }
+ return objValue;
+ }
+
+ /**
+ * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source
+ * objects into destination objects that are passed thru.
+ *
+ * @private
+ * @param {*} objValue The destination value.
+ * @param {*} srcValue The source value.
+ * @param {string} key The key of the property to merge.
+ * @param {Object} object The parent object of `objValue`.
+ * @param {Object} source The parent object of `srcValue`.
+ * @param {Object} [stack] Tracks traversed source values and their merged
+ * counterparts.
+ * @returns {*} Returns the value to assign.
+ */
+ function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
+ if (isObject(objValue) && isObject(srcValue)) {
+ // Recursively merge objects and arrays (susceptible to call stack limits).
+ stack.set(srcValue, objValue);
+ baseMerge(objValue, srcValue, undefined$1, customDefaultsMerge, stack);
+ stack['delete'](srcValue);
+ }
+ return objValue;
+ }
+
+ /**
+ * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
+ * objects.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @param {string} key The key of the property to inspect.
+ * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
+ */
+ function customOmitClone(value) {
+ return isPlainObject(value) ? undefined$1 : value;
+ }
+
+ /**
+ * A specialized version of `baseIsEqualDeep` for arrays with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Array} array The array to compare.
+ * @param {Array} other The other array to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `array` and `other` objects.
+ * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+ */
+ function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+ var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
+ arrLength = array.length,
+ othLength = other.length;
+
+ if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+ return false;
+ }
+ // Check that cyclic values are equal.
+ var arrStacked = stack.get(array);
+ var othStacked = stack.get(other);
+ if (arrStacked && othStacked) {
+ return arrStacked == other && othStacked == array;
+ }
+ var index = -1,
+ result = true,
+ seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined$1;
+
+ stack.set(array, other);
+ stack.set(other, array);
+
+ // Ignore non-index properties.
+ while (++index < arrLength) {
+ var arrValue = array[index],
+ othValue = other[index];
+
+ if (customizer) {
+ var compared = isPartial
+ ? customizer(othValue, arrValue, index, other, array, stack)
+ : customizer(arrValue, othValue, index, array, other, stack);
+ }
+ if (compared !== undefined$1) {
+ if (compared) {
+ continue;
+ }
+ result = false;
+ break;
+ }
+ // Recursively compare arrays (susceptible to call stack limits).
+ if (seen) {
+ if (!arraySome(other, function(othValue, othIndex) {
+ if (!cacheHas(seen, othIndex) &&
+ (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+ return seen.push(othIndex);
+ }
+ })) {
+ result = false;
+ break;
+ }
+ } else if (!(
+ arrValue === othValue ||
+ equalFunc(arrValue, othValue, bitmask, customizer, stack)
+ )) {
+ result = false;
+ break;
+ }
+ }
+ stack['delete'](array);
+ stack['delete'](other);
+ return result;
+ }
+
+ /**
+ * A specialized version of `baseIsEqualDeep` for comparing objects of
+ * the same `toStringTag`.
+ *
+ * **Note:** This function only supports comparing values with tags of
+ * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {string} tag The `toStringTag` of the objects to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+ function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+ switch (tag) {
+ case dataViewTag:
+ if ((object.byteLength != other.byteLength) ||
+ (object.byteOffset != other.byteOffset)) {
+ return false;
+ }
+ object = object.buffer;
+ other = other.buffer;
+
+ case arrayBufferTag:
+ if ((object.byteLength != other.byteLength) ||
+ !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+ return false;
+ }
+ return true;
+
+ case boolTag:
+ case dateTag:
+ case numberTag:
+ // Coerce booleans to `1` or `0` and dates to milliseconds.
+ // Invalid dates are coerced to `NaN`.
+ return eq(+object, +other);
+
+ case errorTag:
+ return object.name == other.name && object.message == other.message;
+
+ case regexpTag:
+ case stringTag:
+ // Coerce regexes to strings and treat strings, primitives and objects,
+ // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
+ // for more details.
+ return object == (other + '');
+
+ case mapTag:
+ var convert = mapToArray;
+
+ case setTag:
+ var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+ convert || (convert = setToArray);
+
+ if (object.size != other.size && !isPartial) {
+ return false;
+ }
+ // Assume cyclic values are equal.
+ var stacked = stack.get(object);
+ if (stacked) {
+ return stacked == other;
+ }
+ bitmask |= COMPARE_UNORDERED_FLAG;
+
+ // Recursively compare objects (susceptible to call stack limits).
+ stack.set(object, other);
+ var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+ stack['delete'](object);
+ return result;
+
+ case symbolTag:
+ if (symbolValueOf) {
+ return symbolValueOf.call(object) == symbolValueOf.call(other);
+ }
+ }
+ return false;
+ }
+
+ /**
+ * A specialized version of `baseIsEqualDeep` for objects with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+ function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+ var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
+ objProps = getAllKeys(object),
+ objLength = objProps.length,
+ othProps = getAllKeys(other),
+ othLength = othProps.length;
+
+ if (objLength != othLength && !isPartial) {
+ return false;
+ }
+ var index = objLength;
+ while (index--) {
+ var key = objProps[index];
+ if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+ return false;
+ }
+ }
+ // Check that cyclic values are equal.
+ var objStacked = stack.get(object);
+ var othStacked = stack.get(other);
+ if (objStacked && othStacked) {
+ return objStacked == other && othStacked == object;
+ }
+ var result = true;
+ stack.set(object, other);
+ stack.set(other, object);
+
+ var skipCtor = isPartial;
+ while (++index < objLength) {
+ key = objProps[index];
+ var objValue = object[key],
+ othValue = other[key];
+
+ if (customizer) {
+ var compared = isPartial
+ ? customizer(othValue, objValue, key, other, object, stack)
+ : customizer(objValue, othValue, key, object, other, stack);
+ }
+ // Recursively compare objects (susceptible to call stack limits).
+ if (!(compared === undefined$1
+ ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
+ : compared
+ )) {
+ result = false;
+ break;
+ }
+ skipCtor || (skipCtor = key == 'constructor');
+ }
+ if (result && !skipCtor) {
+ var objCtor = object.constructor,
+ othCtor = other.constructor;
+
+ // Non `Object` object instances with different constructors are not equal.
+ if (objCtor != othCtor &&
+ ('constructor' in object && 'constructor' in other) &&
+ !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
+ typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+ result = false;
+ }
+ }
+ stack['delete'](object);
+ stack['delete'](other);
+ return result;
+ }
+
+ /**
+ * A specialized version of `baseRest` which flattens the rest array.
+ *
+ * @private
+ * @param {Function} func The function to apply a rest parameter to.
+ * @returns {Function} Returns the new function.
+ */
+ function flatRest(func) {
+ return setToString(overRest(func, undefined$1, flatten), func + '');
+ }
+
+ /**
+ * Creates an array of own enumerable property names and symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+ function getAllKeys(object) {
+ return baseGetAllKeys(object, keys, getSymbols);
+ }
+
+ /**
+ * Creates an array of own and inherited enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+ function getAllKeysIn(object) {
+ return baseGetAllKeys(object, keysIn, getSymbolsIn);
+ }
+
+ /**
+ * Gets metadata for `func`.
+ *
+ * @private
+ * @param {Function} func The function to query.
+ * @returns {*} Returns the metadata for `func`.
+ */
+ var getData = !metaMap ? noop : function(func) {
+ return metaMap.get(func);
+ };
+
+ /**
+ * Gets the name of `func`.
+ *
+ * @private
+ * @param {Function} func The function to query.
+ * @returns {string} Returns the function name.
+ */
+ function getFuncName(func) {
+ var result = (func.name + ''),
+ array = realNames[result],
+ length = hasOwnProperty.call(realNames, result) ? array.length : 0;
+
+ while (length--) {
+ var data = array[length],
+ otherFunc = data.func;
+ if (otherFunc == null || otherFunc == func) {
+ return data.name;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Gets the argument placeholder value for `func`.
+ *
+ * @private
+ * @param {Function} func The function to inspect.
+ * @returns {*} Returns the placeholder value.
+ */
+ function getHolder(func) {
+ var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;
+ return object.placeholder;
+ }
+
+ /**
+ * Gets the appropriate "iteratee" function. If `_.iteratee` is customized,
+ * this function returns the custom method, otherwise it returns `baseIteratee`.
+ * If arguments are provided, the chosen function is invoked with them and
+ * its result is returned.
+ *
+ * @private
+ * @param {*} [value] The value to convert to an iteratee.
+ * @param {number} [arity] The arity of the created iteratee.
+ * @returns {Function} Returns the chosen function or its result.
+ */
+ function getIteratee() {
+ var result = lodash.iteratee || iteratee;
+ result = result === iteratee ? baseIteratee : result;
+ return arguments.length ? result(arguments[0], arguments[1]) : result;
+ }
+
+ /**
+ * Gets the data for `map`.
+ *
+ * @private
+ * @param {Object} map The map to query.
+ * @param {string} key The reference key.
+ * @returns {*} Returns the map data.
+ */
+ function getMapData(map, key) {
+ var data = map.__data__;
+ return isKeyable(key)
+ ? data[typeof key == 'string' ? 'string' : 'hash']
+ : data.map;
+ }
+
+ /**
+ * Gets the property names, values, and compare flags of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the match data of `object`.
+ */
+ function getMatchData(object) {
+ var result = keys(object),
+ length = result.length;
+
+ while (length--) {
+ var key = result[length],
+ value = object[key];
+
+ result[length] = [key, value, isStrictComparable(value)];
+ }
+ return result;
+ }
+
+ /**
+ * Gets the native function at `key` of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the method to get.
+ * @returns {*} Returns the function if it's native, else `undefined`.
+ */
+ function getNative(object, key) {
+ var value = getValue(object, key);
+ return baseIsNative(value) ? value : undefined$1;
+ }
+
+ /**
+ * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the raw `toStringTag`.
+ */
+ function getRawTag(value) {
+ var isOwn = hasOwnProperty.call(value, symToStringTag),
+ tag = value[symToStringTag];
+
+ try {
+ value[symToStringTag] = undefined$1;
+ var unmasked = true;
+ } catch (e) {}
+
+ var result = nativeObjectToString.call(value);
+ if (unmasked) {
+ if (isOwn) {
+ value[symToStringTag] = tag;
+ } else {
+ delete value[symToStringTag];
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Creates an array of the own enumerable symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of symbols.
+ */
+ var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+ if (object == null) {
+ return [];
+ }
+ object = Object(object);
+ return arrayFilter(nativeGetSymbols(object), function(symbol) {
+ return propertyIsEnumerable.call(object, symbol);
+ });
+ };
+
+ /**
+ * Creates an array of the own and inherited enumerable symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of symbols.
+ */
+ var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
+ var result = [];
+ while (object) {
+ arrayPush(result, getSymbols(object));
+ object = getPrototype(object);
+ }
+ return result;
+ };
+
+ /**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+ var getTag = baseGetTag;
+
+ // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
+ if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
+ (Map && getTag(new Map) != mapTag) ||
+ (Promise && getTag(Promise.resolve()) != promiseTag) ||
+ (Set && getTag(new Set) != setTag) ||
+ (WeakMap && getTag(new WeakMap) != weakMapTag)) {
+ getTag = function(value) {
+ var result = baseGetTag(value),
+ Ctor = result == objectTag ? value.constructor : undefined$1,
+ ctorString = Ctor ? toSource(Ctor) : '';
+
+ if (ctorString) {
+ switch (ctorString) {
+ case dataViewCtorString: return dataViewTag;
+ case mapCtorString: return mapTag;
+ case promiseCtorString: return promiseTag;
+ case setCtorString: return setTag;
+ case weakMapCtorString: return weakMapTag;
+ }
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Gets the view, applying any `transforms` to the `start` and `end` positions.
+ *
+ * @private
+ * @param {number} start The start of the view.
+ * @param {number} end The end of the view.
+ * @param {Array} transforms The transformations to apply to the view.
+ * @returns {Object} Returns an object containing the `start` and `end`
+ * positions of the view.
+ */
+ function getView(start, end, transforms) {
+ var index = -1,
+ length = transforms.length;
+
+ while (++index < length) {
+ var data = transforms[index],
+ size = data.size;
+
+ switch (data.type) {
+ case 'drop': start += size; break;
+ case 'dropRight': end -= size; break;
+ case 'take': end = nativeMin(end, start + size); break;
+ case 'takeRight': start = nativeMax(start, end - size); break;
+ }
+ }
+ return { 'start': start, 'end': end };
+ }
+
+ /**
+ * Extracts wrapper details from the `source` body comment.
+ *
+ * @private
+ * @param {string} source The source to inspect.
+ * @returns {Array} Returns the wrapper details.
+ */
+ function getWrapDetails(source) {
+ var match = source.match(reWrapDetails);
+ return match ? match[1].split(reSplitDetails) : [];
+ }
+
+ /**
+ * Checks if `path` exists on `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @param {Function} hasFunc The function to check properties.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ */
+ function hasPath(object, path, hasFunc) {
+ path = castPath(path, object);
+
+ var index = -1,
+ length = path.length,
+ result = false;
+
+ while (++index < length) {
+ var key = toKey(path[index]);
+ if (!(result = object != null && hasFunc(object, key))) {
+ break;
+ }
+ object = object[key];
+ }
+ if (result || ++index != length) {
+ return result;
+ }
+ length = object == null ? 0 : object.length;
+ return !!length && isLength(length) && isIndex(key, length) &&
+ (isArray(object) || isArguments(object));
+ }
+
+ /**
+ * Initializes an array clone.
+ *
+ * @private
+ * @param {Array} array The array to clone.
+ * @returns {Array} Returns the initialized clone.
+ */
+ function initCloneArray(array) {
+ var length = array.length,
+ result = new array.constructor(length);
+
+ // Add properties assigned by `RegExp#exec`.
+ if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
+ result.index = array.index;
+ result.input = array.input;
+ }
+ return result;
+ }
+
+ /**
+ * Initializes an object clone.
+ *
+ * @private
+ * @param {Object} object The object to clone.
+ * @returns {Object} Returns the initialized clone.
+ */
+ function initCloneObject(object) {
+ return (typeof object.constructor == 'function' && !isPrototype(object))
+ ? baseCreate(getPrototype(object))
+ : {};
+ }
+
+ /**
+ * Initializes an object clone based on its `toStringTag`.
+ *
+ * **Note:** This function only supports cloning values with tags of
+ * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to clone.
+ * @param {string} tag The `toStringTag` of the object to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the initialized clone.
+ */
+ function initCloneByTag(object, tag, isDeep) {
+ var Ctor = object.constructor;
+ switch (tag) {
+ case arrayBufferTag:
+ return cloneArrayBuffer(object);
+
+ case boolTag:
+ case dateTag:
+ return new Ctor(+object);
+
+ case dataViewTag:
+ return cloneDataView(object, isDeep);
+
+ case float32Tag: case float64Tag:
+ case int8Tag: case int16Tag: case int32Tag:
+ case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
+ return cloneTypedArray(object, isDeep);
+
+ case mapTag:
+ return new Ctor;
+
+ case numberTag:
+ case stringTag:
+ return new Ctor(object);
+
+ case regexpTag:
+ return cloneRegExp(object);
+
+ case setTag:
+ return new Ctor;
+
+ case symbolTag:
+ return cloneSymbol(object);
+ }
+ }
+
+ /**
+ * Inserts wrapper `details` in a comment at the top of the `source` body.
+ *
+ * @private
+ * @param {string} source The source to modify.
+ * @returns {Array} details The details to insert.
+ * @returns {string} Returns the modified source.
+ */
+ function insertWrapDetails(source, details) {
+ var length = details.length;
+ if (!length) {
+ return source;
+ }
+ var lastIndex = length - 1;
+ details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];
+ details = details.join(length > 2 ? ', ' : ' ');
+ return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n');
+ }
+
+ /**
+ * Checks if `value` is a flattenable `arguments` object or array.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
+ */
+ function isFlattenable(value) {
+ return isArray(value) || isArguments(value) ||
+ !!(spreadableSymbol && value && value[spreadableSymbol]);
+ }
+
+ /**
+ * Checks if `value` is a valid array-like index.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+ */
+ function isIndex(value, length) {
+ var type = typeof value;
+ length = length == null ? MAX_SAFE_INTEGER : length;
+
+ return !!length &&
+ (type == 'number' ||
+ (type != 'symbol' && reIsUint.test(value))) &&
+ (value > -1 && value % 1 == 0 && value < length);
+ }
+
+ /**
+ * Checks if the given arguments are from an iteratee call.
+ *
+ * @private
+ * @param {*} value The potential iteratee value argument.
+ * @param {*} index The potential iteratee index or key argument.
+ * @param {*} object The potential iteratee object argument.
+ * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
+ * else `false`.
+ */
+ function isIterateeCall(value, index, object) {
+ if (!isObject(object)) {
+ return false;
+ }
+ var type = typeof index;
+ if (type == 'number'
+ ? (isArrayLike(object) && isIndex(index, object.length))
+ : (type == 'string' && index in object)
+ ) {
+ return eq(object[index], value);
+ }
+ return false;
+ }
+
+ /**
+ * Checks if `value` is a property name and not a property path.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ */
+ function isKey(value, object) {
+ if (isArray(value)) {
+ return false;
+ }
+ var type = typeof value;
+ if (type == 'number' || type == 'symbol' || type == 'boolean' ||
+ value == null || isSymbol(value)) {
+ return true;
+ }
+ return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
+ (object != null && value in Object(object));
+ }
+
+ /**
+ * Checks if `value` is suitable for use as unique object key.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+ */
+ function isKeyable(value) {
+ var type = typeof value;
+ return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+ ? (value !== '__proto__')
+ : (value === null);
+ }
+
+ /**
+ * Checks if `func` has a lazy counterpart.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` has a lazy counterpart,
+ * else `false`.
+ */
+ function isLaziable(func) {
+ var funcName = getFuncName(func),
+ other = lodash[funcName];
+
+ if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {
+ return false;
+ }
+ if (func === other) {
+ return true;
+ }
+ var data = getData(other);
+ return !!data && func === data[0];
+ }
+
+ /**
+ * Checks if `func` has its source masked.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+ */
+ function isMasked(func) {
+ return !!maskSrcKey && (maskSrcKey in func);
+ }
+
+ /**
+ * Checks if `func` is capable of being masked.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `func` is maskable, else `false`.
+ */
+ var isMaskable = coreJsData ? isFunction : stubFalse;
+
+ /**
+ * Checks if `value` is likely a prototype object.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+ */
+ function isPrototype(value) {
+ var Ctor = value && value.constructor,
+ proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+
+ return value === proto;
+ }
+
+ /**
+ * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` if suitable for strict
+ * equality comparisons, else `false`.
+ */
+ function isStrictComparable(value) {
+ return value === value && !isObject(value);
+ }
+
+ /**
+ * A specialized version of `matchesProperty` for source values suitable
+ * for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+ function matchesStrictComparable(key, srcValue) {
+ return function(object) {
+ if (object == null) {
+ return false;
+ }
+ return object[key] === srcValue &&
+ (srcValue !== undefined$1 || (key in Object(object)));
+ };
+ }
+
+ /**
+ * A specialized version of `_.memoize` which clears the memoized function's
+ * cache when it exceeds `MAX_MEMOIZE_SIZE`.
+ *
+ * @private
+ * @param {Function} func The function to have its output memoized.
+ * @returns {Function} Returns the new memoized function.
+ */
+ function memoizeCapped(func) {
+ var result = memoize(func, function(key) {
+ if (cache.size === MAX_MEMOIZE_SIZE) {
+ cache.clear();
+ }
+ return key;
+ });
+
+ var cache = result.cache;
+ return result;
+ }
+
+ /**
+ * Merges the function metadata of `source` into `data`.
+ *
+ * Merging metadata reduces the number of wrappers used to invoke a function.
+ * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`
+ * may be applied regardless of execution order. Methods like `_.ary` and
+ * `_.rearg` modify function arguments, making the order in which they are
+ * executed important, preventing the merging of metadata. However, we make
+ * an exception for a safe combined case where curried functions have `_.ary`
+ * and or `_.rearg` applied.
+ *
+ * @private
+ * @param {Array} data The destination metadata.
+ * @param {Array} source The source metadata.
+ * @returns {Array} Returns `data`.
+ */
+ function mergeData(data, source) {
+ var bitmask = data[1],
+ srcBitmask = source[1],
+ newBitmask = bitmask | srcBitmask,
+ isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);
+
+ var isCombo =
+ ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||
+ ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||
+ ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));
+
+ // Exit early if metadata can't be merged.
+ if (!(isCommon || isCombo)) {
+ return data;
+ }
+ // Use source `thisArg` if available.
+ if (srcBitmask & WRAP_BIND_FLAG) {
+ data[2] = source[2];
+ // Set when currying a bound function.
+ newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
+ }
+ // Compose partial arguments.
+ var value = source[3];
+ if (value) {
+ var partials = data[3];
+ data[3] = partials ? composeArgs(partials, value, source[4]) : value;
+ data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
+ }
+ // Compose partial right arguments.
+ value = source[5];
+ if (value) {
+ partials = data[5];
+ data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
+ data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
+ }
+ // Use source `argPos` if available.
+ value = source[7];
+ if (value) {
+ data[7] = value;
+ }
+ // Use source `ary` if it's smaller.
+ if (srcBitmask & WRAP_ARY_FLAG) {
+ data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
+ }
+ // Use source `arity` if one is not provided.
+ if (data[9] == null) {
+ data[9] = source[9];
+ }
+ // Use source `func` and merge bitmasks.
+ data[0] = source[0];
+ data[1] = newBitmask;
+
+ return data;
+ }
+
+ /**
+ * This function is like
+ * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * except that it includes inherited enumerable properties.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+ function nativeKeysIn(object) {
+ var result = [];
+ if (object != null) {
+ for (var key in Object(object)) {
+ result.push(key);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Converts `value` to a string using `Object.prototype.toString`.
+ *
+ * @private
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ */
+ function objectToString(value) {
+ return nativeObjectToString.call(value);
+ }
+
+ /**
+ * A specialized version of `baseRest` which transforms the rest array.
+ *
+ * @private
+ * @param {Function} func The function to apply a rest parameter to.
+ * @param {number} [start=func.length-1] The start position of the rest parameter.
+ * @param {Function} transform The rest array transform.
+ * @returns {Function} Returns the new function.
+ */
+ function overRest(func, start, transform) {
+ start = nativeMax(start === undefined$1 ? (func.length - 1) : start, 0);
+ return function() {
+ var args = arguments,
+ index = -1,
+ length = nativeMax(args.length - start, 0),
+ array = Array(length);
+
+ while (++index < length) {
+ array[index] = args[start + index];
+ }
+ index = -1;
+ var otherArgs = Array(start + 1);
+ while (++index < start) {
+ otherArgs[index] = args[index];
+ }
+ otherArgs[start] = transform(array);
+ return apply(func, this, otherArgs);
+ };
+ }
+
+ /**
+ * Gets the parent value at `path` of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array} path The path to get the parent value of.
+ * @returns {*} Returns the parent value.
+ */
+ function parent(object, path) {
+ return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
+ }
+
+ /**
+ * Reorder `array` according to the specified indexes where the element at
+ * the first index is assigned as the first element, the element at
+ * the second index is assigned as the second element, and so on.
+ *
+ * @private
+ * @param {Array} array The array to reorder.
+ * @param {Array} indexes The arranged array indexes.
+ * @returns {Array} Returns `array`.
+ */
+ function reorder(array, indexes) {
+ var arrLength = array.length,
+ length = nativeMin(indexes.length, arrLength),
+ oldArray = copyArray(array);
+
+ while (length--) {
+ var index = indexes[length];
+ array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined$1;
+ }
+ return array;
+ }
+
+ /**
+ * Gets the value at `key`, unless `key` is "__proto__" or "constructor".
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+ function safeGet(object, key) {
+ if (key === 'constructor' && typeof object[key] === 'function') {
+ return;
+ }
+
+ if (key == '__proto__') {
+ return;
+ }
+
+ return object[key];
+ }
+
+ /**
+ * Sets metadata for `func`.
+ *
+ * **Note:** If this function becomes hot, i.e. is invoked a lot in a short
+ * period of time, it will trip its breaker and transition to an identity
+ * function to avoid garbage collection pauses in V8. See
+ * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)
+ * for more details.
+ *
+ * @private
+ * @param {Function} func The function to associate metadata with.
+ * @param {*} data The metadata.
+ * @returns {Function} Returns `func`.
+ */
+ var setData = shortOut(baseSetData);
+
+ /**
+ * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).
+ *
+ * @private
+ * @param {Function} func The function to delay.
+ * @param {number} wait The number of milliseconds to delay invocation.
+ * @returns {number|Object} Returns the timer id or timeout object.
+ */
+ var setTimeout = ctxSetTimeout || function(func, wait) {
+ return root.setTimeout(func, wait);
+ };
+
+ /**
+ * Sets the `toString` method of `func` to return `string`.
+ *
+ * @private
+ * @param {Function} func The function to modify.
+ * @param {Function} string The `toString` result.
+ * @returns {Function} Returns `func`.
+ */
+ var setToString = shortOut(baseSetToString);
+
+ /**
+ * Sets the `toString` method of `wrapper` to mimic the source of `reference`
+ * with wrapper details in a comment at the top of the source body.
+ *
+ * @private
+ * @param {Function} wrapper The function to modify.
+ * @param {Function} reference The reference function.
+ * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
+ * @returns {Function} Returns `wrapper`.
+ */
+ function setWrapToString(wrapper, reference, bitmask) {
+ var source = (reference + '');
+ return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
+ }
+
+ /**
+ * Creates a function that'll short out and invoke `identity` instead
+ * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
+ * milliseconds.
+ *
+ * @private
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new shortable function.
+ */
+ function shortOut(func) {
+ var count = 0,
+ lastCalled = 0;
+
+ return function() {
+ var stamp = nativeNow(),
+ remaining = HOT_SPAN - (stamp - lastCalled);
+
+ lastCalled = stamp;
+ if (remaining > 0) {
+ if (++count >= HOT_COUNT) {
+ return arguments[0];
+ }
+ } else {
+ count = 0;
+ }
+ return func.apply(undefined$1, arguments);
+ };
+ }
+
+ /**
+ * A specialized version of `_.shuffle` which mutates and sets the size of `array`.
+ *
+ * @private
+ * @param {Array} array The array to shuffle.
+ * @param {number} [size=array.length] The size of `array`.
+ * @returns {Array} Returns `array`.
+ */
+ function shuffleSelf(array, size) {
+ var index = -1,
+ length = array.length,
+ lastIndex = length - 1;
+
+ size = size === undefined$1 ? length : size;
+ while (++index < size) {
+ var rand = baseRandom(index, lastIndex),
+ value = array[rand];
+
+ array[rand] = array[index];
+ array[index] = value;
+ }
+ array.length = size;
+ return array;
+ }
+
+ /**
+ * Converts `string` to a property path array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the property path array.
+ */
+ var stringToPath = memoizeCapped(function(string) {
+ var result = [];
+ if (string.charCodeAt(0) === 46 /* . */) {
+ result.push('');
+ }
+ string.replace(rePropName, function(match, number, quote, subString) {
+ result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
+ });
+ return result;
+ });
+
+ /**
+ * Converts `value` to a string key if it's not a string or symbol.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {string|symbol} Returns the key.
+ */
+ function toKey(value) {
+ if (typeof value == 'string' || isSymbol(value)) {
+ return value;
+ }
+ var result = (value + '');
+ return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+ }
+
+ /**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to convert.
+ * @returns {string} Returns the source code.
+ */
+ function toSource(func) {
+ if (func != null) {
+ try {
+ return funcToString.call(func);
+ } catch (e) {}
+ try {
+ return (func + '');
+ } catch (e) {}
+ }
+ return '';
+ }
+
+ /**
+ * Updates wrapper `details` based on `bitmask` flags.
+ *
+ * @private
+ * @returns {Array} details The details to modify.
+ * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
+ * @returns {Array} Returns `details`.
+ */
+ function updateWrapDetails(details, bitmask) {
+ arrayEach(wrapFlags, function(pair) {
+ var value = '_.' + pair[0];
+ if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {
+ details.push(value);
+ }
+ });
+ return details.sort();
+ }
+
+ /**
+ * Creates a clone of `wrapper`.
+ *
+ * @private
+ * @param {Object} wrapper The wrapper to clone.
+ * @returns {Object} Returns the cloned wrapper.
+ */
+ function wrapperClone(wrapper) {
+ if (wrapper instanceof LazyWrapper) {
+ return wrapper.clone();
+ }
+ var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
+ result.__actions__ = copyArray(wrapper.__actions__);
+ result.__index__ = wrapper.__index__;
+ result.__values__ = wrapper.__values__;
+ return result;
+ }
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Creates an array of elements split into groups the length of `size`.
+ * If `array` can't be split evenly, the final chunk will be the remaining
+ * elements.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The array to process.
+ * @param {number} [size=1] The length of each chunk
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {Array} Returns the new array of chunks.
+ * @example
+ *
+ * _.chunk(['a', 'b', 'c', 'd'], 2);
+ * // => [['a', 'b'], ['c', 'd']]
+ *
+ * _.chunk(['a', 'b', 'c', 'd'], 3);
+ * // => [['a', 'b', 'c'], ['d']]
+ */
+ function chunk(array, size, guard) {
+ if ((guard ? isIterateeCall(array, size, guard) : size === undefined$1)) {
+ size = 1;
+ } else {
+ size = nativeMax(toInteger(size), 0);
+ }
+ var length = array == null ? 0 : array.length;
+ if (!length || size < 1) {
+ return [];
+ }
+ var index = 0,
+ resIndex = 0,
+ result = Array(nativeCeil(length / size));
+
+ while (index < length) {
+ result[resIndex++] = baseSlice(array, index, (index += size));
+ }
+ return result;
+ }
+
+ /**
+ * Creates an array with all falsey values removed. The values `false`, `null`,
+ * `0`, `""`, `undefined`, and `NaN` are falsey.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to compact.
+ * @returns {Array} Returns the new array of filtered values.
+ * @example
+ *
+ * _.compact([0, 1, false, 2, '', 3]);
+ * // => [1, 2, 3]
+ */
+ function compact(array) {
+ var index = -1,
+ length = array == null ? 0 : array.length,
+ resIndex = 0,
+ result = [];
+
+ while (++index < length) {
+ var value = array[index];
+ if (value) {
+ result[resIndex++] = value;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Creates a new array concatenating `array` with any additional arrays
+ * and/or values.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to concatenate.
+ * @param {...*} [values] The values to concatenate.
+ * @returns {Array} Returns the new concatenated array.
+ * @example
+ *
+ * var array = [1];
+ * var other = _.concat(array, 2, [3], [[4]]);
+ *
+ * console.log(other);
+ * // => [1, 2, 3, [4]]
+ *
+ * console.log(array);
+ * // => [1]
+ */
+ function concat() {
+ var length = arguments.length;
+ if (!length) {
+ return [];
+ }
+ var args = Array(length - 1),
+ array = arguments[0],
+ index = length;
+
+ while (index--) {
+ args[index - 1] = arguments[index];
+ }
+ return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));
+ }
+
+ /**
+ * Creates an array of `array` values not included in the other given arrays
+ * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons. The order and references of result values are
+ * determined by the first array.
+ *
+ * **Note:** Unlike `_.pullAll`, this method returns a new array.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {...Array} [values] The values to exclude.
+ * @returns {Array} Returns the new array of filtered values.
+ * @see _.without, _.xor
+ * @example
+ *
+ * _.difference([2, 1], [2, 3]);
+ * // => [1]
+ */
+ var difference = baseRest(function(array, values) {
+ return isArrayLikeObject(array)
+ ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))
+ : [];
+ });
+
+ /**
+ * This method is like `_.difference` except that it accepts `iteratee` which
+ * is invoked for each element of `array` and `values` to generate the criterion
+ * by which they're compared. The order and references of result values are
+ * determined by the first array. The iteratee is invoked with one argument:
+ * (value).
+ *
+ * **Note:** Unlike `_.pullAllBy`, this method returns a new array.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {...Array} [values] The values to exclude.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {Array} Returns the new array of filtered values.
+ * @example
+ *
+ * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
+ * // => [1.2]
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
+ * // => [{ 'x': 2 }]
+ */
+ var differenceBy = baseRest(function(array, values) {
+ var iteratee = last(values);
+ if (isArrayLikeObject(iteratee)) {
+ iteratee = undefined$1;
+ }
+ return isArrayLikeObject(array)
+ ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))
+ : [];
+ });
+
+ /**
+ * This method is like `_.difference` except that it accepts `comparator`
+ * which is invoked to compare elements of `array` to `values`. The order and
+ * references of result values are determined by the first array. The comparator
+ * is invoked with two arguments: (arrVal, othVal).
+ *
+ * **Note:** Unlike `_.pullAllWith`, this method returns a new array.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {...Array} [values] The values to exclude.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of filtered values.
+ * @example
+ *
+ * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
+ *
+ * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);
+ * // => [{ 'x': 2, 'y': 1 }]
+ */
+ var differenceWith = baseRest(function(array, values) {
+ var comparator = last(values);
+ if (isArrayLikeObject(comparator)) {
+ comparator = undefined$1;
+ }
+ return isArrayLikeObject(array)
+ ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined$1, comparator)
+ : [];
+ });
+
+ /**
+ * Creates a slice of `array` with `n` elements dropped from the beginning.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.5.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {number} [n=1] The number of elements to drop.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.drop([1, 2, 3]);
+ * // => [2, 3]
+ *
+ * _.drop([1, 2, 3], 2);
+ * // => [3]
+ *
+ * _.drop([1, 2, 3], 5);
+ * // => []
+ *
+ * _.drop([1, 2, 3], 0);
+ * // => [1, 2, 3]
+ */
+ function drop(array, n, guard) {
+ var length = array == null ? 0 : array.length;
+ if (!length) {
+ return [];
+ }
+ n = (guard || n === undefined$1) ? 1 : toInteger(n);
+ return baseSlice(array, n < 0 ? 0 : n, length);
+ }
+
+ /**
+ * Creates a slice of `array` with `n` elements dropped from the end.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {number} [n=1] The number of elements to drop.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.dropRight([1, 2, 3]);
+ * // => [1, 2]
+ *
+ * _.dropRight([1, 2, 3], 2);
+ * // => [1]
+ *
+ * _.dropRight([1, 2, 3], 5);
+ * // => []
+ *
+ * _.dropRight([1, 2, 3], 0);
+ * // => [1, 2, 3]
+ */
+ function dropRight(array, n, guard) {
+ var length = array == null ? 0 : array.length;
+ if (!length) {
+ return [];
+ }
+ n = (guard || n === undefined$1) ? 1 : toInteger(n);
+ n = length - n;
+ return baseSlice(array, 0, n < 0 ? 0 : n);
+ }
+
+ /**
+ * Creates a slice of `array` excluding elements dropped from the end.
+ * Elements are dropped until `predicate` returns falsey. The predicate is
+ * invoked with three arguments: (value, index, array).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'active': true },
+ * { 'user': 'fred', 'active': false },
+ * { 'user': 'pebbles', 'active': false }
+ * ];
+ *
+ * _.dropRightWhile(users, function(o) { return !o.active; });
+ * // => objects for ['barney']
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
+ * // => objects for ['barney', 'fred']
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.dropRightWhile(users, ['active', false]);
+ * // => objects for ['barney']
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.dropRightWhile(users, 'active');
+ * // => objects for ['barney', 'fred', 'pebbles']
+ */
+ function dropRightWhile(array, predicate) {
+ return (array && array.length)
+ ? baseWhile(array, getIteratee(predicate, 3), true, true)
+ : [];
+ }
+
+ /**
+ * Creates a slice of `array` excluding elements dropped from the beginning.
+ * Elements are dropped until `predicate` returns falsey. The predicate is
+ * invoked with three arguments: (value, index, array).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'active': false },
+ * { 'user': 'fred', 'active': false },
+ * { 'user': 'pebbles', 'active': true }
+ * ];
+ *
+ * _.dropWhile(users, function(o) { return !o.active; });
+ * // => objects for ['pebbles']
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.dropWhile(users, { 'user': 'barney', 'active': false });
+ * // => objects for ['fred', 'pebbles']
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.dropWhile(users, ['active', false]);
+ * // => objects for ['pebbles']
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.dropWhile(users, 'active');
+ * // => objects for ['barney', 'fred', 'pebbles']
+ */
+ function dropWhile(array, predicate) {
+ return (array && array.length)
+ ? baseWhile(array, getIteratee(predicate, 3), true)
+ : [];
+ }
+
+ /**
+ * Fills elements of `array` with `value` from `start` up to, but not
+ * including, `end`.
+ *
+ * **Note:** This method mutates `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.2.0
+ * @category Array
+ * @param {Array} array The array to fill.
+ * @param {*} value The value to fill `array` with.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [1, 2, 3];
+ *
+ * _.fill(array, 'a');
+ * console.log(array);
+ * // => ['a', 'a', 'a']
+ *
+ * _.fill(Array(3), 2);
+ * // => [2, 2, 2]
+ *
+ * _.fill([4, 6, 8, 10], '*', 1, 3);
+ * // => [4, '*', '*', 10]
+ */
+ function fill(array, value, start, end) {
+ var length = array == null ? 0 : array.length;
+ if (!length) {
+ return [];
+ }
+ if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {
+ start = 0;
+ end = length;
+ }
+ return baseFill(array, value, start, end);
+ }
+
+ /**
+ * This method is like `_.find` except that it returns the index of the first
+ * element `predicate` returns truthy for instead of the element itself.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'active': false },
+ * { 'user': 'fred', 'active': false },
+ * { 'user': 'pebbles', 'active': true }
+ * ];
+ *
+ * _.findIndex(users, function(o) { return o.user == 'barney'; });
+ * // => 0
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.findIndex(users, { 'user': 'fred', 'active': false });
+ * // => 1
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.findIndex(users, ['active', false]);
+ * // => 0
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.findIndex(users, 'active');
+ * // => 2
+ */
+ function findIndex(array, predicate, fromIndex) {
+ var length = array == null ? 0 : array.length;
+ if (!length) {
+ return -1;
+ }
+ var index = fromIndex == null ? 0 : toInteger(fromIndex);
+ if (index < 0) {
+ index = nativeMax(length + index, 0);
+ }
+ return baseFindIndex(array, getIteratee(predicate, 3), index);
+ }
+
+ /**
+ * This method is like `_.findIndex` except that it iterates over elements
+ * of `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @param {number} [fromIndex=array.length-1] The index to search from.
+ * @returns {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'active': true },
+ * { 'user': 'fred', 'active': false },
+ * { 'user': 'pebbles', 'active': false }
+ * ];
+ *
+ * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
+ * // => 2
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.findLastIndex(users, { 'user': 'barney', 'active': true });
+ * // => 0
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.findLastIndex(users, ['active', false]);
+ * // => 2
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.findLastIndex(users, 'active');
+ * // => 0
+ */
+ function findLastIndex(array, predicate, fromIndex) {
+ var length = array == null ? 0 : array.length;
+ if (!length) {
+ return -1;
+ }
+ var index = length - 1;
+ if (fromIndex !== undefined$1) {
+ index = toInteger(fromIndex);
+ index = fromIndex < 0
+ ? nativeMax(length + index, 0)
+ : nativeMin(index, length - 1);
+ }
+ return baseFindIndex(array, getIteratee(predicate, 3), index, true);
+ }
+
+ /**
+ * Flattens `array` a single level deep.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to flatten.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * _.flatten([1, [2, [3, [4]], 5]]);
+ * // => [1, 2, [3, [4]], 5]
+ */
+ function flatten(array) {
+ var length = array == null ? 0 : array.length;
+ return length ? baseFlatten(array, 1) : [];
+ }
+
+ /**
+ * Recursively flattens `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The array to flatten.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * _.flattenDeep([1, [2, [3, [4]], 5]]);
+ * // => [1, 2, 3, 4, 5]
+ */
+ function flattenDeep(array) {
+ var length = array == null ? 0 : array.length;
+ return length ? baseFlatten(array, INFINITY) : [];
+ }
+
+ /**
+ * Recursively flatten `array` up to `depth` times.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.4.0
+ * @category Array
+ * @param {Array} array The array to flatten.
+ * @param {number} [depth=1] The maximum recursion depth.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * var array = [1, [2, [3, [4]], 5]];
+ *
+ * _.flattenDepth(array, 1);
+ * // => [1, 2, [3, [4]], 5]
+ *
+ * _.flattenDepth(array, 2);
+ * // => [1, 2, 3, [4], 5]
+ */
+ function flattenDepth(array, depth) {
+ var length = array == null ? 0 : array.length;
+ if (!length) {
+ return [];
+ }
+ depth = depth === undefined$1 ? 1 : toInteger(depth);
+ return baseFlatten(array, depth);
+ }
+
+ /**
+ * The inverse of `_.toPairs`; this method returns an object composed
+ * from key-value `pairs`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} pairs The key-value pairs.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * _.fromPairs([['a', 1], ['b', 2]]);
+ * // => { 'a': 1, 'b': 2 }
+ */
+ function fromPairs(pairs) {
+ var index = -1,
+ length = pairs == null ? 0 : pairs.length,
+ result = {};
+
+ while (++index < length) {
+ var pair = pairs[index];
+ result[pair[0]] = pair[1];
+ }
+ return result;
+ }
+
+ /**
+ * Gets the first element of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @alias first
+ * @category Array
+ * @param {Array} array The array to query.
+ * @returns {*} Returns the first element of `array`.
+ * @example
+ *
+ * _.head([1, 2, 3]);
+ * // => 1
+ *
+ * _.head([]);
+ * // => undefined
+ */
+ function head(array) {
+ return (array && array.length) ? array[0] : undefined$1;
+ }
+
+ /**
+ * Gets the index at which the first occurrence of `value` is found in `array`
+ * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons. If `fromIndex` is negative, it's used as the
+ * offset from the end of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ * @example
+ *
+ * _.indexOf([1, 2, 1, 2], 2);
+ * // => 1
+ *
+ * // Search from the `fromIndex`.
+ * _.indexOf([1, 2, 1, 2], 2, 2);
+ * // => 3
+ */
+ function indexOf(array, value, fromIndex) {
+ var length = array == null ? 0 : array.length;
+ if (!length) {
+ return -1;
+ }
+ var index = fromIndex == null ? 0 : toInteger(fromIndex);
+ if (index < 0) {
+ index = nativeMax(length + index, 0);
+ }
+ return baseIndexOf(array, value, index);
+ }
+
+ /**
+ * Gets all but the last element of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.initial([1, 2, 3]);
+ * // => [1, 2]
+ */
+ function initial(array) {
+ var length = array == null ? 0 : array.length;
+ return length ? baseSlice(array, 0, -1) : [];
+ }
+
+ /**
+ * Creates an array of unique values that are included in all given arrays
+ * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons. The order and references of result values are
+ * determined by the first array.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @returns {Array} Returns the new array of intersecting values.
+ * @example
+ *
+ * _.intersection([2, 1], [2, 3]);
+ * // => [2]
+ */
+ var intersection = baseRest(function(arrays) {
+ var mapped = arrayMap(arrays, castArrayLikeObject);
+ return (mapped.length && mapped[0] === arrays[0])
+ ? baseIntersection(mapped)
+ : [];
+ });
+
+ /**
+ * This method is like `_.intersection` except that it accepts `iteratee`
+ * which is invoked for each element of each `arrays` to generate the criterion
+ * by which they're compared. The order and references of result values are
+ * determined by the first array. The iteratee is invoked with one argument:
+ * (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {Array} Returns the new array of intersecting values.
+ * @example
+ *
+ * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
+ * // => [2.1]
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
+ * // => [{ 'x': 1 }]
+ */
+ var intersectionBy = baseRest(function(arrays) {
+ var iteratee = last(arrays),
+ mapped = arrayMap(arrays, castArrayLikeObject);
+
+ if (iteratee === last(mapped)) {
+ iteratee = undefined$1;
+ } else {
+ mapped.pop();
+ }
+ return (mapped.length && mapped[0] === arrays[0])
+ ? baseIntersection(mapped, getIteratee(iteratee, 2))
+ : [];
+ });
+
+ /**
+ * This method is like `_.intersection` except that it accepts `comparator`
+ * which is invoked to compare elements of `arrays`. The order and references
+ * of result values are determined by the first array. The comparator is
+ * invoked with two arguments: (arrVal, othVal).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of intersecting values.
+ * @example
+ *
+ * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
+ * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
+ *
+ * _.intersectionWith(objects, others, _.isEqual);
+ * // => [{ 'x': 1, 'y': 2 }]
+ */
+ var intersectionWith = baseRest(function(arrays) {
+ var comparator = last(arrays),
+ mapped = arrayMap(arrays, castArrayLikeObject);
+
+ comparator = typeof comparator == 'function' ? comparator : undefined$1;
+ if (comparator) {
+ mapped.pop();
+ }
+ return (mapped.length && mapped[0] === arrays[0])
+ ? baseIntersection(mapped, undefined$1, comparator)
+ : [];
+ });
+
+ /**
+ * Converts all elements in `array` into a string separated by `separator`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to convert.
+ * @param {string} [separator=','] The element separator.
+ * @returns {string} Returns the joined string.
+ * @example
+ *
+ * _.join(['a', 'b', 'c'], '~');
+ * // => 'a~b~c'
+ */
+ function join(array, separator) {
+ return array == null ? '' : nativeJoin.call(array, separator);
+ }
+
+ /**
+ * Gets the last element of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @returns {*} Returns the last element of `array`.
+ * @example
+ *
+ * _.last([1, 2, 3]);
+ * // => 3
+ */
+ function last(array) {
+ var length = array == null ? 0 : array.length;
+ return length ? array[length - 1] : undefined$1;
+ }
+
+ /**
+ * This method is like `_.indexOf` except that it iterates over elements of
+ * `array` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} [fromIndex=array.length-1] The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ * @example
+ *
+ * _.lastIndexOf([1, 2, 1, 2], 2);
+ * // => 3
+ *
+ * // Search from the `fromIndex`.
+ * _.lastIndexOf([1, 2, 1, 2], 2, 2);
+ * // => 1
+ */
+ function lastIndexOf(array, value, fromIndex) {
+ var length = array == null ? 0 : array.length;
+ if (!length) {
+ return -1;
+ }
+ var index = length;
+ if (fromIndex !== undefined$1) {
+ index = toInteger(fromIndex);
+ index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
+ }
+ return value === value
+ ? strictLastIndexOf(array, value, index)
+ : baseFindIndex(array, baseIsNaN, index, true);
+ }
+
+ /**
+ * Gets the element at index `n` of `array`. If `n` is negative, the nth
+ * element from the end is returned.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.11.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {number} [n=0] The index of the element to return.
+ * @returns {*} Returns the nth element of `array`.
+ * @example
+ *
+ * var array = ['a', 'b', 'c', 'd'];
+ *
+ * _.nth(array, 1);
+ * // => 'b'
+ *
+ * _.nth(array, -2);
+ * // => 'c';
+ */
+ function nth(array, n) {
+ return (array && array.length) ? baseNth(array, toInteger(n)) : undefined$1;
+ }
+
+ /**
+ * Removes all given values from `array` using
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`
+ * to remove elements from an array by predicate.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.0.0
+ * @category Array
+ * @param {Array} array The array to modify.
+ * @param {...*} [values] The values to remove.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
+ *
+ * _.pull(array, 'a', 'c');
+ * console.log(array);
+ * // => ['b', 'b']
+ */
+ var pull = baseRest(pullAll);
+
+ /**
+ * This method is like `_.pull` except that it accepts an array of values to remove.
+ *
+ * **Note:** Unlike `_.difference`, this method mutates `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to remove.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
+ *
+ * _.pullAll(array, ['a', 'c']);
+ * console.log(array);
+ * // => ['b', 'b']
+ */
+ function pullAll(array, values) {
+ return (array && array.length && values && values.length)
+ ? basePullAll(array, values)
+ : array;
+ }
+
+ /**
+ * This method is like `_.pullAll` except that it accepts `iteratee` which is
+ * invoked for each element of `array` and `values` to generate the criterion
+ * by which they're compared. The iteratee is invoked with one argument: (value).
+ *
+ * **Note:** Unlike `_.differenceBy`, this method mutates `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to remove.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
+ *
+ * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
+ * console.log(array);
+ * // => [{ 'x': 2 }]
+ */
+ function pullAllBy(array, values, iteratee) {
+ return (array && array.length && values && values.length)
+ ? basePullAll(array, values, getIteratee(iteratee, 2))
+ : array;
+ }
+
+ /**
+ * This method is like `_.pullAll` except that it accepts `comparator` which
+ * is invoked to compare elements of `array` to `values`. The comparator is
+ * invoked with two arguments: (arrVal, othVal).
+ *
+ * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.6.0
+ * @category Array
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to remove.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
+ *
+ * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
+ * console.log(array);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
+ */
+ function pullAllWith(array, values, comparator) {
+ return (array && array.length && values && values.length)
+ ? basePullAll(array, values, undefined$1, comparator)
+ : array;
+ }
+
+ /**
+ * Removes elements from `array` corresponding to `indexes` and returns an
+ * array of removed elements.
+ *
+ * **Note:** Unlike `_.at`, this method mutates `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The array to modify.
+ * @param {...(number|number[])} [indexes] The indexes of elements to remove.
+ * @returns {Array} Returns the new array of removed elements.
+ * @example
+ *
+ * var array = ['a', 'b', 'c', 'd'];
+ * var pulled = _.pullAt(array, [1, 3]);
+ *
+ * console.log(array);
+ * // => ['a', 'c']
+ *
+ * console.log(pulled);
+ * // => ['b', 'd']
+ */
+ var pullAt = flatRest(function(array, indexes) {
+ var length = array == null ? 0 : array.length,
+ result = baseAt(array, indexes);
+
+ basePullAt(array, arrayMap(indexes, function(index) {
+ return isIndex(index, length) ? +index : index;
+ }).sort(compareAscending));
+
+ return result;
+ });
+
+ /**
+ * Removes all elements from `array` that `predicate` returns truthy for
+ * and returns an array of the removed elements. The predicate is invoked
+ * with three arguments: (value, index, array).
+ *
+ * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`
+ * to pull elements from an array by value.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.0.0
+ * @category Array
+ * @param {Array} array The array to modify.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the new array of removed elements.
+ * @example
+ *
+ * var array = [1, 2, 3, 4];
+ * var evens = _.remove(array, function(n) {
+ * return n % 2 == 0;
+ * });
+ *
+ * console.log(array);
+ * // => [1, 3]
+ *
+ * console.log(evens);
+ * // => [2, 4]
+ */
+ function remove(array, predicate) {
+ var result = [];
+ if (!(array && array.length)) {
+ return result;
+ }
+ var index = -1,
+ indexes = [],
+ length = array.length;
+
+ predicate = getIteratee(predicate, 3);
+ while (++index < length) {
+ var value = array[index];
+ if (predicate(value, index, array)) {
+ result.push(value);
+ indexes.push(index);
+ }
+ }
+ basePullAt(array, indexes);
+ return result;
+ }
+
+ /**
+ * Reverses `array` so that the first element becomes the last, the second
+ * element becomes the second to last, and so on.
+ *
+ * **Note:** This method mutates `array` and is based on
+ * [`Array#reverse`](https://mdn.io/Array/reverse).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to modify.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [1, 2, 3];
+ *
+ * _.reverse(array);
+ * // => [3, 2, 1]
+ *
+ * console.log(array);
+ * // => [3, 2, 1]
+ */
+ function reverse(array) {
+ return array == null ? array : nativeReverse.call(array);
+ }
+
+ /**
+ * Creates a slice of `array` from `start` up to, but not including, `end`.
+ *
+ * **Note:** This method is used instead of
+ * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
+ * returned.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The array to slice.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns the slice of `array`.
+ */
+ function slice(array, start, end) {
+ var length = array == null ? 0 : array.length;
+ if (!length) {
+ return [];
+ }
+ if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {
+ start = 0;
+ end = length;
+ }
+ else {
+ start = start == null ? 0 : toInteger(start);
+ end = end === undefined$1 ? length : toInteger(end);
+ }
+ return baseSlice(array, start, end);
+ }
+
+ /**
+ * Uses a binary search to determine the lowest index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ * into `array`.
+ * @example
+ *
+ * _.sortedIndex([30, 50], 40);
+ * // => 1
+ */
+ function sortedIndex(array, value) {
+ return baseSortedIndex(array, value);
+ }
+
+ /**
+ * This method is like `_.sortedIndex` except that it accepts `iteratee`
+ * which is invoked for `value` and each element of `array` to compute their
+ * sort ranking. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {number} Returns the index at which `value` should be inserted
+ * into `array`.
+ * @example
+ *
+ * var objects = [{ 'x': 4 }, { 'x': 5 }];
+ *
+ * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
+ * // => 0
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.sortedIndexBy(objects, { 'x': 4 }, 'x');
+ * // => 0
+ */
+ function sortedIndexBy(array, value, iteratee) {
+ return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));
+ }
+
+ /**
+ * This method is like `_.indexOf` except that it performs a binary
+ * search on a sorted `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ * @example
+ *
+ * _.sortedIndexOf([4, 5, 5, 5, 6], 5);
+ * // => 1
+ */
+ function sortedIndexOf(array, value) {
+ var length = array == null ? 0 : array.length;
+ if (length) {
+ var index = baseSortedIndex(array, value);
+ if (index < length && eq(array[index], value)) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * This method is like `_.sortedIndex` except that it returns the highest
+ * index at which `value` should be inserted into `array` in order to
+ * maintain its sort order.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ * into `array`.
+ * @example
+ *
+ * _.sortedLastIndex([4, 5, 5, 5, 6], 5);
+ * // => 4
+ */
+ function sortedLastIndex(array, value) {
+ return baseSortedIndex(array, value, true);
+ }
+
+ /**
+ * This method is like `_.sortedLastIndex` except that it accepts `iteratee`
+ * which is invoked for `value` and each element of `array` to compute their
+ * sort ranking. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {number} Returns the index at which `value` should be inserted
+ * into `array`.
+ * @example
+ *
+ * var objects = [{ 'x': 4 }, { 'x': 5 }];
+ *
+ * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
+ * // => 1
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
+ * // => 1
+ */
+ function sortedLastIndexBy(array, value, iteratee) {
+ return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);
+ }
+
+ /**
+ * This method is like `_.lastIndexOf` except that it performs a binary
+ * search on a sorted `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ * @example
+ *
+ * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
+ * // => 3
+ */
+ function sortedLastIndexOf(array, value) {
+ var length = array == null ? 0 : array.length;
+ if (length) {
+ var index = baseSortedIndex(array, value, true) - 1;
+ if (eq(array[index], value)) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * This method is like `_.uniq` except that it's designed and optimized
+ * for sorted arrays.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * _.sortedUniq([1, 1, 2]);
+ * // => [1, 2]
+ */
+ function sortedUniq(array) {
+ return (array && array.length)
+ ? baseSortedUniq(array)
+ : [];
+ }
+
+ /**
+ * This method is like `_.uniqBy` except that it's designed and optimized
+ * for sorted arrays.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
+ * // => [1.1, 2.3]
+ */
+ function sortedUniqBy(array, iteratee) {
+ return (array && array.length)
+ ? baseSortedUniq(array, getIteratee(iteratee, 2))
+ : [];
+ }
+
+ /**
+ * Gets all but the first element of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.tail([1, 2, 3]);
+ * // => [2, 3]
+ */
+ function tail(array) {
+ var length = array == null ? 0 : array.length;
+ return length ? baseSlice(array, 1, length) : [];
+ }
+
+ /**
+ * Creates a slice of `array` with `n` elements taken from the beginning.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {number} [n=1] The number of elements to take.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.take([1, 2, 3]);
+ * // => [1]
+ *
+ * _.take([1, 2, 3], 2);
+ * // => [1, 2]
+ *
+ * _.take([1, 2, 3], 5);
+ * // => [1, 2, 3]
+ *
+ * _.take([1, 2, 3], 0);
+ * // => []
+ */
+ function take(array, n, guard) {
+ if (!(array && array.length)) {
+ return [];
+ }
+ n = (guard || n === undefined$1) ? 1 : toInteger(n);
+ return baseSlice(array, 0, n < 0 ? 0 : n);
+ }
+
+ /**
+ * Creates a slice of `array` with `n` elements taken from the end.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {number} [n=1] The number of elements to take.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * _.takeRight([1, 2, 3]);
+ * // => [3]
+ *
+ * _.takeRight([1, 2, 3], 2);
+ * // => [2, 3]
+ *
+ * _.takeRight([1, 2, 3], 5);
+ * // => [1, 2, 3]
+ *
+ * _.takeRight([1, 2, 3], 0);
+ * // => []
+ */
+ function takeRight(array, n, guard) {
+ var length = array == null ? 0 : array.length;
+ if (!length) {
+ return [];
+ }
+ n = (guard || n === undefined$1) ? 1 : toInteger(n);
+ n = length - n;
+ return baseSlice(array, n < 0 ? 0 : n, length);
+ }
+
+ /**
+ * Creates a slice of `array` with elements taken from the end. Elements are
+ * taken until `predicate` returns falsey. The predicate is invoked with
+ * three arguments: (value, index, array).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'active': true },
+ * { 'user': 'fred', 'active': false },
+ * { 'user': 'pebbles', 'active': false }
+ * ];
+ *
+ * _.takeRightWhile(users, function(o) { return !o.active; });
+ * // => objects for ['fred', 'pebbles']
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
+ * // => objects for ['pebbles']
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.takeRightWhile(users, ['active', false]);
+ * // => objects for ['fred', 'pebbles']
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.takeRightWhile(users, 'active');
+ * // => []
+ */
+ function takeRightWhile(array, predicate) {
+ return (array && array.length)
+ ? baseWhile(array, getIteratee(predicate, 3), false, true)
+ : [];
+ }
+
+ /**
+ * Creates a slice of `array` with elements taken from the beginning. Elements
+ * are taken until `predicate` returns falsey. The predicate is invoked with
+ * three arguments: (value, index, array).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the slice of `array`.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'active': false },
+ * { 'user': 'fred', 'active': false },
+ * { 'user': 'pebbles', 'active': true }
+ * ];
+ *
+ * _.takeWhile(users, function(o) { return !o.active; });
+ * // => objects for ['barney', 'fred']
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.takeWhile(users, { 'user': 'barney', 'active': false });
+ * // => objects for ['barney']
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.takeWhile(users, ['active', false]);
+ * // => objects for ['barney', 'fred']
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.takeWhile(users, 'active');
+ * // => []
+ */
+ function takeWhile(array, predicate) {
+ return (array && array.length)
+ ? baseWhile(array, getIteratee(predicate, 3))
+ : [];
+ }
+
+ /**
+ * Creates an array of unique values, in order, from all given arrays using
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @returns {Array} Returns the new array of combined values.
+ * @example
+ *
+ * _.union([2], [1, 2]);
+ * // => [2, 1]
+ */
+ var union = baseRest(function(arrays) {
+ return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
+ });
+
+ /**
+ * This method is like `_.union` except that it accepts `iteratee` which is
+ * invoked for each element of each `arrays` to generate the criterion by
+ * which uniqueness is computed. Result values are chosen from the first
+ * array in which the value occurs. The iteratee is invoked with one argument:
+ * (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {Array} Returns the new array of combined values.
+ * @example
+ *
+ * _.unionBy([2.1], [1.2, 2.3], Math.floor);
+ * // => [2.1, 1.2]
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
+ * // => [{ 'x': 1 }, { 'x': 2 }]
+ */
+ var unionBy = baseRest(function(arrays) {
+ var iteratee = last(arrays);
+ if (isArrayLikeObject(iteratee)) {
+ iteratee = undefined$1;
+ }
+ return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));
+ });
+
+ /**
+ * This method is like `_.union` except that it accepts `comparator` which
+ * is invoked to compare elements of `arrays`. Result values are chosen from
+ * the first array in which the value occurs. The comparator is invoked
+ * with two arguments: (arrVal, othVal).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of combined values.
+ * @example
+ *
+ * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
+ * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
+ *
+ * _.unionWith(objects, others, _.isEqual);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
+ */
+ var unionWith = baseRest(function(arrays) {
+ var comparator = last(arrays);
+ comparator = typeof comparator == 'function' ? comparator : undefined$1;
+ return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined$1, comparator);
+ });
+
+ /**
+ * Creates a duplicate-free version of an array, using
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons, in which only the first occurrence of each element
+ * is kept. The order of result values is determined by the order they occur
+ * in the array.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * _.uniq([2, 1, 2]);
+ * // => [2, 1]
+ */
+ function uniq(array) {
+ return (array && array.length) ? baseUniq(array) : [];
+ }
+
+ /**
+ * This method is like `_.uniq` except that it accepts `iteratee` which is
+ * invoked for each element in `array` to generate the criterion by which
+ * uniqueness is computed. The order of result values is determined by the
+ * order they occur in the array. The iteratee is invoked with one argument:
+ * (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
+ * // => [2.1, 1.2]
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+ * // => [{ 'x': 1 }, { 'x': 2 }]
+ */
+ function uniqBy(array, iteratee) {
+ return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];
+ }
+
+ /**
+ * This method is like `_.uniq` except that it accepts `comparator` which
+ * is invoked to compare elements of `array`. The order of result values is
+ * determined by the order they occur in the array.The comparator is invoked
+ * with two arguments: (arrVal, othVal).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
+ *
+ * _.uniqWith(objects, _.isEqual);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
+ */
+ function uniqWith(array, comparator) {
+ comparator = typeof comparator == 'function' ? comparator : undefined$1;
+ return (array && array.length) ? baseUniq(array, undefined$1, comparator) : [];
+ }
+
+ /**
+ * This method is like `_.zip` except that it accepts an array of grouped
+ * elements and creates an array regrouping the elements to their pre-zip
+ * configuration.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.2.0
+ * @category Array
+ * @param {Array} array The array of grouped elements to process.
+ * @returns {Array} Returns the new array of regrouped elements.
+ * @example
+ *
+ * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
+ * // => [['a', 1, true], ['b', 2, false]]
+ *
+ * _.unzip(zipped);
+ * // => [['a', 'b'], [1, 2], [true, false]]
+ */
+ function unzip(array) {
+ if (!(array && array.length)) {
+ return [];
+ }
+ var length = 0;
+ array = arrayFilter(array, function(group) {
+ if (isArrayLikeObject(group)) {
+ length = nativeMax(group.length, length);
+ return true;
+ }
+ });
+ return baseTimes(length, function(index) {
+ return arrayMap(array, baseProperty(index));
+ });
+ }
+
+ /**
+ * This method is like `_.unzip` except that it accepts `iteratee` to specify
+ * how regrouped values should be combined. The iteratee is invoked with the
+ * elements of each group: (...group).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.8.0
+ * @category Array
+ * @param {Array} array The array of grouped elements to process.
+ * @param {Function} [iteratee=_.identity] The function to combine
+ * regrouped values.
+ * @returns {Array} Returns the new array of regrouped elements.
+ * @example
+ *
+ * var zipped = _.zip([1, 2], [10, 20], [100, 200]);
+ * // => [[1, 10, 100], [2, 20, 200]]
+ *
+ * _.unzipWith(zipped, _.add);
+ * // => [3, 30, 300]
+ */
+ function unzipWith(array, iteratee) {
+ if (!(array && array.length)) {
+ return [];
+ }
+ var result = unzip(array);
+ if (iteratee == null) {
+ return result;
+ }
+ return arrayMap(result, function(group) {
+ return apply(iteratee, undefined$1, group);
+ });
+ }
+
+ /**
+ * Creates an array excluding all given values using
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * **Note:** Unlike `_.pull`, this method returns a new array.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {...*} [values] The values to exclude.
+ * @returns {Array} Returns the new array of filtered values.
+ * @see _.difference, _.xor
+ * @example
+ *
+ * _.without([2, 1, 2, 3], 1, 2);
+ * // => [3]
+ */
+ var without = baseRest(function(array, values) {
+ return isArrayLikeObject(array)
+ ? baseDifference(array, values)
+ : [];
+ });
+
+ /**
+ * Creates an array of unique values that is the
+ * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
+ * of the given arrays. The order of result values is determined by the order
+ * they occur in the arrays.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @returns {Array} Returns the new array of filtered values.
+ * @see _.difference, _.without
+ * @example
+ *
+ * _.xor([2, 1], [2, 3]);
+ * // => [1, 3]
+ */
+ var xor = baseRest(function(arrays) {
+ return baseXor(arrayFilter(arrays, isArrayLikeObject));
+ });
+
+ /**
+ * This method is like `_.xor` except that it accepts `iteratee` which is
+ * invoked for each element of each `arrays` to generate the criterion by
+ * which by which they're compared. The order of result values is determined
+ * by the order they occur in the arrays. The iteratee is invoked with one
+ * argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {Array} Returns the new array of filtered values.
+ * @example
+ *
+ * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
+ * // => [1.2, 3.4]
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
+ * // => [{ 'x': 2 }]
+ */
+ var xorBy = baseRest(function(arrays) {
+ var iteratee = last(arrays);
+ if (isArrayLikeObject(iteratee)) {
+ iteratee = undefined$1;
+ }
+ return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));
+ });
+
+ /**
+ * This method is like `_.xor` except that it accepts `comparator` which is
+ * invoked to compare elements of `arrays`. The order of result values is
+ * determined by the order they occur in the arrays. The comparator is invoked
+ * with two arguments: (arrVal, othVal).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of filtered values.
+ * @example
+ *
+ * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
+ * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
+ *
+ * _.xorWith(objects, others, _.isEqual);
+ * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
+ */
+ var xorWith = baseRest(function(arrays) {
+ var comparator = last(arrays);
+ comparator = typeof comparator == 'function' ? comparator : undefined$1;
+ return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined$1, comparator);
+ });
+
+ /**
+ * Creates an array of grouped elements, the first of which contains the
+ * first elements of the given arrays, the second of which contains the
+ * second elements of the given arrays, and so on.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to process.
+ * @returns {Array} Returns the new array of grouped elements.
+ * @example
+ *
+ * _.zip(['a', 'b'], [1, 2], [true, false]);
+ * // => [['a', 1, true], ['b', 2, false]]
+ */
+ var zip = baseRest(unzip);
+
+ /**
+ * This method is like `_.fromPairs` except that it accepts two arrays,
+ * one of property identifiers and one of corresponding values.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.4.0
+ * @category Array
+ * @param {Array} [props=[]] The property identifiers.
+ * @param {Array} [values=[]] The property values.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * _.zipObject(['a', 'b'], [1, 2]);
+ * // => { 'a': 1, 'b': 2 }
+ */
+ function zipObject(props, values) {
+ return baseZipObject(props || [], values || [], assignValue);
+ }
+
+ /**
+ * This method is like `_.zipObject` except that it supports property paths.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.1.0
+ * @category Array
+ * @param {Array} [props=[]] The property identifiers.
+ * @param {Array} [values=[]] The property values.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
+ * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
+ */
+ function zipObjectDeep(props, values) {
+ return baseZipObject(props || [], values || [], baseSet);
+ }
+
+ /**
+ * This method is like `_.zip` except that it accepts `iteratee` to specify
+ * how grouped values should be combined. The iteratee is invoked with the
+ * elements of each group: (...group).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.8.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to process.
+ * @param {Function} [iteratee=_.identity] The function to combine
+ * grouped values.
+ * @returns {Array} Returns the new array of grouped elements.
+ * @example
+ *
+ * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
+ * return a + b + c;
+ * });
+ * // => [111, 222]
+ */
+ var zipWith = baseRest(function(arrays) {
+ var length = arrays.length,
+ iteratee = length > 1 ? arrays[length - 1] : undefined$1;
+
+ iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined$1;
+ return unzipWith(arrays, iteratee);
+ });
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Creates a `lodash` wrapper instance that wraps `value` with explicit method
+ * chain sequences enabled. The result of such sequences must be unwrapped
+ * with `_#value`.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.3.0
+ * @category Seq
+ * @param {*} value The value to wrap.
+ * @returns {Object} Returns the new `lodash` wrapper instance.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'age': 36 },
+ * { 'user': 'fred', 'age': 40 },
+ * { 'user': 'pebbles', 'age': 1 }
+ * ];
+ *
+ * var youngest = _
+ * .chain(users)
+ * .sortBy('age')
+ * .map(function(o) {
+ * return o.user + ' is ' + o.age;
+ * })
+ * .head()
+ * .value();
+ * // => 'pebbles is 1'
+ */
+ function chain(value) {
+ var result = lodash(value);
+ result.__chain__ = true;
+ return result;
+ }
+
+ /**
+ * This method invokes `interceptor` and returns `value`. The interceptor
+ * is invoked with one argument; (value). The purpose of this method is to
+ * "tap into" a method chain sequence in order to modify intermediate results.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Seq
+ * @param {*} value The value to provide to `interceptor`.
+ * @param {Function} interceptor The function to invoke.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * _([1, 2, 3])
+ * .tap(function(array) {
+ * // Mutate input array.
+ * array.pop();
+ * })
+ * .reverse()
+ * .value();
+ * // => [2, 1]
+ */
+ function tap(value, interceptor) {
+ interceptor(value);
+ return value;
+ }
+
+ /**
+ * This method is like `_.tap` except that it returns the result of `interceptor`.
+ * The purpose of this method is to "pass thru" values replacing intermediate
+ * results in a method chain sequence.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Seq
+ * @param {*} value The value to provide to `interceptor`.
+ * @param {Function} interceptor The function to invoke.
+ * @returns {*} Returns the result of `interceptor`.
+ * @example
+ *
+ * _(' abc ')
+ * .chain()
+ * .trim()
+ * .thru(function(value) {
+ * return [value];
+ * })
+ * .value();
+ * // => ['abc']
+ */
+ function thru(value, interceptor) {
+ return interceptor(value);
+ }
+
+ /**
+ * This method is the wrapper version of `_.at`.
+ *
+ * @name at
+ * @memberOf _
+ * @since 1.0.0
+ * @category Seq
+ * @param {...(string|string[])} [paths] The property paths to pick.
+ * @returns {Object} Returns the new `lodash` wrapper instance.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
+ *
+ * _(object).at(['a[0].b.c', 'a[1]']).value();
+ * // => [3, 4]
+ */
+ var wrapperAt = flatRest(function(paths) {
+ var length = paths.length,
+ start = length ? paths[0] : 0,
+ value = this.__wrapped__,
+ interceptor = function(object) { return baseAt(object, paths); };
+
+ if (length > 1 || this.__actions__.length ||
+ !(value instanceof LazyWrapper) || !isIndex(start)) {
+ return this.thru(interceptor);
+ }
+ value = value.slice(start, +start + (length ? 1 : 0));
+ value.__actions__.push({
+ 'func': thru,
+ 'args': [interceptor],
+ 'thisArg': undefined$1
+ });
+ return new LodashWrapper(value, this.__chain__).thru(function(array) {
+ if (length && !array.length) {
+ array.push(undefined$1);
+ }
+ return array;
+ });
+ });
+
+ /**
+ * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.
+ *
+ * @name chain
+ * @memberOf _
+ * @since 0.1.0
+ * @category Seq
+ * @returns {Object} Returns the new `lodash` wrapper instance.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'age': 36 },
+ * { 'user': 'fred', 'age': 40 }
+ * ];
+ *
+ * // A sequence without explicit chaining.
+ * _(users).head();
+ * // => { 'user': 'barney', 'age': 36 }
+ *
+ * // A sequence with explicit chaining.
+ * _(users)
+ * .chain()
+ * .head()
+ * .pick('user')
+ * .value();
+ * // => { 'user': 'barney' }
+ */
+ function wrapperChain() {
+ return chain(this);
+ }
+
+ /**
+ * Executes the chain sequence and returns the wrapped result.
+ *
+ * @name commit
+ * @memberOf _
+ * @since 3.2.0
+ * @category Seq
+ * @returns {Object} Returns the new `lodash` wrapper instance.
+ * @example
+ *
+ * var array = [1, 2];
+ * var wrapped = _(array).push(3);
+ *
+ * console.log(array);
+ * // => [1, 2]
+ *
+ * wrapped = wrapped.commit();
+ * console.log(array);
+ * // => [1, 2, 3]
+ *
+ * wrapped.last();
+ * // => 3
+ *
+ * console.log(array);
+ * // => [1, 2, 3]
+ */
+ function wrapperCommit() {
+ return new LodashWrapper(this.value(), this.__chain__);
+ }
+
+ /**
+ * Gets the next value on a wrapped object following the
+ * [iterator protocol](https://mdn.io/iteration_protocols#iterator).
+ *
+ * @name next
+ * @memberOf _
+ * @since 4.0.0
+ * @category Seq
+ * @returns {Object} Returns the next iterator value.
+ * @example
+ *
+ * var wrapped = _([1, 2]);
+ *
+ * wrapped.next();
+ * // => { 'done': false, 'value': 1 }
+ *
+ * wrapped.next();
+ * // => { 'done': false, 'value': 2 }
+ *
+ * wrapped.next();
+ * // => { 'done': true, 'value': undefined }
+ */
+ function wrapperNext() {
+ if (this.__values__ === undefined$1) {
+ this.__values__ = toArray(this.value());
+ }
+ var done = this.__index__ >= this.__values__.length,
+ value = done ? undefined$1 : this.__values__[this.__index__++];
+
+ return { 'done': done, 'value': value };
+ }
+
+ /**
+ * Enables the wrapper to be iterable.
+ *
+ * @name Symbol.iterator
+ * @memberOf _
+ * @since 4.0.0
+ * @category Seq
+ * @returns {Object} Returns the wrapper object.
+ * @example
+ *
+ * var wrapped = _([1, 2]);
+ *
+ * wrapped[Symbol.iterator]() === wrapped;
+ * // => true
+ *
+ * Array.from(wrapped);
+ * // => [1, 2]
+ */
+ function wrapperToIterator() {
+ return this;
+ }
+
+ /**
+ * Creates a clone of the chain sequence planting `value` as the wrapped value.
+ *
+ * @name plant
+ * @memberOf _
+ * @since 3.2.0
+ * @category Seq
+ * @param {*} value The value to plant.
+ * @returns {Object} Returns the new `lodash` wrapper instance.
+ * @example
+ *
+ * function square(n) {
+ * return n * n;
+ * }
+ *
+ * var wrapped = _([1, 2]).map(square);
+ * var other = wrapped.plant([3, 4]);
+ *
+ * other.value();
+ * // => [9, 16]
+ *
+ * wrapped.value();
+ * // => [1, 4]
+ */
+ function wrapperPlant(value) {
+ var result,
+ parent = this;
+
+ while (parent instanceof baseLodash) {
+ var clone = wrapperClone(parent);
+ clone.__index__ = 0;
+ clone.__values__ = undefined$1;
+ if (result) {
+ previous.__wrapped__ = clone;
+ } else {
+ result = clone;
+ }
+ var previous = clone;
+ parent = parent.__wrapped__;
+ }
+ previous.__wrapped__ = value;
+ return result;
+ }
+
+ /**
+ * This method is the wrapper version of `_.reverse`.
+ *
+ * **Note:** This method mutates the wrapped array.
+ *
+ * @name reverse
+ * @memberOf _
+ * @since 0.1.0
+ * @category Seq
+ * @returns {Object} Returns the new `lodash` wrapper instance.
+ * @example
+ *
+ * var array = [1, 2, 3];
+ *
+ * _(array).reverse().value()
+ * // => [3, 2, 1]
+ *
+ * console.log(array);
+ * // => [3, 2, 1]
+ */
+ function wrapperReverse() {
+ var value = this.__wrapped__;
+ if (value instanceof LazyWrapper) {
+ var wrapped = value;
+ if (this.__actions__.length) {
+ wrapped = new LazyWrapper(this);
+ }
+ wrapped = wrapped.reverse();
+ wrapped.__actions__.push({
+ 'func': thru,
+ 'args': [reverse],
+ 'thisArg': undefined$1
+ });
+ return new LodashWrapper(wrapped, this.__chain__);
+ }
+ return this.thru(reverse);
+ }
+
+ /**
+ * Executes the chain sequence to resolve the unwrapped value.
+ *
+ * @name value
+ * @memberOf _
+ * @since 0.1.0
+ * @alias toJSON, valueOf
+ * @category Seq
+ * @returns {*} Returns the resolved unwrapped value.
+ * @example
+ *
+ * _([1, 2, 3]).value();
+ * // => [1, 2, 3]
+ */
+ function wrapperValue() {
+ return baseWrapperValue(this.__wrapped__, this.__actions__);
+ }
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` thru `iteratee`. The corresponding value of
+ * each key is the number of times the key was returned by `iteratee`. The
+ * iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.5.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * _.countBy([6.1, 4.2, 6.3], Math.floor);
+ * // => { '4': 1, '6': 2 }
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.countBy(['one', 'two', 'three'], 'length');
+ * // => { '3': 2, '5': 1 }
+ */
+ var countBy = createAggregator(function(result, value, key) {
+ if (hasOwnProperty.call(result, key)) {
+ ++result[key];
+ } else {
+ baseAssignValue(result, key, 1);
+ }
+ });
+
+ /**
+ * Checks if `predicate` returns truthy for **all** elements of `collection`.
+ * Iteration is stopped once `predicate` returns falsey. The predicate is
+ * invoked with three arguments: (value, index|key, collection).
+ *
+ * **Note:** This method returns `true` for
+ * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because
+ * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of
+ * elements of empty collections.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {boolean} Returns `true` if all elements pass the predicate check,
+ * else `false`.
+ * @example
+ *
+ * _.every([true, 1, null, 'yes'], Boolean);
+ * // => false
+ *
+ * var users = [
+ * { 'user': 'barney', 'age': 36, 'active': false },
+ * { 'user': 'fred', 'age': 40, 'active': false }
+ * ];
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.every(users, { 'user': 'barney', 'active': false });
+ * // => false
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.every(users, ['active', false]);
+ * // => true
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.every(users, 'active');
+ * // => false
+ */
+ function every(collection, predicate, guard) {
+ var func = isArray(collection) ? arrayEvery : baseEvery;
+ if (guard && isIterateeCall(collection, predicate, guard)) {
+ predicate = undefined$1;
+ }
+ return func(collection, getIteratee(predicate, 3));
+ }
+
+ /**
+ * Iterates over elements of `collection`, returning an array of all elements
+ * `predicate` returns truthy for. The predicate is invoked with three
+ * arguments: (value, index|key, collection).
+ *
+ * **Note:** Unlike `_.remove`, this method returns a new array.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ * @see _.reject
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'age': 36, 'active': true },
+ * { 'user': 'fred', 'age': 40, 'active': false }
+ * ];
+ *
+ * _.filter(users, function(o) { return !o.active; });
+ * // => objects for ['fred']
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.filter(users, { 'age': 36, 'active': true });
+ * // => objects for ['barney']
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.filter(users, ['active', false]);
+ * // => objects for ['fred']
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.filter(users, 'active');
+ * // => objects for ['barney']
+ *
+ * // Combining several predicates using `_.overEvery` or `_.overSome`.
+ * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]]));
+ * // => objects for ['fred', 'barney']
+ */
+ function filter(collection, predicate) {
+ var func = isArray(collection) ? arrayFilter : baseFilter;
+ return func(collection, getIteratee(predicate, 3));
+ }
+
+ /**
+ * Iterates over elements of `collection`, returning the first element
+ * `predicate` returns truthy for. The predicate is invoked with three
+ * arguments: (value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to inspect.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {*} Returns the matched element, else `undefined`.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'age': 36, 'active': true },
+ * { 'user': 'fred', 'age': 40, 'active': false },
+ * { 'user': 'pebbles', 'age': 1, 'active': true }
+ * ];
+ *
+ * _.find(users, function(o) { return o.age < 40; });
+ * // => object for 'barney'
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.find(users, { 'age': 1, 'active': true });
+ * // => object for 'pebbles'
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.find(users, ['active', false]);
+ * // => object for 'fred'
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.find(users, 'active');
+ * // => object for 'barney'
+ */
+ var find = createFind(findIndex);
+
+ /**
+ * This method is like `_.find` except that it iterates over elements of
+ * `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.0.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to inspect.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @param {number} [fromIndex=collection.length-1] The index to search from.
+ * @returns {*} Returns the matched element, else `undefined`.
+ * @example
+ *
+ * _.findLast([1, 2, 3, 4], function(n) {
+ * return n % 2 == 1;
+ * });
+ * // => 3
+ */
+ var findLast = createFind(findLastIndex);
+
+ /**
+ * Creates a flattened array of values by running each element in `collection`
+ * thru `iteratee` and flattening the mapped results. The iteratee is invoked
+ * with three arguments: (value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * function duplicate(n) {
+ * return [n, n];
+ * }
+ *
+ * _.flatMap([1, 2], duplicate);
+ * // => [1, 1, 2, 2]
+ */
+ function flatMap(collection, iteratee) {
+ return baseFlatten(map(collection, iteratee), 1);
+ }
+
+ /**
+ * This method is like `_.flatMap` except that it recursively flattens the
+ * mapped results.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.7.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * function duplicate(n) {
+ * return [[[n, n]]];
+ * }
+ *
+ * _.flatMapDeep([1, 2], duplicate);
+ * // => [1, 1, 2, 2]
+ */
+ function flatMapDeep(collection, iteratee) {
+ return baseFlatten(map(collection, iteratee), INFINITY);
+ }
+
+ /**
+ * This method is like `_.flatMap` except that it recursively flattens the
+ * mapped results up to `depth` times.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.7.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @param {number} [depth=1] The maximum recursion depth.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * function duplicate(n) {
+ * return [[[n, n]]];
+ * }
+ *
+ * _.flatMapDepth([1, 2], duplicate, 2);
+ * // => [[1, 1], [2, 2]]
+ */
+ function flatMapDepth(collection, iteratee, depth) {
+ depth = depth === undefined$1 ? 1 : toInteger(depth);
+ return baseFlatten(map(collection, iteratee), depth);
+ }
+
+ /**
+ * Iterates over elements of `collection` and invokes `iteratee` for each element.
+ * The iteratee is invoked with three arguments: (value, index|key, collection).
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * **Note:** As with other "Collections" methods, objects with a "length"
+ * property are iterated like arrays. To avoid this behavior use `_.forIn`
+ * or `_.forOwn` for object iteration.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @alias each
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ * @see _.forEachRight
+ * @example
+ *
+ * _.forEach([1, 2], function(value) {
+ * console.log(value);
+ * });
+ * // => Logs `1` then `2`.
+ *
+ * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
+ * console.log(key);
+ * });
+ * // => Logs 'a' then 'b' (iteration order is not guaranteed).
+ */
+ function forEach(collection, iteratee) {
+ var func = isArray(collection) ? arrayEach : baseEach;
+ return func(collection, getIteratee(iteratee, 3));
+ }
+
+ /**
+ * This method is like `_.forEach` except that it iterates over elements of
+ * `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.0.0
+ * @alias eachRight
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ * @see _.forEach
+ * @example
+ *
+ * _.forEachRight([1, 2], function(value) {
+ * console.log(value);
+ * });
+ * // => Logs `2` then `1`.
+ */
+ function forEachRight(collection, iteratee) {
+ var func = isArray(collection) ? arrayEachRight : baseEachRight;
+ return func(collection, getIteratee(iteratee, 3));
+ }
+
+ /**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` thru `iteratee`. The order of grouped values
+ * is determined by the order they occur in `collection`. The corresponding
+ * value of each key is an array of elements responsible for generating the
+ * key. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * _.groupBy([6.1, 4.2, 6.3], Math.floor);
+ * // => { '4': [4.2], '6': [6.1, 6.3] }
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.groupBy(['one', 'two', 'three'], 'length');
+ * // => { '3': ['one', 'two'], '5': ['three'] }
+ */
+ var groupBy = createAggregator(function(result, value, key) {
+ if (hasOwnProperty.call(result, key)) {
+ result[key].push(value);
+ } else {
+ baseAssignValue(result, key, [value]);
+ }
+ });
+
+ /**
+ * Checks if `value` is in `collection`. If `collection` is a string, it's
+ * checked for a substring of `value`, otherwise
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * is used for equality comparisons. If `fromIndex` is negative, it's used as
+ * the offset from the end of `collection`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object|string} collection The collection to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
+ * @returns {boolean} Returns `true` if `value` is found, else `false`.
+ * @example
+ *
+ * _.includes([1, 2, 3], 1);
+ * // => true
+ *
+ * _.includes([1, 2, 3], 1, 2);
+ * // => false
+ *
+ * _.includes({ 'a': 1, 'b': 2 }, 1);
+ * // => true
+ *
+ * _.includes('abcd', 'bc');
+ * // => true
+ */
+ function includes(collection, value, fromIndex, guard) {
+ collection = isArrayLike(collection) ? collection : values(collection);
+ fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;
+
+ var length = collection.length;
+ if (fromIndex < 0) {
+ fromIndex = nativeMax(length + fromIndex, 0);
+ }
+ return isString(collection)
+ ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)
+ : (!!length && baseIndexOf(collection, value, fromIndex) > -1);
+ }
+
+ /**
+ * Invokes the method at `path` of each element in `collection`, returning
+ * an array of the results of each invoked method. Any additional arguments
+ * are provided to each invoked method. If `path` is a function, it's invoked
+ * for, and `this` bound to, each element in `collection`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Array|Function|string} path The path of the method to invoke or
+ * the function invoked per iteration.
+ * @param {...*} [args] The arguments to invoke each method with.
+ * @returns {Array} Returns the array of results.
+ * @example
+ *
+ * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
+ * // => [[1, 5, 7], [1, 2, 3]]
+ *
+ * _.invokeMap([123, 456], String.prototype.split, '');
+ * // => [['1', '2', '3'], ['4', '5', '6']]
+ */
+ var invokeMap = baseRest(function(collection, path, args) {
+ var index = -1,
+ isFunc = typeof path == 'function',
+ result = isArrayLike(collection) ? Array(collection.length) : [];
+
+ baseEach(collection, function(value) {
+ result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
+ });
+ return result;
+ });
+
+ /**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` thru `iteratee`. The corresponding value of
+ * each key is the last element responsible for generating the key. The
+ * iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * var array = [
+ * { 'dir': 'left', 'code': 97 },
+ * { 'dir': 'right', 'code': 100 }
+ * ];
+ *
+ * _.keyBy(array, function(o) {
+ * return String.fromCharCode(o.code);
+ * });
+ * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
+ *
+ * _.keyBy(array, 'dir');
+ * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
+ */
+ var keyBy = createAggregator(function(result, value, key) {
+ baseAssignValue(result, key, value);
+ });
+
+ /**
+ * Creates an array of values by running each element in `collection` thru
+ * `iteratee`. The iteratee is invoked with three arguments:
+ * (value, index|key, collection).
+ *
+ * Many lodash methods are guarded to work as iteratees for methods like
+ * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
+ *
+ * The guarded methods are:
+ * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
+ * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
+ * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
+ * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ * @example
+ *
+ * function square(n) {
+ * return n * n;
+ * }
+ *
+ * _.map([4, 8], square);
+ * // => [16, 64]
+ *
+ * _.map({ 'a': 4, 'b': 8 }, square);
+ * // => [16, 64] (iteration order is not guaranteed)
+ *
+ * var users = [
+ * { 'user': 'barney' },
+ * { 'user': 'fred' }
+ * ];
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.map(users, 'user');
+ * // => ['barney', 'fred']
+ */
+ function map(collection, iteratee) {
+ var func = isArray(collection) ? arrayMap : baseMap;
+ return func(collection, getIteratee(iteratee, 3));
+ }
+
+ /**
+ * This method is like `_.sortBy` except that it allows specifying the sort
+ * orders of the iteratees to sort by. If `orders` is unspecified, all values
+ * are sorted in ascending order. Otherwise, specify an order of "desc" for
+ * descending or "asc" for ascending sort order of corresponding values.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]
+ * The iteratees to sort by.
+ * @param {string[]} [orders] The sort orders of `iteratees`.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
+ * @returns {Array} Returns the new sorted array.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'fred', 'age': 48 },
+ * { 'user': 'barney', 'age': 34 },
+ * { 'user': 'fred', 'age': 40 },
+ * { 'user': 'barney', 'age': 36 }
+ * ];
+ *
+ * // Sort by `user` in ascending order and by `age` in descending order.
+ * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
+ * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
+ */
+ function orderBy(collection, iteratees, orders, guard) {
+ if (collection == null) {
+ return [];
+ }
+ if (!isArray(iteratees)) {
+ iteratees = iteratees == null ? [] : [iteratees];
+ }
+ orders = guard ? undefined$1 : orders;
+ if (!isArray(orders)) {
+ orders = orders == null ? [] : [orders];
+ }
+ return baseOrderBy(collection, iteratees, orders);
+ }
+
+ /**
+ * Creates an array of elements split into two groups, the first of which
+ * contains elements `predicate` returns truthy for, the second of which
+ * contains elements `predicate` returns falsey for. The predicate is
+ * invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the array of grouped elements.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'age': 36, 'active': false },
+ * { 'user': 'fred', 'age': 40, 'active': true },
+ * { 'user': 'pebbles', 'age': 1, 'active': false }
+ * ];
+ *
+ * _.partition(users, function(o) { return o.active; });
+ * // => objects for [['fred'], ['barney', 'pebbles']]
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.partition(users, { 'age': 1, 'active': false });
+ * // => objects for [['pebbles'], ['barney', 'fred']]
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.partition(users, ['active', false]);
+ * // => objects for [['barney', 'pebbles'], ['fred']]
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.partition(users, 'active');
+ * // => objects for [['fred'], ['barney', 'pebbles']]
+ */
+ var partition = createAggregator(function(result, value, key) {
+ result[key ? 0 : 1].push(value);
+ }, function() { return [[], []]; });
+
+ /**
+ * Reduces `collection` to a value which is the accumulated result of running
+ * each element in `collection` thru `iteratee`, where each successive
+ * invocation is supplied the return value of the previous. If `accumulator`
+ * is not given, the first element of `collection` is used as the initial
+ * value. The iteratee is invoked with four arguments:
+ * (accumulator, value, index|key, collection).
+ *
+ * Many lodash methods are guarded to work as iteratees for methods like
+ * `_.reduce`, `_.reduceRight`, and `_.transform`.
+ *
+ * The guarded methods are:
+ * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,
+ * and `sortBy`
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @returns {*} Returns the accumulated value.
+ * @see _.reduceRight
+ * @example
+ *
+ * _.reduce([1, 2], function(sum, n) {
+ * return sum + n;
+ * }, 0);
+ * // => 3
+ *
+ * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
+ * (result[value] || (result[value] = [])).push(key);
+ * return result;
+ * }, {});
+ * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)
+ */
+ function reduce(collection, iteratee, accumulator) {
+ var func = isArray(collection) ? arrayReduce : baseReduce,
+ initAccum = arguments.length < 3;
+
+ return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);
+ }
+
+ /**
+ * This method is like `_.reduce` except that it iterates over elements of
+ * `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @returns {*} Returns the accumulated value.
+ * @see _.reduce
+ * @example
+ *
+ * var array = [[0, 1], [2, 3], [4, 5]];
+ *
+ * _.reduceRight(array, function(flattened, other) {
+ * return flattened.concat(other);
+ * }, []);
+ * // => [4, 5, 2, 3, 0, 1]
+ */
+ function reduceRight(collection, iteratee, accumulator) {
+ var func = isArray(collection) ? arrayReduceRight : baseReduce,
+ initAccum = arguments.length < 3;
+
+ return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);
+ }
+
+ /**
+ * The opposite of `_.filter`; this method returns the elements of `collection`
+ * that `predicate` does **not** return truthy for.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ * @see _.filter
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'age': 36, 'active': false },
+ * { 'user': 'fred', 'age': 40, 'active': true }
+ * ];
+ *
+ * _.reject(users, function(o) { return !o.active; });
+ * // => objects for ['fred']
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.reject(users, { 'age': 40, 'active': true });
+ * // => objects for ['barney']
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.reject(users, ['active', false]);
+ * // => objects for ['fred']
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.reject(users, 'active');
+ * // => objects for ['barney']
+ */
+ function reject(collection, predicate) {
+ var func = isArray(collection) ? arrayFilter : baseFilter;
+ return func(collection, negate(getIteratee(predicate, 3)));
+ }
+
+ /**
+ * Gets a random element from `collection`.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.0.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to sample.
+ * @returns {*} Returns the random element.
+ * @example
+ *
+ * _.sample([1, 2, 3, 4]);
+ * // => 2
+ */
+ function sample(collection) {
+ var func = isArray(collection) ? arraySample : baseSample;
+ return func(collection);
+ }
+
+ /**
+ * Gets `n` random elements at unique keys from `collection` up to the
+ * size of `collection`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to sample.
+ * @param {number} [n=1] The number of elements to sample.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {Array} Returns the random elements.
+ * @example
+ *
+ * _.sampleSize([1, 2, 3], 2);
+ * // => [3, 1]
+ *
+ * _.sampleSize([1, 2, 3], 4);
+ * // => [2, 3, 1]
+ */
+ function sampleSize(collection, n, guard) {
+ if ((guard ? isIterateeCall(collection, n, guard) : n === undefined$1)) {
+ n = 1;
+ } else {
+ n = toInteger(n);
+ }
+ var func = isArray(collection) ? arraySampleSize : baseSampleSize;
+ return func(collection, n);
+ }
+
+ /**
+ * Creates an array of shuffled values, using a version of the
+ * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to shuffle.
+ * @returns {Array} Returns the new shuffled array.
+ * @example
+ *
+ * _.shuffle([1, 2, 3, 4]);
+ * // => [4, 1, 3, 2]
+ */
+ function shuffle(collection) {
+ var func = isArray(collection) ? arrayShuffle : baseShuffle;
+ return func(collection);
+ }
+
+ /**
+ * Gets the size of `collection` by returning its length for array-like
+ * values or the number of own enumerable string keyed properties for objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object|string} collection The collection to inspect.
+ * @returns {number} Returns the collection size.
+ * @example
+ *
+ * _.size([1, 2, 3]);
+ * // => 3
+ *
+ * _.size({ 'a': 1, 'b': 2 });
+ * // => 2
+ *
+ * _.size('pebbles');
+ * // => 7
+ */
+ function size(collection) {
+ if (collection == null) {
+ return 0;
+ }
+ if (isArrayLike(collection)) {
+ return isString(collection) ? stringSize(collection) : collection.length;
+ }
+ var tag = getTag(collection);
+ if (tag == mapTag || tag == setTag) {
+ return collection.size;
+ }
+ return baseKeys(collection).length;
+ }
+
+ /**
+ * Checks if `predicate` returns truthy for **any** element of `collection`.
+ * Iteration is stopped once `predicate` returns truthy. The predicate is
+ * invoked with three arguments: (value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ * else `false`.
+ * @example
+ *
+ * _.some([null, 0, 'yes', false], Boolean);
+ * // => true
+ *
+ * var users = [
+ * { 'user': 'barney', 'active': true },
+ * { 'user': 'fred', 'active': false }
+ * ];
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.some(users, { 'user': 'barney', 'active': false });
+ * // => false
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.some(users, ['active', false]);
+ * // => true
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.some(users, 'active');
+ * // => true
+ */
+ function some(collection, predicate, guard) {
+ var func = isArray(collection) ? arraySome : baseSome;
+ if (guard && isIterateeCall(collection, predicate, guard)) {
+ predicate = undefined$1;
+ }
+ return func(collection, getIteratee(predicate, 3));
+ }
+
+ /**
+ * Creates an array of elements, sorted in ascending order by the results of
+ * running each element in a collection thru each iteratee. This method
+ * performs a stable sort, that is, it preserves the original sort order of
+ * equal elements. The iteratees are invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {...(Function|Function[])} [iteratees=[_.identity]]
+ * The iteratees to sort by.
+ * @returns {Array} Returns the new sorted array.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'fred', 'age': 48 },
+ * { 'user': 'barney', 'age': 36 },
+ * { 'user': 'fred', 'age': 30 },
+ * { 'user': 'barney', 'age': 34 }
+ * ];
+ *
+ * _.sortBy(users, [function(o) { return o.user; }]);
+ * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]
+ *
+ * _.sortBy(users, ['user', 'age']);
+ * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]
+ */
+ var sortBy = baseRest(function(collection, iteratees) {
+ if (collection == null) {
+ return [];
+ }
+ var length = iteratees.length;
+ if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
+ iteratees = [];
+ } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
+ iteratees = [iteratees[0]];
+ }
+ return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
+ });
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Gets the timestamp of the number of milliseconds that have elapsed since
+ * the Unix epoch (1 January 1970 00:00:00 UTC).
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Date
+ * @returns {number} Returns the timestamp.
+ * @example
+ *
+ * _.defer(function(stamp) {
+ * console.log(_.now() - stamp);
+ * }, _.now());
+ * // => Logs the number of milliseconds it took for the deferred invocation.
+ */
+ var now = ctxNow || function() {
+ return root.Date.now();
+ };
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * The opposite of `_.before`; this method creates a function that invokes
+ * `func` once it's called `n` or more times.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {number} n The number of calls before `func` is invoked.
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * var saves = ['profile', 'settings'];
+ *
+ * var done = _.after(saves.length, function() {
+ * console.log('done saving!');
+ * });
+ *
+ * _.forEach(saves, function(type) {
+ * asyncSave({ 'type': type, 'complete': done });
+ * });
+ * // => Logs 'done saving!' after the two async saves have completed.
+ */
+ function after(n, func) {
+ if (typeof func != 'function') {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ n = toInteger(n);
+ return function() {
+ if (--n < 1) {
+ return func.apply(this, arguments);
+ }
+ };
+ }
+
+ /**
+ * Creates a function that invokes `func`, with up to `n` arguments,
+ * ignoring any additional arguments.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Function
+ * @param {Function} func The function to cap arguments for.
+ * @param {number} [n=func.length] The arity cap.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {Function} Returns the new capped function.
+ * @example
+ *
+ * _.map(['6', '8', '10'], _.ary(parseInt, 1));
+ * // => [6, 8, 10]
+ */
+ function ary(func, n, guard) {
+ n = guard ? undefined$1 : n;
+ n = (func && n == null) ? func.length : n;
+ return createWrap(func, WRAP_ARY_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, n);
+ }
+
+ /**
+ * Creates a function that invokes `func`, with the `this` binding and arguments
+ * of the created function, while it's called less than `n` times. Subsequent
+ * calls to the created function return the result of the last `func` invocation.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Function
+ * @param {number} n The number of calls at which `func` is no longer invoked.
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * jQuery(element).on('click', _.before(5, addContactToList));
+ * // => Allows adding up to 4 contacts to the list.
+ */
+ function before(n, func) {
+ var result;
+ if (typeof func != 'function') {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ n = toInteger(n);
+ return function() {
+ if (--n > 0) {
+ result = func.apply(this, arguments);
+ }
+ if (n <= 1) {
+ func = undefined$1;
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Creates a function that invokes `func` with the `this` binding of `thisArg`
+ * and `partials` prepended to the arguments it receives.
+ *
+ * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,
+ * may be used as a placeholder for partially applied arguments.
+ *
+ * **Note:** Unlike native `Function#bind`, this method doesn't set the "length"
+ * property of bound functions.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to bind.
+ * @param {*} thisArg The `this` binding of `func`.
+ * @param {...*} [partials] The arguments to be partially applied.
+ * @returns {Function} Returns the new bound function.
+ * @example
+ *
+ * function greet(greeting, punctuation) {
+ * return greeting + ' ' + this.user + punctuation;
+ * }
+ *
+ * var object = { 'user': 'fred' };
+ *
+ * var bound = _.bind(greet, object, 'hi');
+ * bound('!');
+ * // => 'hi fred!'
+ *
+ * // Bound with placeholders.
+ * var bound = _.bind(greet, object, _, '!');
+ * bound('hi');
+ * // => 'hi fred!'
+ */
+ var bind = baseRest(function(func, thisArg, partials) {
+ var bitmask = WRAP_BIND_FLAG;
+ if (partials.length) {
+ var holders = replaceHolders(partials, getHolder(bind));
+ bitmask |= WRAP_PARTIAL_FLAG;
+ }
+ return createWrap(func, bitmask, thisArg, partials, holders);
+ });
+
+ /**
+ * Creates a function that invokes the method at `object[key]` with `partials`
+ * prepended to the arguments it receives.
+ *
+ * This method differs from `_.bind` by allowing bound functions to reference
+ * methods that may be redefined or don't yet exist. See
+ * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)
+ * for more details.
+ *
+ * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic
+ * builds, may be used as a placeholder for partially applied arguments.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.10.0
+ * @category Function
+ * @param {Object} object The object to invoke the method on.
+ * @param {string} key The key of the method.
+ * @param {...*} [partials] The arguments to be partially applied.
+ * @returns {Function} Returns the new bound function.
+ * @example
+ *
+ * var object = {
+ * 'user': 'fred',
+ * 'greet': function(greeting, punctuation) {
+ * return greeting + ' ' + this.user + punctuation;
+ * }
+ * };
+ *
+ * var bound = _.bindKey(object, 'greet', 'hi');
+ * bound('!');
+ * // => 'hi fred!'
+ *
+ * object.greet = function(greeting, punctuation) {
+ * return greeting + 'ya ' + this.user + punctuation;
+ * };
+ *
+ * bound('!');
+ * // => 'hiya fred!'
+ *
+ * // Bound with placeholders.
+ * var bound = _.bindKey(object, 'greet', _, '!');
+ * bound('hi');
+ * // => 'hiya fred!'
+ */
+ var bindKey = baseRest(function(object, key, partials) {
+ var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
+ if (partials.length) {
+ var holders = replaceHolders(partials, getHolder(bindKey));
+ bitmask |= WRAP_PARTIAL_FLAG;
+ }
+ return createWrap(key, bitmask, object, partials, holders);
+ });
+
+ /**
+ * Creates a function that accepts arguments of `func` and either invokes
+ * `func` returning its result, if at least `arity` number of arguments have
+ * been provided, or returns a function that accepts the remaining `func`
+ * arguments, and so on. The arity of `func` may be specified if `func.length`
+ * is not sufficient.
+ *
+ * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,
+ * may be used as a placeholder for provided arguments.
+ *
+ * **Note:** This method doesn't set the "length" property of curried functions.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.0.0
+ * @category Function
+ * @param {Function} func The function to curry.
+ * @param {number} [arity=func.length] The arity of `func`.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {Function} Returns the new curried function.
+ * @example
+ *
+ * var abc = function(a, b, c) {
+ * return [a, b, c];
+ * };
+ *
+ * var curried = _.curry(abc);
+ *
+ * curried(1)(2)(3);
+ * // => [1, 2, 3]
+ *
+ * curried(1, 2)(3);
+ * // => [1, 2, 3]
+ *
+ * curried(1, 2, 3);
+ * // => [1, 2, 3]
+ *
+ * // Curried with placeholders.
+ * curried(1)(_, 3)(2);
+ * // => [1, 2, 3]
+ */
+ function curry(func, arity, guard) {
+ arity = guard ? undefined$1 : arity;
+ var result = createWrap(func, WRAP_CURRY_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, undefined$1, arity);
+ result.placeholder = curry.placeholder;
+ return result;
+ }
+
+ /**
+ * This method is like `_.curry` except that arguments are applied to `func`
+ * in the manner of `_.partialRight` instead of `_.partial`.
+ *
+ * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic
+ * builds, may be used as a placeholder for provided arguments.
+ *
+ * **Note:** This method doesn't set the "length" property of curried functions.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Function
+ * @param {Function} func The function to curry.
+ * @param {number} [arity=func.length] The arity of `func`.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {Function} Returns the new curried function.
+ * @example
+ *
+ * var abc = function(a, b, c) {
+ * return [a, b, c];
+ * };
+ *
+ * var curried = _.curryRight(abc);
+ *
+ * curried(3)(2)(1);
+ * // => [1, 2, 3]
+ *
+ * curried(2, 3)(1);
+ * // => [1, 2, 3]
+ *
+ * curried(1, 2, 3);
+ * // => [1, 2, 3]
+ *
+ * // Curried with placeholders.
+ * curried(3)(1, _)(2);
+ * // => [1, 2, 3]
+ */
+ function curryRight(func, arity, guard) {
+ arity = guard ? undefined$1 : arity;
+ var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, undefined$1, arity);
+ result.placeholder = curryRight.placeholder;
+ return result;
+ }
+
+ /**
+ * Creates a debounced function that delays invoking `func` until after `wait`
+ * milliseconds have elapsed since the last time the debounced function was
+ * invoked. The debounced function comes with a `cancel` method to cancel
+ * delayed `func` invocations and a `flush` method to immediately invoke them.
+ * Provide `options` to indicate whether `func` should be invoked on the
+ * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
+ * with the last arguments provided to the debounced function. Subsequent
+ * calls to the debounced function return the result of the last `func`
+ * invocation.
+ *
+ * **Note:** If `leading` and `trailing` options are `true`, `func` is
+ * invoked on the trailing edge of the timeout only if the debounced function
+ * is invoked more than once during the `wait` timeout.
+ *
+ * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+ * until to the next tick, similar to `setTimeout` with a timeout of `0`.
+ *
+ * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+ * for details over the differences between `_.debounce` and `_.throttle`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to debounce.
+ * @param {number} [wait=0] The number of milliseconds to delay.
+ * @param {Object} [options={}] The options object.
+ * @param {boolean} [options.leading=false]
+ * Specify invoking on the leading edge of the timeout.
+ * @param {number} [options.maxWait]
+ * The maximum time `func` is allowed to be delayed before it's invoked.
+ * @param {boolean} [options.trailing=true]
+ * Specify invoking on the trailing edge of the timeout.
+ * @returns {Function} Returns the new debounced function.
+ * @example
+ *
+ * // Avoid costly calculations while the window size is in flux.
+ * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
+ *
+ * // Invoke `sendMail` when clicked, debouncing subsequent calls.
+ * jQuery(element).on('click', _.debounce(sendMail, 300, {
+ * 'leading': true,
+ * 'trailing': false
+ * }));
+ *
+ * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+ * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
+ * var source = new EventSource('/stream');
+ * jQuery(source).on('message', debounced);
+ *
+ * // Cancel the trailing debounced invocation.
+ * jQuery(window).on('popstate', debounced.cancel);
+ */
+ function debounce(func, wait, options) {
+ var lastArgs,
+ lastThis,
+ maxWait,
+ result,
+ timerId,
+ lastCallTime,
+ lastInvokeTime = 0,
+ leading = false,
+ maxing = false,
+ trailing = true;
+
+ if (typeof func != 'function') {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ wait = toNumber(wait) || 0;
+ if (isObject(options)) {
+ leading = !!options.leading;
+ maxing = 'maxWait' in options;
+ maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+ trailing = 'trailing' in options ? !!options.trailing : trailing;
+ }
+
+ function invokeFunc(time) {
+ var args = lastArgs,
+ thisArg = lastThis;
+
+ lastArgs = lastThis = undefined$1;
+ lastInvokeTime = time;
+ result = func.apply(thisArg, args);
+ return result;
+ }
+
+ function leadingEdge(time) {
+ // Reset any `maxWait` timer.
+ lastInvokeTime = time;
+ // Start the timer for the trailing edge.
+ timerId = setTimeout(timerExpired, wait);
+ // Invoke the leading edge.
+ return leading ? invokeFunc(time) : result;
+ }
+
+ function remainingWait(time) {
+ var timeSinceLastCall = time - lastCallTime,
+ timeSinceLastInvoke = time - lastInvokeTime,
+ timeWaiting = wait - timeSinceLastCall;
+
+ return maxing
+ ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
+ : timeWaiting;
+ }
+
+ function shouldInvoke(time) {
+ var timeSinceLastCall = time - lastCallTime,
+ timeSinceLastInvoke = time - lastInvokeTime;
+
+ // Either this is the first call, activity has stopped and we're at the
+ // trailing edge, the system time has gone backwards and we're treating
+ // it as the trailing edge, or we've hit the `maxWait` limit.
+ return (lastCallTime === undefined$1 || (timeSinceLastCall >= wait) ||
+ (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
+ }
+
+ function timerExpired() {
+ var time = now();
+ if (shouldInvoke(time)) {
+ return trailingEdge(time);
+ }
+ // Restart the timer.
+ timerId = setTimeout(timerExpired, remainingWait(time));
+ }
+
+ function trailingEdge(time) {
+ timerId = undefined$1;
+
+ // Only invoke if we have `lastArgs` which means `func` has been
+ // debounced at least once.
+ if (trailing && lastArgs) {
+ return invokeFunc(time);
+ }
+ lastArgs = lastThis = undefined$1;
+ return result;
+ }
+
+ function cancel() {
+ if (timerId !== undefined$1) {
+ clearTimeout(timerId);
+ }
+ lastInvokeTime = 0;
+ lastArgs = lastCallTime = lastThis = timerId = undefined$1;
+ }
+
+ function flush() {
+ return timerId === undefined$1 ? result : trailingEdge(now());
+ }
+
+ function debounced() {
+ var time = now(),
+ isInvoking = shouldInvoke(time);
+
+ lastArgs = arguments;
+ lastThis = this;
+ lastCallTime = time;
+
+ if (isInvoking) {
+ if (timerId === undefined$1) {
+ return leadingEdge(lastCallTime);
+ }
+ if (maxing) {
+ // Handle invocations in a tight loop.
+ clearTimeout(timerId);
+ timerId = setTimeout(timerExpired, wait);
+ return invokeFunc(lastCallTime);
+ }
+ }
+ if (timerId === undefined$1) {
+ timerId = setTimeout(timerExpired, wait);
+ }
+ return result;
+ }
+ debounced.cancel = cancel;
+ debounced.flush = flush;
+ return debounced;
+ }
+
+ /**
+ * Defers invoking the `func` until the current call stack has cleared. Any
+ * additional arguments are provided to `func` when it's invoked.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to defer.
+ * @param {...*} [args] The arguments to invoke `func` with.
+ * @returns {number} Returns the timer id.
+ * @example
+ *
+ * _.defer(function(text) {
+ * console.log(text);
+ * }, 'deferred');
+ * // => Logs 'deferred' after one millisecond.
+ */
+ var defer = baseRest(function(func, args) {
+ return baseDelay(func, 1, args);
+ });
+
+ /**
+ * Invokes `func` after `wait` milliseconds. Any additional arguments are
+ * provided to `func` when it's invoked.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to delay.
+ * @param {number} wait The number of milliseconds to delay invocation.
+ * @param {...*} [args] The arguments to invoke `func` with.
+ * @returns {number} Returns the timer id.
+ * @example
+ *
+ * _.delay(function(text) {
+ * console.log(text);
+ * }, 1000, 'later');
+ * // => Logs 'later' after one second.
+ */
+ var delay = baseRest(function(func, wait, args) {
+ return baseDelay(func, toNumber(wait) || 0, args);
+ });
+
+ /**
+ * Creates a function that invokes `func` with arguments reversed.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Function
+ * @param {Function} func The function to flip arguments for.
+ * @returns {Function} Returns the new flipped function.
+ * @example
+ *
+ * var flipped = _.flip(function() {
+ * return _.toArray(arguments);
+ * });
+ *
+ * flipped('a', 'b', 'c', 'd');
+ * // => ['d', 'c', 'b', 'a']
+ */
+ function flip(func) {
+ return createWrap(func, WRAP_FLIP_FLAG);
+ }
+
+ /**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is used as the map cache key. The `func`
+ * is invoked with the `this` binding of the memoized function.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `_.memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `clear`, `delete`, `get`, `has`, and `set`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @returns {Function} Returns the new memoized function.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ * var other = { 'c': 3, 'd': 4 };
+ *
+ * var values = _.memoize(_.values);
+ * values(object);
+ * // => [1, 2]
+ *
+ * values(other);
+ * // => [3, 4]
+ *
+ * object.a = 2;
+ * values(object);
+ * // => [1, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b']);
+ * values(object);
+ * // => ['a', 'b']
+ *
+ * // Replace `_.memoize.Cache`.
+ * _.memoize.Cache = WeakMap;
+ */
+ function memoize(func, resolver) {
+ if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ var memoized = function() {
+ var args = arguments,
+ key = resolver ? resolver.apply(this, args) : args[0],
+ cache = memoized.cache;
+
+ if (cache.has(key)) {
+ return cache.get(key);
+ }
+ var result = func.apply(this, args);
+ memoized.cache = cache.set(key, result) || cache;
+ return result;
+ };
+ memoized.cache = new (memoize.Cache || MapCache);
+ return memoized;
+ }
+
+ // Expose `MapCache`.
+ memoize.Cache = MapCache;
+
+ /**
+ * Creates a function that negates the result of the predicate `func`. The
+ * `func` predicate is invoked with the `this` binding and arguments of the
+ * created function.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Function
+ * @param {Function} predicate The predicate to negate.
+ * @returns {Function} Returns the new negated function.
+ * @example
+ *
+ * function isEven(n) {
+ * return n % 2 == 0;
+ * }
+ *
+ * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
+ * // => [1, 3, 5]
+ */
+ function negate(predicate) {
+ if (typeof predicate != 'function') {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ return function() {
+ var args = arguments;
+ switch (args.length) {
+ case 0: return !predicate.call(this);
+ case 1: return !predicate.call(this, args[0]);
+ case 2: return !predicate.call(this, args[0], args[1]);
+ case 3: return !predicate.call(this, args[0], args[1], args[2]);
+ }
+ return !predicate.apply(this, args);
+ };
+ }
+
+ /**
+ * Creates a function that is restricted to invoking `func` once. Repeat calls
+ * to the function return the value of the first invocation. The `func` is
+ * invoked with the `this` binding and arguments of the created function.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * var initialize = _.once(createApplication);
+ * initialize();
+ * initialize();
+ * // => `createApplication` is invoked once
+ */
+ function once(func) {
+ return before(2, func);
+ }
+
+ /**
+ * Creates a function that invokes `func` with its arguments transformed.
+ *
+ * @static
+ * @since 4.0.0
+ * @memberOf _
+ * @category Function
+ * @param {Function} func The function to wrap.
+ * @param {...(Function|Function[])} [transforms=[_.identity]]
+ * The argument transforms.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * function doubled(n) {
+ * return n * 2;
+ * }
+ *
+ * function square(n) {
+ * return n * n;
+ * }
+ *
+ * var func = _.overArgs(function(x, y) {
+ * return [x, y];
+ * }, [square, doubled]);
+ *
+ * func(9, 3);
+ * // => [81, 6]
+ *
+ * func(10, 5);
+ * // => [100, 10]
+ */
+ var overArgs = castRest(function(func, transforms) {
+ transforms = (transforms.length == 1 && isArray(transforms[0]))
+ ? arrayMap(transforms[0], baseUnary(getIteratee()))
+ : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));
+
+ var funcsLength = transforms.length;
+ return baseRest(function(args) {
+ var index = -1,
+ length = nativeMin(args.length, funcsLength);
+
+ while (++index < length) {
+ args[index] = transforms[index].call(this, args[index]);
+ }
+ return apply(func, this, args);
+ });
+ });
+
+ /**
+ * Creates a function that invokes `func` with `partials` prepended to the
+ * arguments it receives. This method is like `_.bind` except it does **not**
+ * alter the `this` binding.
+ *
+ * The `_.partial.placeholder` value, which defaults to `_` in monolithic
+ * builds, may be used as a placeholder for partially applied arguments.
+ *
+ * **Note:** This method doesn't set the "length" property of partially
+ * applied functions.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.2.0
+ * @category Function
+ * @param {Function} func The function to partially apply arguments to.
+ * @param {...*} [partials] The arguments to be partially applied.
+ * @returns {Function} Returns the new partially applied function.
+ * @example
+ *
+ * function greet(greeting, name) {
+ * return greeting + ' ' + name;
+ * }
+ *
+ * var sayHelloTo = _.partial(greet, 'hello');
+ * sayHelloTo('fred');
+ * // => 'hello fred'
+ *
+ * // Partially applied with placeholders.
+ * var greetFred = _.partial(greet, _, 'fred');
+ * greetFred('hi');
+ * // => 'hi fred'
+ */
+ var partial = baseRest(function(func, partials) {
+ var holders = replaceHolders(partials, getHolder(partial));
+ return createWrap(func, WRAP_PARTIAL_FLAG, undefined$1, partials, holders);
+ });
+
+ /**
+ * This method is like `_.partial` except that partially applied arguments
+ * are appended to the arguments it receives.
+ *
+ * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic
+ * builds, may be used as a placeholder for partially applied arguments.
+ *
+ * **Note:** This method doesn't set the "length" property of partially
+ * applied functions.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.0.0
+ * @category Function
+ * @param {Function} func The function to partially apply arguments to.
+ * @param {...*} [partials] The arguments to be partially applied.
+ * @returns {Function} Returns the new partially applied function.
+ * @example
+ *
+ * function greet(greeting, name) {
+ * return greeting + ' ' + name;
+ * }
+ *
+ * var greetFred = _.partialRight(greet, 'fred');
+ * greetFred('hi');
+ * // => 'hi fred'
+ *
+ * // Partially applied with placeholders.
+ * var sayHelloTo = _.partialRight(greet, 'hello', _);
+ * sayHelloTo('fred');
+ * // => 'hello fred'
+ */
+ var partialRight = baseRest(function(func, partials) {
+ var holders = replaceHolders(partials, getHolder(partialRight));
+ return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined$1, partials, holders);
+ });
+
+ /**
+ * Creates a function that invokes `func` with arguments arranged according
+ * to the specified `indexes` where the argument value at the first index is
+ * provided as the first argument, the argument value at the second index is
+ * provided as the second argument, and so on.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Function
+ * @param {Function} func The function to rearrange arguments for.
+ * @param {...(number|number[])} indexes The arranged argument indexes.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var rearged = _.rearg(function(a, b, c) {
+ * return [a, b, c];
+ * }, [2, 0, 1]);
+ *
+ * rearged('b', 'c', 'a')
+ * // => ['a', 'b', 'c']
+ */
+ var rearg = flatRest(function(func, indexes) {
+ return createWrap(func, WRAP_REARG_FLAG, undefined$1, undefined$1, undefined$1, indexes);
+ });
+
+ /**
+ * Creates a function that invokes `func` with the `this` binding of the
+ * created function and arguments from `start` and beyond provided as
+ * an array.
+ *
+ * **Note:** This method is based on the
+ * [rest parameter](https://mdn.io/rest_parameters).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Function
+ * @param {Function} func The function to apply a rest parameter to.
+ * @param {number} [start=func.length-1] The start position of the rest parameter.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var say = _.rest(function(what, names) {
+ * return what + ' ' + _.initial(names).join(', ') +
+ * (_.size(names) > 1 ? ', & ' : '') + _.last(names);
+ * });
+ *
+ * say('hello', 'fred', 'barney', 'pebbles');
+ * // => 'hello fred, barney, & pebbles'
+ */
+ function rest(func, start) {
+ if (typeof func != 'function') {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ start = start === undefined$1 ? start : toInteger(start);
+ return baseRest(func, start);
+ }
+
+ /**
+ * Creates a function that invokes `func` with the `this` binding of the
+ * create function and an array of arguments much like
+ * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).
+ *
+ * **Note:** This method is based on the
+ * [spread operator](https://mdn.io/spread_operator).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.2.0
+ * @category Function
+ * @param {Function} func The function to spread arguments over.
+ * @param {number} [start=0] The start position of the spread.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var say = _.spread(function(who, what) {
+ * return who + ' says ' + what;
+ * });
+ *
+ * say(['fred', 'hello']);
+ * // => 'fred says hello'
+ *
+ * var numbers = Promise.all([
+ * Promise.resolve(40),
+ * Promise.resolve(36)
+ * ]);
+ *
+ * numbers.then(_.spread(function(x, y) {
+ * return x + y;
+ * }));
+ * // => a Promise of 76
+ */
+ function spread(func, start) {
+ if (typeof func != 'function') {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ start = start == null ? 0 : nativeMax(toInteger(start), 0);
+ return baseRest(function(args) {
+ var array = args[start],
+ otherArgs = castSlice(args, 0, start);
+
+ if (array) {
+ arrayPush(otherArgs, array);
+ }
+ return apply(func, this, otherArgs);
+ });
+ }
+
+ /**
+ * Creates a throttled function that only invokes `func` at most once per
+ * every `wait` milliseconds. The throttled function comes with a `cancel`
+ * method to cancel delayed `func` invocations and a `flush` method to
+ * immediately invoke them. Provide `options` to indicate whether `func`
+ * should be invoked on the leading and/or trailing edge of the `wait`
+ * timeout. The `func` is invoked with the last arguments provided to the
+ * throttled function. Subsequent calls to the throttled function return the
+ * result of the last `func` invocation.
+ *
+ * **Note:** If `leading` and `trailing` options are `true`, `func` is
+ * invoked on the trailing edge of the timeout only if the throttled function
+ * is invoked more than once during the `wait` timeout.
+ *
+ * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+ * until to the next tick, similar to `setTimeout` with a timeout of `0`.
+ *
+ * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+ * for details over the differences between `_.throttle` and `_.debounce`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to throttle.
+ * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
+ * @param {Object} [options={}] The options object.
+ * @param {boolean} [options.leading=true]
+ * Specify invoking on the leading edge of the timeout.
+ * @param {boolean} [options.trailing=true]
+ * Specify invoking on the trailing edge of the timeout.
+ * @returns {Function} Returns the new throttled function.
+ * @example
+ *
+ * // Avoid excessively updating the position while scrolling.
+ * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
+ *
+ * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
+ * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
+ * jQuery(element).on('click', throttled);
+ *
+ * // Cancel the trailing throttled invocation.
+ * jQuery(window).on('popstate', throttled.cancel);
+ */
+ function throttle(func, wait, options) {
+ var leading = true,
+ trailing = true;
+
+ if (typeof func != 'function') {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ if (isObject(options)) {
+ leading = 'leading' in options ? !!options.leading : leading;
+ trailing = 'trailing' in options ? !!options.trailing : trailing;
+ }
+ return debounce(func, wait, {
+ 'leading': leading,
+ 'maxWait': wait,
+ 'trailing': trailing
+ });
+ }
+
+ /**
+ * Creates a function that accepts up to one argument, ignoring any
+ * additional arguments.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Function
+ * @param {Function} func The function to cap arguments for.
+ * @returns {Function} Returns the new capped function.
+ * @example
+ *
+ * _.map(['6', '8', '10'], _.unary(parseInt));
+ * // => [6, 8, 10]
+ */
+ function unary(func) {
+ return ary(func, 1);
+ }
+
+ /**
+ * Creates a function that provides `value` to `wrapper` as its first
+ * argument. Any additional arguments provided to the function are appended
+ * to those provided to the `wrapper`. The wrapper is invoked with the `this`
+ * binding of the created function.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {*} value The value to wrap.
+ * @param {Function} [wrapper=identity] The wrapper function.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var p = _.wrap(_.escape, function(func, text) {
+ * return '' + func(text) + '
';
+ * });
+ *
+ * p('fred, barney, & pebbles');
+ * // => 'fred, barney, & pebbles
'
+ */
+ function wrap(value, wrapper) {
+ return partial(castFunction(wrapper), value);
+ }
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Casts `value` as an array if it's not one.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.4.0
+ * @category Lang
+ * @param {*} value The value to inspect.
+ * @returns {Array} Returns the cast array.
+ * @example
+ *
+ * _.castArray(1);
+ * // => [1]
+ *
+ * _.castArray({ 'a': 1 });
+ * // => [{ 'a': 1 }]
+ *
+ * _.castArray('abc');
+ * // => ['abc']
+ *
+ * _.castArray(null);
+ * // => [null]
+ *
+ * _.castArray(undefined);
+ * // => [undefined]
+ *
+ * _.castArray();
+ * // => []
+ *
+ * var array = [1, 2, 3];
+ * console.log(_.castArray(array) === array);
+ * // => true
+ */
+ function castArray() {
+ if (!arguments.length) {
+ return [];
+ }
+ var value = arguments[0];
+ return isArray(value) ? value : [value];
+ }
+
+ /**
+ * Creates a shallow clone of `value`.
+ *
+ * **Note:** This method is loosely based on the
+ * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
+ * and supports cloning arrays, array buffers, booleans, date objects, maps,
+ * numbers, `Object` objects, regexes, sets, strings, symbols, and typed
+ * arrays. The own enumerable properties of `arguments` objects are cloned
+ * as plain objects. An empty object is returned for uncloneable values such
+ * as error objects, functions, DOM nodes, and WeakMaps.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to clone.
+ * @returns {*} Returns the cloned value.
+ * @see _.cloneDeep
+ * @example
+ *
+ * var objects = [{ 'a': 1 }, { 'b': 2 }];
+ *
+ * var shallow = _.clone(objects);
+ * console.log(shallow[0] === objects[0]);
+ * // => true
+ */
+ function clone(value) {
+ return baseClone(value, CLONE_SYMBOLS_FLAG);
+ }
+
+ /**
+ * This method is like `_.clone` except that it accepts `customizer` which
+ * is invoked to produce the cloned value. If `customizer` returns `undefined`,
+ * cloning is handled by the method instead. The `customizer` is invoked with
+ * up to four arguments; (value [, index|key, object, stack]).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to clone.
+ * @param {Function} [customizer] The function to customize cloning.
+ * @returns {*} Returns the cloned value.
+ * @see _.cloneDeepWith
+ * @example
+ *
+ * function customizer(value) {
+ * if (_.isElement(value)) {
+ * return value.cloneNode(false);
+ * }
+ * }
+ *
+ * var el = _.cloneWith(document.body, customizer);
+ *
+ * console.log(el === document.body);
+ * // => false
+ * console.log(el.nodeName);
+ * // => 'BODY'
+ * console.log(el.childNodes.length);
+ * // => 0
+ */
+ function cloneWith(value, customizer) {
+ customizer = typeof customizer == 'function' ? customizer : undefined$1;
+ return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
+ }
+
+ /**
+ * This method is like `_.clone` except that it recursively clones `value`.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.0.0
+ * @category Lang
+ * @param {*} value The value to recursively clone.
+ * @returns {*} Returns the deep cloned value.
+ * @see _.clone
+ * @example
+ *
+ * var objects = [{ 'a': 1 }, { 'b': 2 }];
+ *
+ * var deep = _.cloneDeep(objects);
+ * console.log(deep[0] === objects[0]);
+ * // => false
+ */
+ function cloneDeep(value) {
+ return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
+ }
+
+ /**
+ * This method is like `_.cloneWith` except that it recursively clones `value`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to recursively clone.
+ * @param {Function} [customizer] The function to customize cloning.
+ * @returns {*} Returns the deep cloned value.
+ * @see _.cloneWith
+ * @example
+ *
+ * function customizer(value) {
+ * if (_.isElement(value)) {
+ * return value.cloneNode(true);
+ * }
+ * }
+ *
+ * var el = _.cloneDeepWith(document.body, customizer);
+ *
+ * console.log(el === document.body);
+ * // => false
+ * console.log(el.nodeName);
+ * // => 'BODY'
+ * console.log(el.childNodes.length);
+ * // => 20
+ */
+ function cloneDeepWith(value, customizer) {
+ customizer = typeof customizer == 'function' ? customizer : undefined$1;
+ return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
+ }
+
+ /**
+ * Checks if `object` conforms to `source` by invoking the predicate
+ * properties of `source` with the corresponding property values of `object`.
+ *
+ * **Note:** This method is equivalent to `_.conforms` when `source` is
+ * partially applied.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.14.0
+ * @category Lang
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property predicates to conform to.
+ * @returns {boolean} Returns `true` if `object` conforms, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ *
+ * _.conformsTo(object, { 'b': function(n) { return n > 1; } });
+ * // => true
+ *
+ * _.conformsTo(object, { 'b': function(n) { return n > 2; } });
+ * // => false
+ */
+ function conformsTo(object, source) {
+ return source == null || baseConformsTo(object, source, keys(source));
+ }
+
+ /**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+ function eq(value, other) {
+ return value === other || (value !== value && other !== other);
+ }
+
+ /**
+ * Checks if `value` is greater than `other`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.9.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if `value` is greater than `other`,
+ * else `false`.
+ * @see _.lt
+ * @example
+ *
+ * _.gt(3, 1);
+ * // => true
+ *
+ * _.gt(3, 3);
+ * // => false
+ *
+ * _.gt(1, 3);
+ * // => false
+ */
+ var gt = createRelationalOperation(baseGt);
+
+ /**
+ * Checks if `value` is greater than or equal to `other`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.9.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if `value` is greater than or equal to
+ * `other`, else `false`.
+ * @see _.lte
+ * @example
+ *
+ * _.gte(3, 1);
+ * // => true
+ *
+ * _.gte(3, 3);
+ * // => true
+ *
+ * _.gte(1, 3);
+ * // => false
+ */
+ var gte = createRelationalOperation(function(value, other) {
+ return value >= other;
+ });
+
+ /**
+ * Checks if `value` is likely an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ * else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+ var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
+ return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
+ !propertyIsEnumerable.call(value, 'callee');
+ };
+
+ /**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+ var isArray = Array.isArray;
+
+ /**
+ * Checks if `value` is classified as an `ArrayBuffer` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
+ * @example
+ *
+ * _.isArrayBuffer(new ArrayBuffer(2));
+ * // => true
+ *
+ * _.isArrayBuffer(new Array(2));
+ * // => false
+ */
+ var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;
+
+ /**
+ * Checks if `value` is array-like. A value is considered array-like if it's
+ * not a function and has a `value.length` that's an integer greater than or
+ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ * @example
+ *
+ * _.isArrayLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLike(document.body.children);
+ * // => true
+ *
+ * _.isArrayLike('abc');
+ * // => true
+ *
+ * _.isArrayLike(_.noop);
+ * // => false
+ */
+ function isArrayLike(value) {
+ return value != null && isLength(value.length) && !isFunction(value);
+ }
+
+ /**
+ * This method is like `_.isArrayLike` except that it also checks if `value`
+ * is an object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array-like object,
+ * else `false`.
+ * @example
+ *
+ * _.isArrayLikeObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLikeObject(document.body.children);
+ * // => true
+ *
+ * _.isArrayLikeObject('abc');
+ * // => false
+ *
+ * _.isArrayLikeObject(_.noop);
+ * // => false
+ */
+ function isArrayLikeObject(value) {
+ return isObjectLike(value) && isArrayLike(value);
+ }
+
+ /**
+ * Checks if `value` is classified as a boolean primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.
+ * @example
+ *
+ * _.isBoolean(false);
+ * // => true
+ *
+ * _.isBoolean(null);
+ * // => false
+ */
+ function isBoolean(value) {
+ return value === true || value === false ||
+ (isObjectLike(value) && baseGetTag(value) == boolTag);
+ }
+
+ /**
+ * Checks if `value` is a buffer.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+ * @example
+ *
+ * _.isBuffer(new Buffer(2));
+ * // => true
+ *
+ * _.isBuffer(new Uint8Array(2));
+ * // => false
+ */
+ var isBuffer = nativeIsBuffer || stubFalse;
+
+ /**
+ * Checks if `value` is classified as a `Date` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
+ * @example
+ *
+ * _.isDate(new Date);
+ * // => true
+ *
+ * _.isDate('Mon April 23 2012');
+ * // => false
+ */
+ var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;
+
+ /**
+ * Checks if `value` is likely a DOM element.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
+ * @example
+ *
+ * _.isElement(document.body);
+ * // => true
+ *
+ * _.isElement('');
+ * // => false
+ */
+ function isElement(value) {
+ return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
+ }
+
+ /**
+ * Checks if `value` is an empty object, collection, map, or set.
+ *
+ * Objects are considered empty if they have no own enumerable string keyed
+ * properties.
+ *
+ * Array-like values such as `arguments` objects, arrays, buffers, strings, or
+ * jQuery-like collections are considered empty if they have a `length` of `0`.
+ * Similarly, maps and sets are considered empty if they have a `size` of `0`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is empty, else `false`.
+ * @example
+ *
+ * _.isEmpty(null);
+ * // => true
+ *
+ * _.isEmpty(true);
+ * // => true
+ *
+ * _.isEmpty(1);
+ * // => true
+ *
+ * _.isEmpty([1, 2, 3]);
+ * // => false
+ *
+ * _.isEmpty({ 'a': 1 });
+ * // => false
+ */
+ function isEmpty(value) {
+ if (value == null) {
+ return true;
+ }
+ if (isArrayLike(value) &&
+ (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||
+ isBuffer(value) || isTypedArray(value) || isArguments(value))) {
+ return !value.length;
+ }
+ var tag = getTag(value);
+ if (tag == mapTag || tag == setTag) {
+ return !value.size;
+ }
+ if (isPrototype(value)) {
+ return !baseKeys(value).length;
+ }
+ for (var key in value) {
+ if (hasOwnProperty.call(value, key)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Performs a deep comparison between two values to determine if they are
+ * equivalent.
+ *
+ * **Note:** This method supports comparing arrays, array buffers, booleans,
+ * date objects, error objects, maps, numbers, `Object` objects, regexes,
+ * sets, strings, symbols, and typed arrays. `Object` objects are compared
+ * by their own, not inherited, enumerable properties. Functions and DOM
+ * nodes are compared by strict equality, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.isEqual(object, other);
+ * // => true
+ *
+ * object === other;
+ * // => false
+ */
+ function isEqual(value, other) {
+ return baseIsEqual(value, other);
+ }
+
+ /**
+ * This method is like `_.isEqual` except that it accepts `customizer` which
+ * is invoked to compare values. If `customizer` returns `undefined`, comparisons
+ * are handled by the method instead. The `customizer` is invoked with up to
+ * six arguments: (objValue, othValue [, index|key, object, other, stack]).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * function isGreeting(value) {
+ * return /^h(?:i|ello)$/.test(value);
+ * }
+ *
+ * function customizer(objValue, othValue) {
+ * if (isGreeting(objValue) && isGreeting(othValue)) {
+ * return true;
+ * }
+ * }
+ *
+ * var array = ['hello', 'goodbye'];
+ * var other = ['hi', 'goodbye'];
+ *
+ * _.isEqualWith(array, other, customizer);
+ * // => true
+ */
+ function isEqualWith(value, other, customizer) {
+ customizer = typeof customizer == 'function' ? customizer : undefined$1;
+ var result = customizer ? customizer(value, other) : undefined$1;
+ return result === undefined$1 ? baseIsEqual(value, other, undefined$1, customizer) : !!result;
+ }
+
+ /**
+ * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,
+ * `SyntaxError`, `TypeError`, or `URIError` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an error object, else `false`.
+ * @example
+ *
+ * _.isError(new Error);
+ * // => true
+ *
+ * _.isError(Error);
+ * // => false
+ */
+ function isError(value) {
+ if (!isObjectLike(value)) {
+ return false;
+ }
+ var tag = baseGetTag(value);
+ return tag == errorTag || tag == domExcTag ||
+ (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));
+ }
+
+ /**
+ * Checks if `value` is a finite primitive number.
+ *
+ * **Note:** This method is based on
+ * [`Number.isFinite`](https://mdn.io/Number/isFinite).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.
+ * @example
+ *
+ * _.isFinite(3);
+ * // => true
+ *
+ * _.isFinite(Number.MIN_VALUE);
+ * // => true
+ *
+ * _.isFinite(Infinity);
+ * // => false
+ *
+ * _.isFinite('3');
+ * // => false
+ */
+ function isFinite(value) {
+ return typeof value == 'number' && nativeIsFinite(value);
+ }
+
+ /**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+ function isFunction(value) {
+ if (!isObject(value)) {
+ return false;
+ }
+ // The use of `Object#toString` avoids issues with the `typeof` operator
+ // in Safari 9 which returns 'object' for typed arrays and other constructors.
+ var tag = baseGetTag(value);
+ return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+ }
+
+ /**
+ * Checks if `value` is an integer.
+ *
+ * **Note:** This method is based on
+ * [`Number.isInteger`](https://mdn.io/Number/isInteger).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an integer, else `false`.
+ * @example
+ *
+ * _.isInteger(3);
+ * // => true
+ *
+ * _.isInteger(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isInteger(Infinity);
+ * // => false
+ *
+ * _.isInteger('3');
+ * // => false
+ */
+ function isInteger(value) {
+ return typeof value == 'number' && value == toInteger(value);
+ }
+
+ /**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ * @example
+ *
+ * _.isLength(3);
+ * // => true
+ *
+ * _.isLength(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isLength(Infinity);
+ * // => false
+ *
+ * _.isLength('3');
+ * // => false
+ */
+ function isLength(value) {
+ return typeof value == 'number' &&
+ value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+ }
+
+ /**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+ function isObject(value) {
+ var type = typeof value;
+ return value != null && (type == 'object' || type == 'function');
+ }
+
+ /**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+ function isObjectLike(value) {
+ return value != null && typeof value == 'object';
+ }
+
+ /**
+ * Checks if `value` is classified as a `Map` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+ * @example
+ *
+ * _.isMap(new Map);
+ * // => true
+ *
+ * _.isMap(new WeakMap);
+ * // => false
+ */
+ var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
+
+ /**
+ * Performs a partial deep comparison between `object` and `source` to
+ * determine if `object` contains equivalent property values.
+ *
+ * **Note:** This method is equivalent to `_.matches` when `source` is
+ * partially applied.
+ *
+ * Partial comparisons will match empty array and empty object `source`
+ * values against any array or object value, respectively. See `_.isEqual`
+ * for a list of supported value comparisons.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property values to match.
+ * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ *
+ * _.isMatch(object, { 'b': 2 });
+ * // => true
+ *
+ * _.isMatch(object, { 'b': 1 });
+ * // => false
+ */
+ function isMatch(object, source) {
+ return object === source || baseIsMatch(object, source, getMatchData(source));
+ }
+
+ /**
+ * This method is like `_.isMatch` except that it accepts `customizer` which
+ * is invoked to compare values. If `customizer` returns `undefined`, comparisons
+ * are handled by the method instead. The `customizer` is invoked with five
+ * arguments: (objValue, srcValue, index|key, object, source).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property values to match.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+ * @example
+ *
+ * function isGreeting(value) {
+ * return /^h(?:i|ello)$/.test(value);
+ * }
+ *
+ * function customizer(objValue, srcValue) {
+ * if (isGreeting(objValue) && isGreeting(srcValue)) {
+ * return true;
+ * }
+ * }
+ *
+ * var object = { 'greeting': 'hello' };
+ * var source = { 'greeting': 'hi' };
+ *
+ * _.isMatchWith(object, source, customizer);
+ * // => true
+ */
+ function isMatchWith(object, source, customizer) {
+ customizer = typeof customizer == 'function' ? customizer : undefined$1;
+ return baseIsMatch(object, source, getMatchData(source), customizer);
+ }
+
+ /**
+ * Checks if `value` is `NaN`.
+ *
+ * **Note:** This method is based on
+ * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as
+ * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for
+ * `undefined` and other non-number values.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
+ * @example
+ *
+ * _.isNaN(NaN);
+ * // => true
+ *
+ * _.isNaN(new Number(NaN));
+ * // => true
+ *
+ * isNaN(undefined);
+ * // => true
+ *
+ * _.isNaN(undefined);
+ * // => false
+ */
+ function isNaN(value) {
+ // An `NaN` primitive is the only value that is not equal to itself.
+ // Perform the `toStringTag` check first to avoid errors with some
+ // ActiveX objects in IE.
+ return isNumber(value) && value != +value;
+ }
+
+ /**
+ * Checks if `value` is a pristine native function.
+ *
+ * **Note:** This method can't reliably detect native functions in the presence
+ * of the core-js package because core-js circumvents this kind of detection.
+ * Despite multiple requests, the core-js maintainer has made it clear: any
+ * attempt to fix the detection will be obstructed. As a result, we're left
+ * with little choice but to throw an error. Unfortunately, this also affects
+ * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),
+ * which rely on core-js.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ * else `false`.
+ * @example
+ *
+ * _.isNative(Array.prototype.push);
+ * // => true
+ *
+ * _.isNative(_);
+ * // => false
+ */
+ function isNative(value) {
+ if (isMaskable(value)) {
+ throw new Error(CORE_ERROR_TEXT);
+ }
+ return baseIsNative(value);
+ }
+
+ /**
+ * Checks if `value` is `null`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is `null`, else `false`.
+ * @example
+ *
+ * _.isNull(null);
+ * // => true
+ *
+ * _.isNull(void 0);
+ * // => false
+ */
+ function isNull(value) {
+ return value === null;
+ }
+
+ /**
+ * Checks if `value` is `null` or `undefined`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is nullish, else `false`.
+ * @example
+ *
+ * _.isNil(null);
+ * // => true
+ *
+ * _.isNil(void 0);
+ * // => true
+ *
+ * _.isNil(NaN);
+ * // => false
+ */
+ function isNil(value) {
+ return value == null;
+ }
+
+ /**
+ * Checks if `value` is classified as a `Number` primitive or object.
+ *
+ * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are
+ * classified as numbers, use the `_.isFinite` method.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a number, else `false`.
+ * @example
+ *
+ * _.isNumber(3);
+ * // => true
+ *
+ * _.isNumber(Number.MIN_VALUE);
+ * // => true
+ *
+ * _.isNumber(Infinity);
+ * // => true
+ *
+ * _.isNumber('3');
+ * // => false
+ */
+ function isNumber(value) {
+ return typeof value == 'number' ||
+ (isObjectLike(value) && baseGetTag(value) == numberTag);
+ }
+
+ /**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * `Object` constructor or one with a `[[Prototype]]` of `null`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.8.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * }
+ *
+ * _.isPlainObject(new Foo);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ *
+ * _.isPlainObject(Object.create(null));
+ * // => true
+ */
+ function isPlainObject(value) {
+ if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
+ return false;
+ }
+ var proto = getPrototype(value);
+ if (proto === null) {
+ return true;
+ }
+ var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+ return typeof Ctor == 'function' && Ctor instanceof Ctor &&
+ funcToString.call(Ctor) == objectCtorString;
+ }
+
+ /**
+ * Checks if `value` is classified as a `RegExp` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
+ * @example
+ *
+ * _.isRegExp(/abc/);
+ * // => true
+ *
+ * _.isRegExp('/abc/');
+ * // => false
+ */
+ var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;
+
+ /**
+ * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754
+ * double precision number which isn't the result of a rounded unsafe integer.
+ *
+ * **Note:** This method is based on
+ * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.
+ * @example
+ *
+ * _.isSafeInteger(3);
+ * // => true
+ *
+ * _.isSafeInteger(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isSafeInteger(Infinity);
+ * // => false
+ *
+ * _.isSafeInteger('3');
+ * // => false
+ */
+ function isSafeInteger(value) {
+ return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
+ }
+
+ /**
+ * Checks if `value` is classified as a `Set` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+ * @example
+ *
+ * _.isSet(new Set);
+ * // => true
+ *
+ * _.isSet(new WeakSet);
+ * // => false
+ */
+ var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
+
+ /**
+ * Checks if `value` is classified as a `String` primitive or object.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a string, else `false`.
+ * @example
+ *
+ * _.isString('abc');
+ * // => true
+ *
+ * _.isString(1);
+ * // => false
+ */
+ function isString(value) {
+ return typeof value == 'string' ||
+ (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);
+ }
+
+ /**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+ function isSymbol(value) {
+ return typeof value == 'symbol' ||
+ (isObjectLike(value) && baseGetTag(value) == symbolTag);
+ }
+
+ /**
+ * Checks if `value` is classified as a typed array.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ * @example
+ *
+ * _.isTypedArray(new Uint8Array);
+ * // => true
+ *
+ * _.isTypedArray([]);
+ * // => false
+ */
+ var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+ /**
+ * Checks if `value` is `undefined`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
+ * @example
+ *
+ * _.isUndefined(void 0);
+ * // => true
+ *
+ * _.isUndefined(null);
+ * // => false
+ */
+ function isUndefined(value) {
+ return value === undefined$1;
+ }
+
+ /**
+ * Checks if `value` is classified as a `WeakMap` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.
+ * @example
+ *
+ * _.isWeakMap(new WeakMap);
+ * // => true
+ *
+ * _.isWeakMap(new Map);
+ * // => false
+ */
+ function isWeakMap(value) {
+ return isObjectLike(value) && getTag(value) == weakMapTag;
+ }
+
+ /**
+ * Checks if `value` is classified as a `WeakSet` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.
+ * @example
+ *
+ * _.isWeakSet(new WeakSet);
+ * // => true
+ *
+ * _.isWeakSet(new Set);
+ * // => false
+ */
+ function isWeakSet(value) {
+ return isObjectLike(value) && baseGetTag(value) == weakSetTag;
+ }
+
+ /**
+ * Checks if `value` is less than `other`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.9.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if `value` is less than `other`,
+ * else `false`.
+ * @see _.gt
+ * @example
+ *
+ * _.lt(1, 3);
+ * // => true
+ *
+ * _.lt(3, 3);
+ * // => false
+ *
+ * _.lt(3, 1);
+ * // => false
+ */
+ var lt = createRelationalOperation(baseLt);
+
+ /**
+ * Checks if `value` is less than or equal to `other`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.9.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if `value` is less than or equal to
+ * `other`, else `false`.
+ * @see _.gte
+ * @example
+ *
+ * _.lte(1, 3);
+ * // => true
+ *
+ * _.lte(3, 3);
+ * // => true
+ *
+ * _.lte(3, 1);
+ * // => false
+ */
+ var lte = createRelationalOperation(function(value, other) {
+ return value <= other;
+ });
+
+ /**
+ * Converts `value` to an array.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {Array} Returns the converted array.
+ * @example
+ *
+ * _.toArray({ 'a': 1, 'b': 2 });
+ * // => [1, 2]
+ *
+ * _.toArray('abc');
+ * // => ['a', 'b', 'c']
+ *
+ * _.toArray(1);
+ * // => []
+ *
+ * _.toArray(null);
+ * // => []
+ */
+ function toArray(value) {
+ if (!value) {
+ return [];
+ }
+ if (isArrayLike(value)) {
+ return isString(value) ? stringToArray(value) : copyArray(value);
+ }
+ if (symIterator && value[symIterator]) {
+ return iteratorToArray(value[symIterator]());
+ }
+ var tag = getTag(value),
+ func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);
+
+ return func(value);
+ }
+
+ /**
+ * Converts `value` to a finite number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.12.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted number.
+ * @example
+ *
+ * _.toFinite(3.2);
+ * // => 3.2
+ *
+ * _.toFinite(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toFinite(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toFinite('3.2');
+ * // => 3.2
+ */
+ function toFinite(value) {
+ if (!value) {
+ return value === 0 ? value : 0;
+ }
+ value = toNumber(value);
+ if (value === INFINITY || value === -INFINITY) {
+ var sign = (value < 0 ? -1 : 1);
+ return sign * MAX_INTEGER;
+ }
+ return value === value ? value : 0;
+ }
+
+ /**
+ * Converts `value` to an integer.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted integer.
+ * @example
+ *
+ * _.toInteger(3.2);
+ * // => 3
+ *
+ * _.toInteger(Number.MIN_VALUE);
+ * // => 0
+ *
+ * _.toInteger(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toInteger('3.2');
+ * // => 3
+ */
+ function toInteger(value) {
+ var result = toFinite(value),
+ remainder = result % 1;
+
+ return result === result ? (remainder ? result - remainder : result) : 0;
+ }
+
+ /**
+ * Converts `value` to an integer suitable for use as the length of an
+ * array-like object.
+ *
+ * **Note:** This method is based on
+ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted integer.
+ * @example
+ *
+ * _.toLength(3.2);
+ * // => 3
+ *
+ * _.toLength(Number.MIN_VALUE);
+ * // => 0
+ *
+ * _.toLength(Infinity);
+ * // => 4294967295
+ *
+ * _.toLength('3.2');
+ * // => 3
+ */
+ function toLength(value) {
+ return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
+ }
+
+ /**
+ * Converts `value` to a number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ * @example
+ *
+ * _.toNumber(3.2);
+ * // => 3.2
+ *
+ * _.toNumber(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toNumber(Infinity);
+ * // => Infinity
+ *
+ * _.toNumber('3.2');
+ * // => 3.2
+ */
+ function toNumber(value) {
+ if (typeof value == 'number') {
+ return value;
+ }
+ if (isSymbol(value)) {
+ return NAN;
+ }
+ if (isObject(value)) {
+ var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+ value = isObject(other) ? (other + '') : other;
+ }
+ if (typeof value != 'string') {
+ return value === 0 ? value : +value;
+ }
+ value = value.replace(reTrim, '');
+ var isBinary = reIsBinary.test(value);
+ return (isBinary || reIsOctal.test(value))
+ ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+ : (reIsBadHex.test(value) ? NAN : +value);
+ }
+
+ /**
+ * Converts `value` to a plain object flattening inherited enumerable string
+ * keyed properties of `value` to own properties of the plain object.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {Object} Returns the converted plain object.
+ * @example
+ *
+ * function Foo() {
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.assign({ 'a': 1 }, new Foo);
+ * // => { 'a': 1, 'b': 2 }
+ *
+ * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
+ * // => { 'a': 1, 'b': 2, 'c': 3 }
+ */
+ function toPlainObject(value) {
+ return copyObject(value, keysIn(value));
+ }
+
+ /**
+ * Converts `value` to a safe integer. A safe integer can be compared and
+ * represented correctly.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted integer.
+ * @example
+ *
+ * _.toSafeInteger(3.2);
+ * // => 3
+ *
+ * _.toSafeInteger(Number.MIN_VALUE);
+ * // => 0
+ *
+ * _.toSafeInteger(Infinity);
+ * // => 9007199254740991
+ *
+ * _.toSafeInteger('3.2');
+ * // => 3
+ */
+ function toSafeInteger(value) {
+ return value
+ ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)
+ : (value === 0 ? value : 0);
+ }
+
+ /**
+ * Converts `value` to a string. An empty string is returned for `null`
+ * and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */
+ function toString(value) {
+ return value == null ? '' : baseToString(value);
+ }
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Assigns own enumerable string keyed properties of source objects to the
+ * destination object. Source objects are applied from left to right.
+ * Subsequent sources overwrite property assignments of previous sources.
+ *
+ * **Note:** This method mutates `object` and is loosely based on
+ * [`Object.assign`](https://mdn.io/Object/assign).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.10.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @see _.assignIn
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * }
+ *
+ * function Bar() {
+ * this.c = 3;
+ * }
+ *
+ * Foo.prototype.b = 2;
+ * Bar.prototype.d = 4;
+ *
+ * _.assign({ 'a': 0 }, new Foo, new Bar);
+ * // => { 'a': 1, 'c': 3 }
+ */
+ var assign = createAssigner(function(object, source) {
+ if (isPrototype(source) || isArrayLike(source)) {
+ copyObject(source, keys(source), object);
+ return;
+ }
+ for (var key in source) {
+ if (hasOwnProperty.call(source, key)) {
+ assignValue(object, key, source[key]);
+ }
+ }
+ });
+
+ /**
+ * This method is like `_.assign` except that it iterates over own and
+ * inherited source properties.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @alias extend
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @see _.assign
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * }
+ *
+ * function Bar() {
+ * this.c = 3;
+ * }
+ *
+ * Foo.prototype.b = 2;
+ * Bar.prototype.d = 4;
+ *
+ * _.assignIn({ 'a': 0 }, new Foo, new Bar);
+ * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }
+ */
+ var assignIn = createAssigner(function(object, source) {
+ copyObject(source, keysIn(source), object);
+ });
+
+ /**
+ * This method is like `_.assignIn` except that it accepts `customizer`
+ * which is invoked to produce the assigned values. If `customizer` returns
+ * `undefined`, assignment is handled by the method instead. The `customizer`
+ * is invoked with five arguments: (objValue, srcValue, key, object, source).
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @alias extendWith
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} sources The source objects.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @returns {Object} Returns `object`.
+ * @see _.assignWith
+ * @example
+ *
+ * function customizer(objValue, srcValue) {
+ * return _.isUndefined(objValue) ? srcValue : objValue;
+ * }
+ *
+ * var defaults = _.partialRight(_.assignInWith, customizer);
+ *
+ * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
+ * // => { 'a': 1, 'b': 2 }
+ */
+ var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
+ copyObject(source, keysIn(source), object, customizer);
+ });
+
+ /**
+ * This method is like `_.assign` except that it accepts `customizer`
+ * which is invoked to produce the assigned values. If `customizer` returns
+ * `undefined`, assignment is handled by the method instead. The `customizer`
+ * is invoked with five arguments: (objValue, srcValue, key, object, source).
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} sources The source objects.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @returns {Object} Returns `object`.
+ * @see _.assignInWith
+ * @example
+ *
+ * function customizer(objValue, srcValue) {
+ * return _.isUndefined(objValue) ? srcValue : objValue;
+ * }
+ *
+ * var defaults = _.partialRight(_.assignWith, customizer);
+ *
+ * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
+ * // => { 'a': 1, 'b': 2 }
+ */
+ var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
+ copyObject(source, keys(source), object, customizer);
+ });
+
+ /**
+ * Creates an array of values corresponding to `paths` of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.0.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {...(string|string[])} [paths] The property paths to pick.
+ * @returns {Array} Returns the picked values.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
+ *
+ * _.at(object, ['a[0].b.c', 'a[1]']);
+ * // => [3, 4]
+ */
+ var at = flatRest(baseAt);
+
+ /**
+ * Creates an object that inherits from the `prototype` object. If a
+ * `properties` object is given, its own enumerable string keyed properties
+ * are assigned to the created object.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.3.0
+ * @category Object
+ * @param {Object} prototype The object to inherit from.
+ * @param {Object} [properties] The properties to assign to the object.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * function Shape() {
+ * this.x = 0;
+ * this.y = 0;
+ * }
+ *
+ * function Circle() {
+ * Shape.call(this);
+ * }
+ *
+ * Circle.prototype = _.create(Shape.prototype, {
+ * 'constructor': Circle
+ * });
+ *
+ * var circle = new Circle;
+ * circle instanceof Circle;
+ * // => true
+ *
+ * circle instanceof Shape;
+ * // => true
+ */
+ function create(prototype, properties) {
+ var result = baseCreate(prototype);
+ return properties == null ? result : baseAssign(result, properties);
+ }
+
+ /**
+ * Assigns own and inherited enumerable string keyed properties of source
+ * objects to the destination object for all destination properties that
+ * resolve to `undefined`. Source objects are applied from left to right.
+ * Once a property is set, additional values of the same property are ignored.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @see _.defaultsDeep
+ * @example
+ *
+ * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
+ * // => { 'a': 1, 'b': 2 }
+ */
+ var defaults = baseRest(function(object, sources) {
+ object = Object(object);
+
+ var index = -1;
+ var length = sources.length;
+ var guard = length > 2 ? sources[2] : undefined$1;
+
+ if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+ length = 1;
+ }
+
+ while (++index < length) {
+ var source = sources[index];
+ var props = keysIn(source);
+ var propsIndex = -1;
+ var propsLength = props.length;
+
+ while (++propsIndex < propsLength) {
+ var key = props[propsIndex];
+ var value = object[key];
+
+ if (value === undefined$1 ||
+ (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {
+ object[key] = source[key];
+ }
+ }
+ }
+
+ return object;
+ });
+
+ /**
+ * This method is like `_.defaults` except that it recursively assigns
+ * default properties.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.10.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @see _.defaults
+ * @example
+ *
+ * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });
+ * // => { 'a': { 'b': 2, 'c': 3 } }
+ */
+ var defaultsDeep = baseRest(function(args) {
+ args.push(undefined$1, customDefaultsMerge);
+ return apply(mergeWith, undefined$1, args);
+ });
+
+ /**
+ * This method is like `_.find` except that it returns the key of the first
+ * element `predicate` returns truthy for instead of the element itself.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.1.0
+ * @category Object
+ * @param {Object} object The object to inspect.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @returns {string|undefined} Returns the key of the matched element,
+ * else `undefined`.
+ * @example
+ *
+ * var users = {
+ * 'barney': { 'age': 36, 'active': true },
+ * 'fred': { 'age': 40, 'active': false },
+ * 'pebbles': { 'age': 1, 'active': true }
+ * };
+ *
+ * _.findKey(users, function(o) { return o.age < 40; });
+ * // => 'barney' (iteration order is not guaranteed)
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.findKey(users, { 'age': 1, 'active': true });
+ * // => 'pebbles'
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.findKey(users, ['active', false]);
+ * // => 'fred'
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.findKey(users, 'active');
+ * // => 'barney'
+ */
+ function findKey(object, predicate) {
+ return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);
+ }
+
+ /**
+ * This method is like `_.findKey` except that it iterates over elements of
+ * a collection in the opposite order.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.0.0
+ * @category Object
+ * @param {Object} object The object to inspect.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @returns {string|undefined} Returns the key of the matched element,
+ * else `undefined`.
+ * @example
+ *
+ * var users = {
+ * 'barney': { 'age': 36, 'active': true },
+ * 'fred': { 'age': 40, 'active': false },
+ * 'pebbles': { 'age': 1, 'active': true }
+ * };
+ *
+ * _.findLastKey(users, function(o) { return o.age < 40; });
+ * // => returns 'pebbles' assuming `_.findKey` returns 'barney'
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.findLastKey(users, { 'age': 36, 'active': true });
+ * // => 'barney'
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.findLastKey(users, ['active', false]);
+ * // => 'fred'
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.findLastKey(users, 'active');
+ * // => 'pebbles'
+ */
+ function findLastKey(object, predicate) {
+ return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
+ }
+
+ /**
+ * Iterates over own and inherited enumerable string keyed properties of an
+ * object and invokes `iteratee` for each property. The iteratee is invoked
+ * with three arguments: (value, key, object). Iteratee functions may exit
+ * iteration early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.3.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ * @see _.forInRight
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.forIn(new Foo, function(value, key) {
+ * console.log(key);
+ * });
+ * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).
+ */
+ function forIn(object, iteratee) {
+ return object == null
+ ? object
+ : baseFor(object, getIteratee(iteratee, 3), keysIn);
+ }
+
+ /**
+ * This method is like `_.forIn` except that it iterates over properties of
+ * `object` in the opposite order.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.0.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ * @see _.forIn
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.forInRight(new Foo, function(value, key) {
+ * console.log(key);
+ * });
+ * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.
+ */
+ function forInRight(object, iteratee) {
+ return object == null
+ ? object
+ : baseForRight(object, getIteratee(iteratee, 3), keysIn);
+ }
+
+ /**
+ * Iterates over own enumerable string keyed properties of an object and
+ * invokes `iteratee` for each property. The iteratee is invoked with three
+ * arguments: (value, key, object). Iteratee functions may exit iteration
+ * early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.3.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ * @see _.forOwnRight
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.forOwn(new Foo, function(value, key) {
+ * console.log(key);
+ * });
+ * // => Logs 'a' then 'b' (iteration order is not guaranteed).
+ */
+ function forOwn(object, iteratee) {
+ return object && baseForOwn(object, getIteratee(iteratee, 3));
+ }
+
+ /**
+ * This method is like `_.forOwn` except that it iterates over properties of
+ * `object` in the opposite order.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.0.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ * @see _.forOwn
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.forOwnRight(new Foo, function(value, key) {
+ * console.log(key);
+ * });
+ * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.
+ */
+ function forOwnRight(object, iteratee) {
+ return object && baseForOwnRight(object, getIteratee(iteratee, 3));
+ }
+
+ /**
+ * Creates an array of function property names from own enumerable properties
+ * of `object`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns the function names.
+ * @see _.functionsIn
+ * @example
+ *
+ * function Foo() {
+ * this.a = _.constant('a');
+ * this.b = _.constant('b');
+ * }
+ *
+ * Foo.prototype.c = _.constant('c');
+ *
+ * _.functions(new Foo);
+ * // => ['a', 'b']
+ */
+ function functions(object) {
+ return object == null ? [] : baseFunctions(object, keys(object));
+ }
+
+ /**
+ * Creates an array of function property names from own and inherited
+ * enumerable properties of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns the function names.
+ * @see _.functions
+ * @example
+ *
+ * function Foo() {
+ * this.a = _.constant('a');
+ * this.b = _.constant('b');
+ * }
+ *
+ * Foo.prototype.c = _.constant('c');
+ *
+ * _.functionsIn(new Foo);
+ * // => ['a', 'b', 'c']
+ */
+ function functionsIn(object) {
+ return object == null ? [] : baseFunctions(object, keysIn(object));
+ }
+
+ /**
+ * Gets the value at `path` of `object`. If the resolved value is
+ * `undefined`, the `defaultValue` is returned in its place.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.get(object, 'a[0].b.c');
+ * // => 3
+ *
+ * _.get(object, ['a', '0', 'b', 'c']);
+ * // => 3
+ *
+ * _.get(object, 'a.b.c', 'default');
+ * // => 'default'
+ */
+ function get(object, path, defaultValue) {
+ var result = object == null ? undefined$1 : baseGet(object, path);
+ return result === undefined$1 ? defaultValue : result;
+ }
+
+ /**
+ * Checks if `path` is a direct property of `object`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = { 'a': { 'b': 2 } };
+ * var other = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.has(object, 'a');
+ * // => true
+ *
+ * _.has(object, 'a.b');
+ * // => true
+ *
+ * _.has(object, ['a', 'b']);
+ * // => true
+ *
+ * _.has(other, 'a');
+ * // => false
+ */
+ function has(object, path) {
+ return object != null && hasPath(object, path, baseHas);
+ }
+
+ /**
+ * Checks if `path` is a direct or inherited property of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.hasIn(object, 'a');
+ * // => true
+ *
+ * _.hasIn(object, 'a.b');
+ * // => true
+ *
+ * _.hasIn(object, ['a', 'b']);
+ * // => true
+ *
+ * _.hasIn(object, 'b');
+ * // => false
+ */
+ function hasIn(object, path) {
+ return object != null && hasPath(object, path, baseHasIn);
+ }
+
+ /**
+ * Creates an object composed of the inverted keys and values of `object`.
+ * If `object` contains duplicate values, subsequent values overwrite
+ * property assignments of previous values.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.7.0
+ * @category Object
+ * @param {Object} object The object to invert.
+ * @returns {Object} Returns the new inverted object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2, 'c': 1 };
+ *
+ * _.invert(object);
+ * // => { '1': 'c', '2': 'b' }
+ */
+ var invert = createInverter(function(result, value, key) {
+ if (value != null &&
+ typeof value.toString != 'function') {
+ value = nativeObjectToString.call(value);
+ }
+
+ result[value] = key;
+ }, constant(identity));
+
+ /**
+ * This method is like `_.invert` except that the inverted object is generated
+ * from the results of running each element of `object` thru `iteratee`. The
+ * corresponding inverted value of each inverted key is an array of keys
+ * responsible for generating the inverted value. The iteratee is invoked
+ * with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.1.0
+ * @category Object
+ * @param {Object} object The object to invert.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {Object} Returns the new inverted object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2, 'c': 1 };
+ *
+ * _.invertBy(object);
+ * // => { '1': ['a', 'c'], '2': ['b'] }
+ *
+ * _.invertBy(object, function(value) {
+ * return 'group' + value;
+ * });
+ * // => { 'group1': ['a', 'c'], 'group2': ['b'] }
+ */
+ var invertBy = createInverter(function(result, value, key) {
+ if (value != null &&
+ typeof value.toString != 'function') {
+ value = nativeObjectToString.call(value);
+ }
+
+ if (hasOwnProperty.call(result, value)) {
+ result[value].push(key);
+ } else {
+ result[value] = [key];
+ }
+ }, getIteratee);
+
+ /**
+ * Invokes the method at `path` of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the method to invoke.
+ * @param {...*} [args] The arguments to invoke the method with.
+ * @returns {*} Returns the result of the invoked method.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };
+ *
+ * _.invoke(object, 'a[0].b.c.slice', 1, 3);
+ * // => [2, 3]
+ */
+ var invoke = baseRest(baseInvoke);
+
+ /**
+ * Creates an array of the own enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects. See the
+ * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keys(new Foo);
+ * // => ['a', 'b'] (iteration order is not guaranteed)
+ *
+ * _.keys('hi');
+ * // => ['0', '1']
+ */
+ function keys(object) {
+ return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+ }
+
+ /**
+ * Creates an array of the own and inherited enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keysIn(new Foo);
+ * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+ */
+ function keysIn(object) {
+ return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+ }
+
+ /**
+ * The opposite of `_.mapValues`; this method creates an object with the
+ * same values as `object` and keys generated by running each own enumerable
+ * string keyed property of `object` thru `iteratee`. The iteratee is invoked
+ * with three arguments: (value, key, object).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.8.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Object} Returns the new mapped object.
+ * @see _.mapValues
+ * @example
+ *
+ * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
+ * return key + value;
+ * });
+ * // => { 'a1': 1, 'b2': 2 }
+ */
+ function mapKeys(object, iteratee) {
+ var result = {};
+ iteratee = getIteratee(iteratee, 3);
+
+ baseForOwn(object, function(value, key, object) {
+ baseAssignValue(result, iteratee(value, key, object), value);
+ });
+ return result;
+ }
+
+ /**
+ * Creates an object with the same keys as `object` and values generated
+ * by running each own enumerable string keyed property of `object` thru
+ * `iteratee`. The iteratee is invoked with three arguments:
+ * (value, key, object).
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Object} Returns the new mapped object.
+ * @see _.mapKeys
+ * @example
+ *
+ * var users = {
+ * 'fred': { 'user': 'fred', 'age': 40 },
+ * 'pebbles': { 'user': 'pebbles', 'age': 1 }
+ * };
+ *
+ * _.mapValues(users, function(o) { return o.age; });
+ * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.mapValues(users, 'age');
+ * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
+ */
+ function mapValues(object, iteratee) {
+ var result = {};
+ iteratee = getIteratee(iteratee, 3);
+
+ baseForOwn(object, function(value, key, object) {
+ baseAssignValue(result, key, iteratee(value, key, object));
+ });
+ return result;
+ }
+
+ /**
+ * This method is like `_.assign` except that it recursively merges own and
+ * inherited enumerable string keyed properties of source objects into the
+ * destination object. Source properties that resolve to `undefined` are
+ * skipped if a destination value exists. Array and plain object properties
+ * are merged recursively. Other objects and value types are overridden by
+ * assignment. Source objects are applied from left to right. Subsequent
+ * sources overwrite property assignments of previous sources.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.5.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = {
+ * 'a': [{ 'b': 2 }, { 'd': 4 }]
+ * };
+ *
+ * var other = {
+ * 'a': [{ 'c': 3 }, { 'e': 5 }]
+ * };
+ *
+ * _.merge(object, other);
+ * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
+ */
+ var merge = createAssigner(function(object, source, srcIndex) {
+ baseMerge(object, source, srcIndex);
+ });
+
+ /**
+ * This method is like `_.merge` except that it accepts `customizer` which
+ * is invoked to produce the merged values of the destination and source
+ * properties. If `customizer` returns `undefined`, merging is handled by the
+ * method instead. The `customizer` is invoked with six arguments:
+ * (objValue, srcValue, key, object, source, stack).
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} sources The source objects.
+ * @param {Function} customizer The function to customize assigned values.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function customizer(objValue, srcValue) {
+ * if (_.isArray(objValue)) {
+ * return objValue.concat(srcValue);
+ * }
+ * }
+ *
+ * var object = { 'a': [1], 'b': [2] };
+ * var other = { 'a': [3], 'b': [4] };
+ *
+ * _.mergeWith(object, other, customizer);
+ * // => { 'a': [1, 3], 'b': [2, 4] }
+ */
+ var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
+ baseMerge(object, source, srcIndex, customizer);
+ });
+
+ /**
+ * The opposite of `_.pick`; this method creates an object composed of the
+ * own and inherited enumerable property paths of `object` that are not omitted.
+ *
+ * **Note:** This method is considerably slower than `_.pick`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {...(string|string[])} [paths] The property paths to omit.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.omit(object, ['a', 'c']);
+ * // => { 'b': '2' }
+ */
+ var omit = flatRest(function(object, paths) {
+ var result = {};
+ if (object == null) {
+ return result;
+ }
+ var isDeep = false;
+ paths = arrayMap(paths, function(path) {
+ path = castPath(path, object);
+ isDeep || (isDeep = path.length > 1);
+ return path;
+ });
+ copyObject(object, getAllKeysIn(object), result);
+ if (isDeep) {
+ result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
+ }
+ var length = paths.length;
+ while (length--) {
+ baseUnset(result, paths[length]);
+ }
+ return result;
+ });
+
+ /**
+ * The opposite of `_.pickBy`; this method creates an object composed of
+ * the own and inherited enumerable string keyed properties of `object` that
+ * `predicate` doesn't return truthy for. The predicate is invoked with two
+ * arguments: (value, key).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {Function} [predicate=_.identity] The function invoked per property.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.omitBy(object, _.isNumber);
+ * // => { 'b': '2' }
+ */
+ function omitBy(object, predicate) {
+ return pickBy(object, negate(getIteratee(predicate)));
+ }
+
+ /**
+ * Creates an object composed of the picked `object` properties.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {...(string|string[])} [paths] The property paths to pick.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.pick(object, ['a', 'c']);
+ * // => { 'a': 1, 'c': 3 }
+ */
+ var pick = flatRest(function(object, paths) {
+ return object == null ? {} : basePick(object, paths);
+ });
+
+ /**
+ * Creates an object composed of the `object` properties `predicate` returns
+ * truthy for. The predicate is invoked with two arguments: (value, key).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {Function} [predicate=_.identity] The function invoked per property.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.pickBy(object, _.isNumber);
+ * // => { 'a': 1, 'c': 3 }
+ */
+ function pickBy(object, predicate) {
+ if (object == null) {
+ return {};
+ }
+ var props = arrayMap(getAllKeysIn(object), function(prop) {
+ return [prop];
+ });
+ predicate = getIteratee(predicate);
+ return basePickBy(object, props, function(value, path) {
+ return predicate(value, path[0]);
+ });
+ }
+
+ /**
+ * This method is like `_.get` except that if the resolved value is a
+ * function it's invoked with the `this` binding of its parent object and
+ * its result is returned.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to resolve.
+ * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };
+ *
+ * _.result(object, 'a[0].b.c1');
+ * // => 3
+ *
+ * _.result(object, 'a[0].b.c2');
+ * // => 4
+ *
+ * _.result(object, 'a[0].b.c3', 'default');
+ * // => 'default'
+ *
+ * _.result(object, 'a[0].b.c3', _.constant('default'));
+ * // => 'default'
+ */
+ function result(object, path, defaultValue) {
+ path = castPath(path, object);
+
+ var index = -1,
+ length = path.length;
+
+ // Ensure the loop is entered when path is empty.
+ if (!length) {
+ length = 1;
+ object = undefined$1;
+ }
+ while (++index < length) {
+ var value = object == null ? undefined$1 : object[toKey(path[index])];
+ if (value === undefined$1) {
+ index = length;
+ value = defaultValue;
+ }
+ object = isFunction(value) ? value.call(object) : value;
+ }
+ return object;
+ }
+
+ /**
+ * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
+ * it's created. Arrays are created for missing index properties while objects
+ * are created for all other missing properties. Use `_.setWith` to customize
+ * `path` creation.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.set(object, 'a[0].b.c', 4);
+ * console.log(object.a[0].b.c);
+ * // => 4
+ *
+ * _.set(object, ['x', '0', 'y', 'z'], 5);
+ * console.log(object.x[0].y.z);
+ * // => 5
+ */
+ function set(object, path, value) {
+ return object == null ? object : baseSet(object, path, value);
+ }
+
+ /**
+ * This method is like `_.set` except that it accepts `customizer` which is
+ * invoked to produce the objects of `path`. If `customizer` returns `undefined`
+ * path creation is handled by the method instead. The `customizer` is invoked
+ * with three arguments: (nsValue, key, nsObject).
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {*} value The value to set.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = {};
+ *
+ * _.setWith(object, '[0][1]', 'a', Object);
+ * // => { '0': { '1': 'a' } }
+ */
+ function setWith(object, path, value, customizer) {
+ customizer = typeof customizer == 'function' ? customizer : undefined$1;
+ return object == null ? object : baseSet(object, path, value, customizer);
+ }
+
+ /**
+ * Creates an array of own enumerable string keyed-value pairs for `object`
+ * which can be consumed by `_.fromPairs`. If `object` is a map or set, its
+ * entries are returned.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @alias entries
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the key-value pairs.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.toPairs(new Foo);
+ * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)
+ */
+ var toPairs = createToPairs(keys);
+
+ /**
+ * Creates an array of own and inherited enumerable string keyed-value pairs
+ * for `object` which can be consumed by `_.fromPairs`. If `object` is a map
+ * or set, its entries are returned.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @alias entriesIn
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the key-value pairs.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.toPairsIn(new Foo);
+ * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)
+ */
+ var toPairsIn = createToPairs(keysIn);
+
+ /**
+ * An alternative to `_.reduce`; this method transforms `object` to a new
+ * `accumulator` object which is the result of running each of its own
+ * enumerable string keyed properties thru `iteratee`, with each invocation
+ * potentially mutating the `accumulator` object. If `accumulator` is not
+ * provided, a new object with the same `[[Prototype]]` will be used. The
+ * iteratee is invoked with four arguments: (accumulator, value, key, object).
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.3.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @param {*} [accumulator] The custom accumulator value.
+ * @returns {*} Returns the accumulated value.
+ * @example
+ *
+ * _.transform([2, 3, 4], function(result, n) {
+ * result.push(n *= n);
+ * return n % 2 == 0;
+ * }, []);
+ * // => [4, 9]
+ *
+ * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
+ * (result[value] || (result[value] = [])).push(key);
+ * }, {});
+ * // => { '1': ['a', 'c'], '2': ['b'] }
+ */
+ function transform(object, iteratee, accumulator) {
+ var isArr = isArray(object),
+ isArrLike = isArr || isBuffer(object) || isTypedArray(object);
+
+ iteratee = getIteratee(iteratee, 4);
+ if (accumulator == null) {
+ var Ctor = object && object.constructor;
+ if (isArrLike) {
+ accumulator = isArr ? new Ctor : [];
+ }
+ else if (isObject(object)) {
+ accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};
+ }
+ else {
+ accumulator = {};
+ }
+ }
+ (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {
+ return iteratee(accumulator, value, index, object);
+ });
+ return accumulator;
+ }
+
+ /**
+ * Removes the property at `path` of `object`.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to unset.
+ * @returns {boolean} Returns `true` if the property is deleted, else `false`.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 7 } }] };
+ * _.unset(object, 'a[0].b.c');
+ * // => true
+ *
+ * console.log(object);
+ * // => { 'a': [{ 'b': {} }] };
+ *
+ * _.unset(object, ['a', '0', 'b', 'c']);
+ * // => true
+ *
+ * console.log(object);
+ * // => { 'a': [{ 'b': {} }] };
+ */
+ function unset(object, path) {
+ return object == null ? true : baseUnset(object, path);
+ }
+
+ /**
+ * This method is like `_.set` except that accepts `updater` to produce the
+ * value to set. Use `_.updateWith` to customize `path` creation. The `updater`
+ * is invoked with one argument: (value).
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.6.0
+ * @category Object
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {Function} updater The function to produce the updated value.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.update(object, 'a[0].b.c', function(n) { return n * n; });
+ * console.log(object.a[0].b.c);
+ * // => 9
+ *
+ * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });
+ * console.log(object.x[0].y.z);
+ * // => 0
+ */
+ function update(object, path, updater) {
+ return object == null ? object : baseUpdate(object, path, castFunction(updater));
+ }
+
+ /**
+ * This method is like `_.update` except that it accepts `customizer` which is
+ * invoked to produce the objects of `path`. If `customizer` returns `undefined`
+ * path creation is handled by the method instead. The `customizer` is invoked
+ * with three arguments: (nsValue, key, nsObject).
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.6.0
+ * @category Object
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {Function} updater The function to produce the updated value.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = {};
+ *
+ * _.updateWith(object, '[0][1]', _.constant('a'), Object);
+ * // => { '0': { '1': 'a' } }
+ */
+ function updateWith(object, path, updater, customizer) {
+ customizer = typeof customizer == 'function' ? customizer : undefined$1;
+ return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
+ }
+
+ /**
+ * Creates an array of the own enumerable string keyed property values of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property values.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.values(new Foo);
+ * // => [1, 2] (iteration order is not guaranteed)
+ *
+ * _.values('hi');
+ * // => ['h', 'i']
+ */
+ function values(object) {
+ return object == null ? [] : baseValues(object, keys(object));
+ }
+
+ /**
+ * Creates an array of the own and inherited enumerable string keyed property
+ * values of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property values.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.valuesIn(new Foo);
+ * // => [1, 2, 3] (iteration order is not guaranteed)
+ */
+ function valuesIn(object) {
+ return object == null ? [] : baseValues(object, keysIn(object));
+ }
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Clamps `number` within the inclusive `lower` and `upper` bounds.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Number
+ * @param {number} number The number to clamp.
+ * @param {number} [lower] The lower bound.
+ * @param {number} upper The upper bound.
+ * @returns {number} Returns the clamped number.
+ * @example
+ *
+ * _.clamp(-10, -5, 5);
+ * // => -5
+ *
+ * _.clamp(10, -5, 5);
+ * // => 5
+ */
+ function clamp(number, lower, upper) {
+ if (upper === undefined$1) {
+ upper = lower;
+ lower = undefined$1;
+ }
+ if (upper !== undefined$1) {
+ upper = toNumber(upper);
+ upper = upper === upper ? upper : 0;
+ }
+ if (lower !== undefined$1) {
+ lower = toNumber(lower);
+ lower = lower === lower ? lower : 0;
+ }
+ return baseClamp(toNumber(number), lower, upper);
+ }
+
+ /**
+ * Checks if `n` is between `start` and up to, but not including, `end`. If
+ * `end` is not specified, it's set to `start` with `start` then set to `0`.
+ * If `start` is greater than `end` the params are swapped to support
+ * negative ranges.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.3.0
+ * @category Number
+ * @param {number} number The number to check.
+ * @param {number} [start=0] The start of the range.
+ * @param {number} end The end of the range.
+ * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
+ * @see _.range, _.rangeRight
+ * @example
+ *
+ * _.inRange(3, 2, 4);
+ * // => true
+ *
+ * _.inRange(4, 8);
+ * // => true
+ *
+ * _.inRange(4, 2);
+ * // => false
+ *
+ * _.inRange(2, 2);
+ * // => false
+ *
+ * _.inRange(1.2, 2);
+ * // => true
+ *
+ * _.inRange(5.2, 4);
+ * // => false
+ *
+ * _.inRange(-3, -2, -6);
+ * // => true
+ */
+ function inRange(number, start, end) {
+ start = toFinite(start);
+ if (end === undefined$1) {
+ end = start;
+ start = 0;
+ } else {
+ end = toFinite(end);
+ }
+ number = toNumber(number);
+ return baseInRange(number, start, end);
+ }
+
+ /**
+ * Produces a random number between the inclusive `lower` and `upper` bounds.
+ * If only one argument is provided a number between `0` and the given number
+ * is returned. If `floating` is `true`, or either `lower` or `upper` are
+ * floats, a floating-point number is returned instead of an integer.
+ *
+ * **Note:** JavaScript follows the IEEE-754 standard for resolving
+ * floating-point values which can produce unexpected results.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.7.0
+ * @category Number
+ * @param {number} [lower=0] The lower bound.
+ * @param {number} [upper=1] The upper bound.
+ * @param {boolean} [floating] Specify returning a floating-point number.
+ * @returns {number} Returns the random number.
+ * @example
+ *
+ * _.random(0, 5);
+ * // => an integer between 0 and 5
+ *
+ * _.random(5);
+ * // => also an integer between 0 and 5
+ *
+ * _.random(5, true);
+ * // => a floating-point number between 0 and 5
+ *
+ * _.random(1.2, 5.2);
+ * // => a floating-point number between 1.2 and 5.2
+ */
+ function random(lower, upper, floating) {
+ if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {
+ upper = floating = undefined$1;
+ }
+ if (floating === undefined$1) {
+ if (typeof upper == 'boolean') {
+ floating = upper;
+ upper = undefined$1;
+ }
+ else if (typeof lower == 'boolean') {
+ floating = lower;
+ lower = undefined$1;
+ }
+ }
+ if (lower === undefined$1 && upper === undefined$1) {
+ lower = 0;
+ upper = 1;
+ }
+ else {
+ lower = toFinite(lower);
+ if (upper === undefined$1) {
+ upper = lower;
+ lower = 0;
+ } else {
+ upper = toFinite(upper);
+ }
+ }
+ if (lower > upper) {
+ var temp = lower;
+ lower = upper;
+ upper = temp;
+ }
+ if (floating || lower % 1 || upper % 1) {
+ var rand = nativeRandom();
+ return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);
+ }
+ return baseRandom(lower, upper);
+ }
+
+ /*------------------------------------------------------------------------*/
+
+ /**
+ * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the camel cased string.
+ * @example
+ *
+ * _.camelCase('Foo Bar');
+ * // => 'fooBar'
+ *
+ * _.camelCase('--foo-bar--');
+ * // => 'fooBar'
+ *
+ * _.camelCase('__FOO_BAR__');
+ * // => 'fooBar'
+ */
+ var camelCase = createCompounder(function(result, word, index) {
+ word = word.toLowerCase();
+ return result + (index ? capitalize(word) : word);
+ });
+
+ /**
+ * Converts the first character of `string` to upper case and the remaining
+ * to lower case.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to capitalize.
+ * @returns {string} Returns the capitalized string.
+ * @example
+ *
+ * _.capitalize('FRED');
+ * // => 'Fred'
+ */
+ function capitalize(string) {
+ return upperFirst(toString(string).toLowerCase());
+ }
+
+ /**
+ * Deburrs `string` by converting
+ * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
+ * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
+ * letters to basic Latin letters and removing
+ * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to deburr.
+ * @returns {string} Returns the deburred string.
+ * @example
+ *
+ * _.deburr('déjà vu');
+ * // => 'deja vu'
+ */
+ function deburr(string) {
+ string = toString(string);
+ return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');
+ }
+
+ /**
+ * Checks if `string` ends with the given target string.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to inspect.
+ * @param {string} [target] The string to search for.
+ * @param {number} [position=string.length] The position to search up to.
+ * @returns {boolean} Returns `true` if `string` ends with `target`,
+ * else `false`.
+ * @example
+ *
+ * _.endsWith('abc', 'c');
+ * // => true
+ *
+ * _.endsWith('abc', 'b');
+ * // => false
+ *
+ * _.endsWith('abc', 'b', 2);
+ * // => true
+ */
+ function endsWith(string, target, position) {
+ string = toString(string);
+ target = baseToString(target);
+
+ var length = string.length;
+ position = position === undefined$1
+ ? length
+ : baseClamp(toInteger(position), 0, length);
+
+ var end = position;
+ position -= target.length;
+ return position >= 0 && string.slice(position, end) == target;
+ }
+
+ /**
+ * Converts the characters "&", "<", ">", '"', and "'" in `string` to their
+ * corresponding HTML entities.
+ *
+ * **Note:** No other characters are escaped. To escape additional
+ * characters use a third-party library like [_he_](https://mths.be/he).
+ *
+ * Though the ">" character is escaped for symmetry, characters like
+ * ">" and "/" don't need escaping in HTML and have no special meaning
+ * unless they're part of a tag or unquoted attribute value. See
+ * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)
+ * (under "semi-related fun fact") for more details.
+ *
+ * When working with HTML you should always
+ * [quote attribute values](http://wonko.com/post/html-escaping) to reduce
+ * XSS vectors.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category String
+ * @param {string} [string=''] The string to escape.
+ * @returns {string} Returns the escaped string.
+ * @example
+ *
+ * _.escape('fred, barney, & pebbles');
+ * // => 'fred, barney, & pebbles'
+ */
+ function escape(string) {
+ string = toString(string);
+ return (string && reHasUnescapedHtml.test(string))
+ ? string.replace(reUnescapedHtml, escapeHtmlChar)
+ : string;
+ }
+
+ /**
+ * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
+ * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to escape.
+ * @returns {string} Returns the escaped string.
+ * @example
+ *
+ * _.escapeRegExp('[lodash](https://lodash.com/)');
+ * // => '\[lodash\]\(https://lodash\.com/\)'
+ */
+ function escapeRegExp(string) {
+ string = toString(string);
+ return (string && reHasRegExpChar.test(string))
+ ? string.replace(reRegExpChar, '\\$&')
+ : string;
+ }
+
+ /**
+ * Converts `string` to
+ * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the kebab cased string.
+ * @example
+ *
+ * _.kebabCase('Foo Bar');
+ * // => 'foo-bar'
+ *
+ * _.kebabCase('fooBar');
+ * // => 'foo-bar'
+ *
+ * _.kebabCase('__FOO_BAR__');
+ * // => 'foo-bar'
+ */
+ var kebabCase = createCompounder(function(result, word, index) {
+ return result + (index ? '-' : '') + word.toLowerCase();
+ });
+
+ /**
+ * Converts `string`, as space separated words, to lower case.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the lower cased string.
+ * @example
+ *
+ * _.lowerCase('--Foo-Bar--');
+ * // => 'foo bar'
+ *
+ * _.lowerCase('fooBar');
+ * // => 'foo bar'
+ *
+ * _.lowerCase('__FOO_BAR__');
+ * // => 'foo bar'
+ */
+ var lowerCase = createCompounder(function(result, word, index) {
+ return result + (index ? ' ' : '') + word.toLowerCase();
+ });
+
+ /**
+ * Converts the first character of `string` to lower case.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the converted string.
+ * @example
+ *
+ * _.lowerFirst('Fred');
+ * // => 'fred'
+ *
+ * _.lowerFirst('FRED');
+ * // => 'fRED'
+ */
+ var lowerFirst = createCaseFirst('toLowerCase');
+
+ /**
+ * Pads `string` on the left and right sides if it's shorter than `length`.
+ * Padding characters are truncated if they can't be evenly divided by `length`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to pad.
+ * @param {number} [length=0] The padding length.
+ * @param {string} [chars=' '] The string used as padding.
+ * @returns {string} Returns the padded string.
+ * @example
+ *
+ * _.pad('abc', 8);
+ * // => ' abc '
+ *
+ * _.pad('abc', 8, '_-');
+ * // => '_-abc_-_'
+ *
+ * _.pad('abc', 3);
+ * // => 'abc'
+ */
+ function pad(string, length, chars) {
+ string = toString(string);
+ length = toInteger(length);
+
+ var strLength = length ? stringSize(string) : 0;
+ if (!length || strLength >= length) {
+ return string;
+ }
+ var mid = (length - strLength) / 2;
+ return (
+ createPadding(nativeFloor(mid), chars) +
+ string +
+ createPadding(nativeCeil(mid), chars)
+ );
+ }
+
+ /**
+ * Pads `string` on the right side if it's shorter than `length`. Padding
+ * characters are truncated if they exceed `length`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category String
+ * @param {string} [string=''] The string to pad.
+ * @param {number} [length=0] The padding length.
+ * @param {string} [chars=' '] The string used as padding.
+ * @returns {string} Returns the padded string.
+ * @example
+ *
+ * _.padEnd('abc', 6);
+ * // => 'abc '
+ *
+ * _.padEnd('abc', 6, '_-');
+ * // => 'abc_-_'
+ *
+ * _.padEnd('abc', 3);
+ * // => 'abc'
+ */
+ function padEnd(string, length, chars) {
+ string = toString(string);
+ length = toInteger(length);
+
+ var strLength = length ? stringSize(string) : 0;
+ return (length && strLength < length)
+ ? (string + createPadding(length - strLength, chars))
+ : string;
+ }
+
+ /**
+ * Pads `string` on the left side if it's shorter than `length`. Padding
+ * characters are truncated if they exceed `length`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category String
+ * @param {string} [string=''] The string to pad.
+ * @param {number} [length=0] The padding length.
+ * @param {string} [chars=' '] The string used as padding.
+ * @returns {string} Returns the padded string.
+ * @example
+ *
+ * _.padStart('abc', 6);
+ * // => ' abc'
+ *
+ * _.padStart('abc', 6, '_-');
+ * // => '_-_abc'
+ *
+ * _.padStart('abc', 3);
+ * // => 'abc'
+ */
+ function padStart(string, length, chars) {
+ string = toString(string);
+ length = toInteger(length);
+
+ var strLength = length ? stringSize(string) : 0;
+ return (length && strLength < length)
+ ? (createPadding(length - strLength, chars) + string)
+ : string;
+ }
+
+ /**
+ * Converts `string` to an integer of the specified radix. If `radix` is
+ * `undefined` or `0`, a `radix` of `10` is used unless `value` is a
+ * hexadecimal, in which case a `radix` of `16` is used.
+ *
+ * **Note:** This method aligns with the
+ * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.1.0
+ * @category String
+ * @param {string} string The string to convert.
+ * @param {number} [radix=10] The radix to interpret `value` by.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {number} Returns the converted integer.
+ * @example
+ *
+ * _.parseInt('08');
+ * // => 8
+ *
+ * _.map(['6', '08', '10'], _.parseInt);
+ * // => [6, 8, 10]
+ */
+ function parseInt(string, radix, guard) {
+ if (guard || radix == null) {
+ radix = 0;
+ } else if (radix) {
+ radix = +radix;
+ }
+ return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);
+ }
+
+ /**
+ * Repeats the given string `n` times.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to repeat.
+ * @param {number} [n=1] The number of times to repeat the string.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {string} Returns the repeated string.
+ * @example
+ *
+ * _.repeat('*', 3);
+ * // => '***'
+ *
+ * _.repeat('abc', 2);
+ * // => 'abcabc'
+ *
+ * _.repeat('abc', 0);
+ * // => ''
+ */
+ function repeat(string, n, guard) {
+ if ((guard ? isIterateeCall(string, n, guard) : n === undefined$1)) {
+ n = 1;
+ } else {
+ n = toInteger(n);
+ }
+ return baseRepeat(toString(string), n);
+ }
+
+ /**
+ * Replaces matches for `pattern` in `string` with `replacement`.
+ *
+ * **Note:** This method is based on
+ * [`String#replace`](https://mdn.io/String/replace).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category String
+ * @param {string} [string=''] The string to modify.
+ * @param {RegExp|string} pattern The pattern to replace.
+ * @param {Function|string} replacement The match replacement.
+ * @returns {string} Returns the modified string.
+ * @example
+ *
+ * _.replace('Hi Fred', 'Fred', 'Barney');
+ * // => 'Hi Barney'
+ */
+ function replace() {
+ var args = arguments,
+ string = toString(args[0]);
+
+ return args.length < 3 ? string : string.replace(args[1], args[2]);
+ }
+
+ /**
+ * Converts `string` to
+ * [snake case](https://en.wikipedia.org/wiki/Snake_case).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the snake cased string.
+ * @example
+ *
+ * _.snakeCase('Foo Bar');
+ * // => 'foo_bar'
+ *
+ * _.snakeCase('fooBar');
+ * // => 'foo_bar'
+ *
+ * _.snakeCase('--FOO-BAR--');
+ * // => 'foo_bar'
+ */
+ var snakeCase = createCompounder(function(result, word, index) {
+ return result + (index ? '_' : '') + word.toLowerCase();
+ });
+
+ /**
+ * Splits `string` by `separator`.
+ *
+ * **Note:** This method is based on
+ * [`String#split`](https://mdn.io/String/split).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category String
+ * @param {string} [string=''] The string to split.
+ * @param {RegExp|string} separator The separator pattern to split by.
+ * @param {number} [limit] The length to truncate results to.
+ * @returns {Array} Returns the string segments.
+ * @example
+ *
+ * _.split('a-b-c', '-', 2);
+ * // => ['a', 'b']
+ */
+ function split(string, separator, limit) {
+ if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {
+ separator = limit = undefined$1;
+ }
+ limit = limit === undefined$1 ? MAX_ARRAY_LENGTH : limit >>> 0;
+ if (!limit) {
+ return [];
+ }
+ string = toString(string);
+ if (string && (
+ typeof separator == 'string' ||
+ (separator != null && !isRegExp(separator))
+ )) {
+ separator = baseToString(separator);
+ if (!separator && hasUnicode(string)) {
+ return castSlice(stringToArray(string), 0, limit);
+ }
+ }
+ return string.split(separator, limit);
+ }
+
+ /**
+ * Converts `string` to
+ * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.1.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the start cased string.
+ * @example
+ *
+ * _.startCase('--foo-bar--');
+ * // => 'Foo Bar'
+ *
+ * _.startCase('fooBar');
+ * // => 'Foo Bar'
+ *
+ * _.startCase('__FOO_BAR__');
+ * // => 'FOO BAR'
+ */
+ var startCase = createCompounder(function(result, word, index) {
+ return result + (index ? ' ' : '') + upperFirst(word);
+ });
+
+ /**
+ * Checks if `string` starts with the given target string.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to inspect.
+ * @param {string} [target] The string to search for.
+ * @param {number} [position=0] The position to search from.
+ * @returns {boolean} Returns `true` if `string` starts with `target`,
+ * else `false`.
+ * @example
+ *
+ * _.startsWith('abc', 'a');
+ * // => true
+ *
+ * _.startsWith('abc', 'b');
+ * // => false
+ *
+ * _.startsWith('abc', 'b', 1);
+ * // => true
+ */
+ function startsWith(string, target, position) {
+ string = toString(string);
+ position = position == null
+ ? 0
+ : baseClamp(toInteger(position), 0, string.length);
+
+ target = baseToString(target);
+ return string.slice(position, position + target.length) == target;
+ }
+
+ /**
+ * Creates a compiled template function that can interpolate data properties
+ * in "interpolate" delimiters, HTML-escape interpolated data properties in
+ * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data
+ * properties may be accessed as free variables in the template. If a setting
+ * object is given, it takes precedence over `_.templateSettings` values.
+ *
+ * **Note:** In the development build `_.template` utilizes
+ * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)
+ * for easier debugging.
+ *
+ * For more information on precompiling templates see
+ * [lodash's custom builds documentation](https://lodash.com/custom-builds).
+ *
+ * For more information on Chrome extension sandboxes see
+ * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category String
+ * @param {string} [string=''] The template string.
+ * @param {Object} [options={}] The options object.
+ * @param {RegExp} [options.escape=_.templateSettings.escape]
+ * The HTML "escape" delimiter.
+ * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]
+ * The "evaluate" delimiter.
+ * @param {Object} [options.imports=_.templateSettings.imports]
+ * An object to import into the template as free variables.
+ * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]
+ * The "interpolate" delimiter.
+ * @param {string} [options.sourceURL='lodash.templateSources[n]']
+ * The sourceURL of the compiled template.
+ * @param {string} [options.variable='obj']
+ * The data object variable name.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {Function} Returns the compiled template function.
+ * @example
+ *
+ * // Use the "interpolate" delimiter to create a compiled template.
+ * var compiled = _.template('hello <%= user %>!');
+ * compiled({ 'user': 'fred' });
+ * // => 'hello fred!'
+ *
+ * // Use the HTML "escape" delimiter to escape data property values.
+ * var compiled = _.template('<%- value %>');
+ * compiled({ 'value': '