@spscommerce/utils 5.5.0-ie → 5.5.0-ie.2

package/lib/index.es.js

@@ -0,0 +1,2399 @@
+function _mergeNamespaces(n, m) {
+    m.forEach(function (e) {
+        e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+            if (k !== 'default' && !(k in n)) {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    });
+    return Object.freeze(n);
+}
+
+function flatten(arg) {
+    if (!Array.isArray(arg)) {
+        return arg;
+    }
+    return arg.reduce(function (acc, x) { return acc.concat(flatten(x)); }, []);
+}
+
+var __values$d = (undefined && undefined.__values) || 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.");
+};
+/**
+ * Tests if candidate is a subset of array
+ */
+function isSubset(candidate, array) {
+    var e_1, _a;
+    /*
+     * Set.prototype.has is required by the ECMAScript spec to be
+     * implemented in sub-linear time, so by converting array to Set
+     * we can avoid n^2 complexity. (In WebKit, Sets are HashMaps
+     * internally, so has() is constant time)
+     */
+    var set = new Set(array);
+    try {
+        for (var candidate_1 = __values$d(candidate), candidate_1_1 = candidate_1.next(); !candidate_1_1.done; candidate_1_1 = candidate_1.next()) {
+            var member = candidate_1_1.value;
+            if (!set.has(member)) {
+                return false;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (candidate_1_1 && !candidate_1_1.done && (_a = candidate_1.return)) _a.call(candidate_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return true;
+}
+
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator$1 = (undefined && undefined.__generator) || 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 };
+    }
+};
+/**
+ * If the function is set to be called, cancel the
+ * timeout that would call it. Reset id & pending to defaults.
+ *
+ * @returns - Whether an invocation was actually canceled or not.
+ */
+function resetDebouncedFn() {
+    this.pending = false;
+    if (typeof this.id === "number") {
+        clearTimeout(this.id);
+        delete this.id;
+        return true;
+    }
+    return false;
+}
+/**
+ * Takes in a function and returns a new function that debounces it.
+ * The returned function returns an observable that can be subscribed to
+ * if you need to have something happen when the debounced function
+ * finally gets called and returns a value.
+ */
+function debounce(functionToDebounce, milliseconds, thisArg) {
+    var debFn = function debouncedFn() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return new Promise(function (resolve, reject) {
+            debFn.reset();
+            debFn.pending = true;
+            function executor() {
+                var _this = this;
+                void (function () { return __awaiter(_this, void 0, void 0, function () {
+                    var output, err_1;
+                    return __generator$1(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 3, 4, 5]);
+                                output = functionToDebounce.apply(thisArg || this, args);
+                                if (!(output instanceof Promise)) return [3 /*break*/, 2];
+                                return [4 /*yield*/, output];
+                            case 1:
+                                output = _a.sent();
+                                _a.label = 2;
+                            case 2:
+                                resolve(output);
+                                return [3 /*break*/, 5];
+                            case 3:
+                                err_1 = _a.sent();
+                                reject(err_1);
+                                return [3 /*break*/, 5];
+                            case 4:
+                                debFn.reset();
+                                return [7 /*endfinally*/];
+                            case 5: return [2 /*return*/];
+                        }
+                    });
+                }); })();
+            }
+            debFn.id = window.setTimeout(executor, milliseconds);
+        });
+    };
+    debFn.reset = resetDebouncedFn.bind(debFn);
+    return debFn;
+}
+
+/**
+ * If the function is set to be called, cancel the
+ * timeout that would call it. Reset id & pending to defaults.
+ *
+ * @returns - Whether an invocation was actually canceled or not.
+ */
+function resetLockedFn() {
+    this.pending = false;
+    if (typeof this.id === "number") {
+        window.cancelAnimationFrame(this.id);
+        delete this.id;
+        return true;
+    }
+    return false;
+}
+/**
+ * Return a new function to replace the passed in one which ensures that
+ * the given function will run only in `requestAnimationFrame()` and at
+ * most once per frame.
+ */
+function lockToAnimationFrames(functionToLock, thisArg) {
+    var lockFn = function lockedFn() {
+        var _this = this;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (lockFn.pending) {
+            lockFn.reset();
+        }
+        lockFn.id = window.requestAnimationFrame(function () {
+            if (functionToLock) {
+                functionToLock.apply(thisArg || _this, args);
+            }
+            lockFn.reset();
+        });
+        lockFn.pending = true;
+    };
+    lockFn.pending = false;
+    lockFn.reset = resetLockedFn.bind(lockFn);
+    return lockFn;
+}
+
+/**
+ * Enqueues the given function to run on the next "tick" of the JS event
+ * loop cycle. If you ever encounter the "value changed after it was
+ * checked" error in Angular when trying to assign a value of a
+ * component class, performing that assignment on the next tick, i.e. when
+ * all of Angular's current cycle is finished, will resolve that error.
+ */
+function onNextTick(fn, thisArg) {
+    var boundFn = thisArg ? fn.bind(thisArg) : fn;
+    setTimeout(boundFn, 0);
+}
+
+/**
+ * Functions for various operators, most useful in combination
+ * with functional programming tools like map, filter, and reduce.
+ */
+var Op = {
+    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+    add: function (a, b) { return a + b; },
+    and: function (a, b) { return a && b; },
+    band: function (a, b) { return a & b; },
+    bor: function (a, b) { return a | b; },
+    bxor: function (a, b) { return a ^ b; },
+    bnot: function (a) { return ~a; },
+    decr: function (a) { return a - 1; },
+    div: function (a, b) { return a / b; },
+    eq: function (a, b) { return a === b; },
+    exp: function (a, b) { return Math.pow(a, b); },
+    gt: function (a, b) { return a > b; },
+    gte: function (a, b) { return a >= b; },
+    incr: function (a) { return a + 1; },
+    lshift: function (a, b) { return a << b; },
+    lt: function (a, b) { return a < b; },
+    lte: function (a, b) { return a <= b; },
+    mul: function (a, b) { return a * b; },
+    neg: function (a) { return -a; },
+    neq: function (a, b) { return a !== b; },
+    not: function (a) { return !a; },
+    or: function (a, b) { return a || b; },
+    rem: function (a, b) { return a % b; },
+    rshift: function (a, b) { return a >> b; },
+    rshift_zf: function (a, b) { return a >>> b; },
+    sub: function (a, b) { return a - b; },
+    xor: function (a, b) { return (a || b) && !(a && b); },
+};
+
+/**
+ * Unlike lodash range, includes the specified end number.
+ * So range(1, 10) gives you 1-10 instead of 1-9.
+ */
+function range(start, end) {
+    if (!Number.isInteger(start)) {
+        throw new Error("start must be an integer");
+    }
+    if (!Number.isInteger(end)) {
+        throw new Error("end must be an integer");
+    }
+    return new Array(Math.abs(end - start) + 1).fill(start)
+        .map(start > end ? Op.sub : Op.add);
+}
+
+/* eslint-disable @typescript-eslint/no-redeclare, @typescript-eslint/no-extraneous-class */
+/** docs:ignore */
+var __values$c = (undefined && undefined.__values) || 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.");
+};
+/*
+ * This was intended to be a replacement for Event that allows subclassing
+ * However it doesn't work in all browsers
+ * TODO: Drop this, use built-in CustomEvent once IE11 is dead
+ */
+var CustomEvent = /** @class */ (function () {
+    function CustomEvent(eventName, initDict) {
+        var e_1, _a, e_2, _b, e_3, _c;
+        if (initDict === void 0) { initDict = {}; }
+        var event;
+        if (typeof Event === "function") {
+            event = new Event(eventName, initDict);
+        }
+        else {
+            // IE11
+            event = document.createEvent("Event");
+            event.initEvent(eventName, initDict.bubbles, initDict.cancelable);
+            try {
+                for (var _d = __values$c(Object.keys(initDict)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var key = _e.value;
+                    if (key !== "bubbles" && key !== "cancelable") {
+                        event[key] = initDict[key];
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        Object.setPrototypeOf(this, event);
+        /*
+         * Native functions like the getters, setters, and methods on Event.prototype
+         * cannot be called with "this" being a custom object. So what we're doing here
+         * works around that.
+         */
+        var descriptors = Object.getOwnPropertyDescriptors(Event.prototype);
+        try {
+            for (var _f = __values$c(Object.keys(descriptors)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var propKey = _g.value;
+                var descriptor = descriptors[propKey];
+                try {
+                    for (var _h = (e_3 = void 0, __values$c(Object.keys(descriptor))), _j = _h.next(); !_j.done; _j = _h.next()) {
+                        var key = _j.value;
+                        if (typeof descriptor[key] === "function") {
+                            descriptor[key] = descriptor[key].bind(event);
+                        }
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        Object.defineProperties(this, descriptors);
+    }
+    return CustomEvent;
+}());
+
+var EDI_DOCUMENT_TYPE = Object.freeze({
+    100: { name: "Insurance Plan Description" },
+    101: { name: "Name and Address Lists" },
+    104: { name: "Air Shipment Information" },
+    106: { name: "Motor Carrier Rate Proposal" },
+    107: { name: "Request for Motor Carrier Rate Proposal" },
+    108: { name: "Response to a Motor Carrier Rate Proposal" },
+    109: { name: "Vessel Content Details" },
+    110: { name: "Air Freight Details and Invoice" },
+    112: { name: "Property Damage Report" },
+    120: { name: "Vehicle Shipping Order" },
+    121: { name: "Vehicle Service" },
+    124: { name: "Vehicle Damage" },
+    125: { name: "Multilevel Railcar Load Details" },
+    126: { name: "Vehicle Application Advice" },
+    127: { name: "Vehicle Baying Order" },
+    128: { name: "Dealer Information" },
+    129: { name: "Vehicle Carrier Rate Update" },
+    130: { name: "Student Educational Record (Transcript)" },
+    131: { name: "Student Educational Record (Transcript) Acknowledgment" },
+    135: { name: "Student Loan Application" },
+    138: { name: "Testing Results Request and Report" },
+    139: { name: "Student Loan Guarantee Result" },
+    140: { name: "Product Registration" },
+    141: { name: "Product Service Claim Response" },
+    142: { name: "Product Service Claim" },
+    143: { name: "Product Service Notification" },
+    144: { name: "Student Loan Transfer and Status Verification" },
+    146: { name: "Request for Student Educational Record (Transcript)" },
+    147: { name: "Response to Request for Student Educational Record (Transcript)" },
+    148: { name: "Report of Injury, Illness or Incident" },
+    149: { name: "Notice of Tax Adjustment or Assessment" },
+    150: { name: "Tax Rate Notification" },
+    151: { name: "Electronic Filing of Tax Return Data Acknowledgment" },
+    152: { name: "Statistical Government Information" },
+    153: { name: "Unemployment Insurance Tax Claim or Charge Information" },
+    154: { name: "Uniform Commercial Code Filing" },
+    155: { name: "Business Credit Report" },
+    157: { name: "Notice of Power of Attorney" },
+    159: { name: "Motion Picture Booking Confirmation" },
+    160: { name: "Transportation Automatic Equipment Identification" },
+    161: { name: "Train Sheet" },
+    169: { name: "Transportation Appointment Schedule Information" },
+    170: { name: "Revenue Receipts Statement" },
+    175: { name: "Court and Law Enforcement Notice" },
+    176: { name: "Court Submission TYPE" },
+    180: { name: "Return Merchandise Authorization and Notification" },
+    185: { name: "Royalty Regulatory Report" },
+    186: { name: "Insurance Underwriting Requirements Reporting" },
+    188: { name: "Educational Course Inventory" },
+    189: { name: "Application for Admission to Educational Institutions" },
+    190: { name: "Student Enrollment Verification" },
+    191: { name: "Student Loan Pre-Claims and Claims" },
+    194: { name: "Grant or Assistance Application" },
+    195: { name: "Federal Communications Commission (FCC) License Application" },
+    196: { name: "Contractor Cost Data Reporting" },
+    197: { name: "Real Estate Title Evidence" },
+    198: { name: "Loan Verification Information" },
+    199: { name: "Real Estate Settlement Information" },
+    200: { name: "Mortgage Credit Report" },
+    201: { name: "Residential Loan Application" },
+    202: { name: "Secondary Mortgage Market Loan Delivery" },
+    203: { name: "Secondary Mortgage Market Investor Report" },
+    204: { name: "Motor Carrier Load Tender" },
+    205: { name: "Mortgage Note" },
+    206: { name: "Real Estate Inspection" },
+    210: { name: "Motor Carrier Freight Details and Invoice" },
+    211: { name: "Motor Carrier Bill of Lading", edifactId: "IFTMCE" },
+    212: { name: "Motor Carrier Delivery Trailer Manifest" },
+    213: { name: "Motor Carrier Shipment Status Inquiry" },
+    214: { name: "Transportation Carrier Shipment Status Message" },
+    215: { name: "Motor Carrier Pick-up Manifest" },
+    216: { name: "Motor Carrier Shipment Pick-up Notification" },
+    217: { name: "Motor Carrier Loading and Route Guide" },
+    218: { name: "Motor Carrier Tariff Information" },
+    219: { name: "Logistics Service Request" },
+    220: { name: "Logistics Service Response" },
+    222: { name: "Cartage Work Assignment" },
+    223: { name: "Consolidators Freight Bill and Invoice" },
+    224: { name: "Motor Carrier Summary Freight Bill Manifest" },
+    225: { name: "Response to a Cartage Work Assignment" },
+    240: { name: "Motor Carrier Package Status" },
+    242: { name: "Data Status Tracking" },
+    244: { name: "Product Source Information" },
+    248: { name: "Account Assignment/Inquiry and Service/Status" },
+    249: { name: "Animal Toxicological Data" },
+    250: { name: "Purchase Order Shipment Management Document" },
+    251: { name: "Pricing Support" },
+    252: { name: "Insurance Producer Administration" },
+    255: { name: "Underwriting Information Services" },
+    256: { name: "Periodic Compensation" },
+    260: { name: "Application for Mortgage Insurance Benefits" },
+    261: { name: "Real Estate Information Request" },
+    262: { name: "Real Estate Information Report" },
+    263: { name: "Residential Mortgage Insurance Application Response" },
+    264: { name: "Mortgage Loan Default Status" },
+    265: { name: "Real Estate Title Insurance Services Order" },
+    266: { name: "Mortgage or Property Record Change Notification" },
+    267: { name: "Individual Life, Annuity and Disability Application" },
+    268: { name: "Annuity Activity" },
+    270: { name: "Eligibility, Coverage or Benefit Inquiry" },
+    271: { name: "Eligibility, Coverage or Benefit Information" },
+    272: { name: "Property and Casualty Loss Notification" },
+    273: { name: "Insurance/Annuity Application Status" },
+    274: { name: "Health Care Provider Information" },
+    275: { name: "Patient Information" },
+    276: { name: "Health Care Claim Status Request" },
+    277: { name: "Health Care Claim Status Notification" },
+    278: { name: "Health Care Services Insurance/Benefit Review Information" },
+    280: { name: "Voter Registration Information" },
+    285: { name: "Commercial Vehicle Safety and Credentials Information Exchange" },
+    286: { name: "Commercial Vehicle Credentials" },
+    288: { name: "Wage Determination" },
+    290: { name: "Cooperative Advertising Agreements" },
+    300: { name: "Reservation (Booking Request) (Ocean)" },
+    301: { name: "Confirmation (Ocean)", edifactId: "IFTMBC" },
+    303: { name: "Booking Cancellation (Ocean)" },
+    304: { name: "Shipping Instructions" },
+    309: { name: "U.S. Customs Manifest" },
+    310: { name: "Freight Receipt and Invoice (Ocean)" },
+    311: { name: "Canadian Customs Information" },
+    312: { name: "Arrival Notice (Ocean)" },
+    313: { name: "Shipment Status Inquiry (Ocean)" },
+    315: { name: "Status Details (Ocean)" },
+    317: { name: "Delivery/Pickup Order" },
+    319: { name: "Terminal Information" },
+    322: { name: "Terminal Operations and Intermodal Ramp Activity" },
+    323: { name: "Vessel Schedule and Itinerary (Ocean)" },
+    324: { name: "Vessel Stow Plan (Ocean)" },
+    325: { name: "Consolidation of Goods In Container" },
+    326: { name: "Consignment Summary List" },
+    350: { name: "U.S. Customs Status Information" },
+    352: { name: "U.S. Customs Carrier General Order Status" },
+    353: { name: "U.S. Customs Events Advisory Details" },
+    354: { name: "U.S. Customs Automated Manifest Archive Status" },
+    355: { name: "U.S. Customs Acceptance/Rejection" },
+    356: { name: "U.S. Customs Permit to Transfer Request" },
+    357: { name: "U.S. Customs In-Bond Information" },
+    358: { name: "U.S. Customs Consist Information" },
+    361: { name: "Carrier Interchange Agreement (Ocean)" },
+    362: { name: "Cargo Insurance Advice of Shipment" },
+    404: { name: "Rail Carrier Shipment Information" },
+    410: { name: "Rail Carrier Freight Details and Invoice" },
+    411: { name: "Rail Carrier Freight Details and Invoice Summary" },
+    412: { name: "Trailer or Container Repair Billing" },
+    414: { name: "Rail Carhire Settlements" },
+    417: { name: "Rail Carrier Waybill Interchange" },
+    418: { name: "Rail Advance Interchange Consist" },
+    419: { name: "Advance Car Disposition" },
+    420: { name: "Car Handling Information" },
+    421: { name: "Estimated Time of Arrival and Car Scheduling" },
+    422: { name: "Shipper's Car Order" },
+    423: { name: "Rail Industrial Switch List" },
+    424: { name: "Rail Carrier Services Settlement" },
+    425: { name: "Rail Waybill Request" },
+    426: { name: "Rail Revenue Waybill" },
+    427: { name: "Rail Waybill Response" },
+    429: { name: "Railroad Retirement Activity" },
+    431: { name: "Railroad Station Master File" },
+    432: { name: "Rail Deprescription" },
+    433: { name: "Railroad Reciprocal Switch File" },
+    434: { name: "Railroad Mark Register Update Activity" },
+    435: { name: "Standard Transportation Commodity Code (STCC) Master" },
+    436: { name: "Locomotive Information" },
+    437: { name: "Railroad Junctions and Interchanges Activity" },
+    440: { name: "Shipment Weights" },
+    451: { name: "Railroad Event Report" },
+    452: { name: "Railroad Problem Log Inquiry or Advice" },
+    453: { name: "Railroad Service Commitment Advice" },
+    455: { name: "Railroad Parameter Trace Registration" },
+    456: { name: "Railroad Equipment Inquiry or Advice" },
+    460: { name: "Railroad Price Distribution Request or Response" },
+    463: { name: "Rail Rate Reply" },
+    466: { name: "Rate Request" },
+    468: { name: "Rate Docket Journal Log" },
+    470: { name: "Railroad Clearance" },
+    475: { name: "Rail Route File Maintenance" },
+    485: { name: "Ratemaking Action" },
+    486: { name: "Rate Docket Expiration" },
+    490: { name: "Rate Group Definition" },
+    492: { name: "Miscellaneous Rates" },
+    494: { name: "Rail Scale Rates" },
+    500: { name: "Medical Event Reporting" },
+    501: { name: "Vendor Performance Review" },
+    503: { name: "Pricing History" },
+    504: { name: "Clauses and Provisions" },
+    511: { name: "Requisition" },
+    517: { name: "Material Obligation Validation" },
+    521: { name: "Income or Asset Offset" },
+    527: { name: "Material Due-In and Receipt" },
+    536: { name: "Logistics Reassignment" },
+    540: { name: "Notice of Employment Status" },
+    561: { name: "Contract Abstract" },
+    567: { name: "Contract Completion Status" },
+    568: { name: "Contract Payment Management Report" },
+    601: { name: "U.S. Customs Export Shipment Information" },
+    602: { name: "Transportation Services Tender" },
+    620: { name: "Excavation Communication" },
+    625: { name: "Well Information" },
+    650: { name: "Maintenance Service Order" },
+    715: { name: "Intermodal Group Loading Plan" },
+    805: { name: "Contract Pricing Proposal" },
+    806: { name: "Project Schedule Reporting" },
+    810: { name: "Invoice", edifactId: "INVOIC" },
+    811: { name: "Consolidated Service Invoice/Statement" },
+    812: { name: "Credit/Debit Adjustment" },
+    813: { name: "Electronic Filing of Tax Return Data" },
+    814: { name: "General Request, Response or Confirmation" },
+    815: { name: "Cryptographic Service Message" },
+    816: { name: "Organizational Relationships" },
+    818: { name: "Commission Sales Report" },
+    819: { name: "Operating Expense Statement" },
+    820: { name: "Payment Order/Remittance Advice", edifactId: "REMADV" },
+    821: { name: "Financial Information Reporting" },
+    822: { name: "Account Analysis" },
+    823: { name: "Lockbox" },
+    824: { name: "Application Advice", edifactId: "APERAK" },
+    826: { name: "Tax Information Exchange" },
+    827: { name: "Financial Return Notice" },
+    828: { name: "Debit Authorization" },
+    829: { name: "Payment Cancellation Request" },
+    830: { name: "Planning Schedule with Release Capability", edifactId: "DELFOR" },
+    831: { name: "Application Control Totals" },
+    832: { name: "Price/Sales Catalog", edifactId: "PRICAT" },
+    833: { name: "Mortgage Credit Report Order" },
+    834: { name: "Benefit Enrollment and Maintenance" },
+    835: { name: "Health Care Claim Payment/Advice" },
+    836: { name: "Procurement Notices" },
+    837: { name: "Health Care Claim" },
+    838: { name: "Trading Partner Profile" },
+    839: { name: "Project Cost Reporting" },
+    840: { name: "Request for Quotation", edifactId: "REQUOTE" },
+    841: { name: "Specifications/Technical Information" },
+    842: { name: "Nonconformance Report" },
+    843: { name: "Response to Request for Quotation", edifactId: "QUOTES" },
+    844: { name: "Product Transfer Account Adjustment", edifactId: "SSDCLM" },
+    845: { name: "Price Authorization Acknowledgment/Status", edifactId: "ATHSTS" },
+    846: { name: "Inventory Inquiry/Advice", edifactId: "INVRPT" },
+    847: { name: "Material Claim" },
+    848: { name: "Material Safety Data Sheet" },
+    849: { name: "Response to Product Transfer Account Adjustment" },
+    850: { name: "Purchase Order", edifactId: "ORDERS" },
+    851: { name: "Asset Schedule" },
+    852: { name: "Product Activity Data", edifactId: "SLSRPT" },
+    853: { name: "Routing and Carrier Instruction" },
+    854: { name: "Shipment Delivery Discrepancy Information" },
+    855: { name: "Purchase Order Acknowledgment", edifactId: "ORDRSP" },
+    856: { name: "Advance Ship Notice/Manifest", edifactId: "DESADV" },
+    857: { name: "Shipment and Billing Notice" },
+    858: { name: "Shipment Information" },
+    859: { name: "Freight Invoice" },
+    860: { name: "Purchase Order Change", edifactId: "ORDCHG" },
+    861: { name: "Receiving Advice/Acceptance Certificate", edifactId: "RECADV" },
+    862: { name: "Shipping Schedule", edifactId: "DELJIT" },
+    863: { name: "Report of Test Results" },
+    864: { name: "Text Message" },
+    865: { name: "Purchase Order Change", edifactId: "ORDRSP" },
+    866: { name: "Production Sequence" },
+    867: { name: "Product Transfer and Resale Report", edifactId: "SLSRPT" },
+    868: { name: "Electronic Form Structure" },
+    869: { name: "Order Status Inquiry", edifactId: "ORSSTA" },
+    870: { name: "Order Status Report", edifactId: "ORDREP" },
+    871: { name: "Component Parts Content" },
+    872: { name: "Residential Mortgage Insurance Application" },
+    875: { name: "Grocery Products Purchase Order" },
+    876: { name: "Grocery Products Purchase Order Change" },
+    877: { name: "Manufacturer Coupon Family Code Structure" },
+    878: { name: "Product Authorization/De-authorization" },
+    879: { name: "Price Information" },
+    880: { name: "Grocery Products Invoice" },
+    881: { name: "Manufacturer Coupon Redemption Detail" },
+    882: { name: "Direct Store Delivery Summary Information" },
+    883: { name: "Market Development Fund Allocation" },
+    884: { name: "Market Development Fund Settlement" },
+    885: { name: "Retail Account Characteristics" },
+    886: { name: "Customer Call Reporting" },
+    887: { name: "Coupon Notification" },
+    888: { name: "Item Maintenance" },
+    889: { name: "Promotion Announcement" },
+    891: { name: "Deduction Research Report" },
+    893: { name: "Item Information Request" },
+    894: { name: "Delivery/Return Base Record" },
+    895: { name: "Delivery/Return Acknowledgment or Adjustment" },
+    896: { name: "Product Dimension Maintenance" },
+    920: { name: "Loss or Damage Claim - General Commodities" },
+    924: { name: "Loss or Damage Claim - Motor Vehicle" },
+    925: { name: "Claim Tracer" },
+    926: { name: "Claim Status Report and Tracer Reply" },
+    928: { name: "Automotive Inspection Detail" },
+    940: { name: "Warehouse Shipping Order" },
+    943: { name: "Warehouse Stock Transfer Shipment Advice" },
+    944: { name: "Warehouse Stock Transfer Receipt Advice" },
+    945: { name: "Warehouse Shipping Advice" },
+    947: { name: "Warehouse Inventory Adjustment Advice" },
+    980: { name: "Functional Group Totals" },
+    990: { name: "Response to a Load Tender" },
+    996: { name: "File Transfer" },
+    997: { name: "Functional Acknowledgment", edifactId: "CONTROL" },
+    998: { name: "Set Cancellation" },
+    999: { name: "Implementation Acknowledgment" },
+});
+
+/**
+ * A property decorated with this will have any value assigned
+ * to it cast to a number with the unary `+` operator.
+ */
+function castToNumber() {
+    return function (target, key) {
+        var _a;
+        var internalKey = "_" + String(key);
+        Object.defineProperties(target, (_a = {},
+            _a[internalKey] = {
+                enumerable: false,
+                configurable: true,
+                writable: true,
+                value: undefined,
+            },
+            _a[key] = {
+                enumerable: true,
+                configurable: true,
+                get: function () {
+                    return this[internalKey];
+                },
+                set: function (newValue) {
+                    this[internalKey] = Number(newValue);
+                },
+            },
+            _a));
+    };
+}
+
+var __assign$3 = (undefined && undefined.__assign) || function () {
+    __assign$3 = 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 __assign$3.apply(this, arguments);
+};
+/**
+ * Decorator that applies `debounce`
+ */
+function debounced(ms) {
+    return function (target, propertyKey, descriptor) {
+        var originalDescriptorCopy = __assign$3({}, descriptor);
+        originalDescriptorCopy.get = function get() {
+            /*
+             * Make a new copy each time; if you don't then every instance after the first
+             * one of the class containing the decorated method will break.
+             */
+            var newDescriptorWithDebounced = __assign$3({}, originalDescriptorCopy);
+            newDescriptorWithDebounced.value = debounce(originalDescriptorCopy.value, ms, this);
+            Object.defineProperty(this, propertyKey, newDescriptorWithDebounced);
+            return newDescriptorWithDebounced.value;
+        };
+        originalDescriptorCopy.configurable = true;
+        delete originalDescriptorCopy.writable;
+        delete originalDescriptorCopy.value;
+        return originalDescriptorCopy;
+    };
+}
+
+var __assign$2 = (undefined && undefined.__assign) || function () {
+    __assign$2 = 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 __assign$2.apply(this, arguments);
+};
+/**
+ * Decorator that applies `lockToAnimationFrames`
+ */
+function lockedToAnimationFrames(target, propertyKey, descriptor) {
+    var originalDescriptorCopy = __assign$2({}, descriptor);
+    descriptor.get = function get() {
+        /*
+         * Make a new copy each time; if you don't then every instance after the first
+         * one of the class containing the decorated method will break.
+         */
+        var newDescriptor = __assign$2({}, originalDescriptorCopy);
+        newDescriptor.value = lockToAnimationFrames(originalDescriptorCopy.value, this);
+        Object.defineProperty(this, propertyKey, newDescriptor);
+        return newDescriptor.value;
+    };
+    descriptor.configurable = true;
+    delete descriptor.writable;
+    delete descriptor.value;
+    return descriptor;
+}
+
+var __assign$1 = (undefined && undefined.__assign) || function () {
+    __assign$1 = 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 __assign$1.apply(this, arguments);
+};
+var __values$b = (undefined && undefined.__values) || 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.");
+};
+/**
+ * This would be simpler to understand as a factory that returns a decorator function,
+ *  but TypeScript AoT compliation doesn't allow that. This lets you create a decorator
+ *  that takes in a metadata object as an argument and assigns its values along with
+ *  default values to the decorated method. The decorator will look like a standard
+ *  decorator but calling this method and returning the result is the only thing it
+ *  needs to do.
+ */
+function simpleMetadataDecoratorApplicator(metadata, defaults, target, key, descriptor) {
+    var updatedDescriptor = descriptor || Object.getOwnPropertyDescriptor(target, key);
+    var getter = updatedDescriptor.get;
+    var value = updatedDescriptor.value;
+    updatedDescriptor.get = function get() {
+        var e_1, _a;
+        // I don't remember why I did this "this" alias & want to ensure we don't break anything...
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        var self = this;
+        var fn = value || getter.call(this);
+        var boundFn = fn.bind(this);
+        var updatedMetadata = __assign$1(__assign$1({}, defaults), metadata);
+        var _loop_1 = function (prop) {
+            if (typeof metadata[prop] === "function") {
+                Object.defineProperty(boundFn, prop, {
+                    get: function () {
+                        return updatedMetadata[prop](self);
+                    },
+                });
+            }
+            else {
+                boundFn[prop] = updatedMetadata[prop];
+            }
+        };
+        try {
+            for (var _b = __values$b(Object.keys(defaults)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var prop = _c.value;
+                _loop_1(prop);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        Object.defineProperty(this, key, {
+            writable: true,
+            configurable: true,
+            enumerable: updatedDescriptor.enumerable,
+            value: boundFn,
+        });
+        return boundFn;
+    };
+    delete updatedDescriptor.value;
+    delete updatedDescriptor.writable;
+    return updatedDescriptor;
+}
+
+var __assign = (undefined && undefined.__assign) || function () {
+    __assign = 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 __assign.apply(this, arguments);
+};
+/** Method decorator that configures the method to always run the tick after it's invoked */
+function tickDelay(target, propertyKey, descriptor) {
+    var originalDescriptorCopy = __assign({}, descriptor);
+    originalDescriptorCopy.get = function get() {
+        /*
+         * Make a new copy each time; if you don't then every instance after the first
+         * one of the class containing the decorated method will break.
+         */
+        var newDescriptor = __assign({}, originalDescriptorCopy);
+        var boundFn = originalDescriptorCopy.value.bind(this);
+        newDescriptor.value = function () { return setTimeout(boundFn, 0); };
+        Object.defineProperty(this, propertyKey, newDescriptor);
+        return newDescriptor.value;
+    };
+    originalDescriptorCopy.configurable = true;
+    delete originalDescriptorCopy.writable;
+    delete originalDescriptorCopy.value;
+    return originalDescriptorCopy;
+}
+
+/**
+ * Constrains a number to the given range. If the number is below the
+ * low end of the range, the low end will be returned. If the number is
+ * above the top end of the range, the top end will be returned. Otherwise
+ * the number itself will be returned.
+ */
+function constrain(n, range) {
+    if (!n || n < range[0]) {
+        return range[0];
+    }
+    if (n > range[1]) {
+        return range[1];
+    }
+    return n;
+}
+
+/**
+ * Progressively rounds `num` to `decimalPlaces` places. This differs from other
+ * rounding methods out there such as lodash's, which are not progressive. For example,
+ * `(0.149).toFixed(1)` and lodash `_.round(0.149, 1)` both return `0.1`, but this
+ * function rounds `0.149` to `0.15` and then `0.15` to `0.2` and returns `0.2`.
+ */
+function decimalRound(num, decimalPlaces) {
+    if (decimalPlaces === void 0) { decimalPlaces = 0; }
+    var integralAndFractionalSplit = String(num).split(".");
+    var allDecimalPlaces = integralAndFractionalSplit.length > 1
+        ? integralAndFractionalSplit[1].length
+        : 0;
+    var roundedNum = num;
+    for (var i = allDecimalPlaces - 1; i >= decimalPlaces; i -= 1) {
+        roundedNum = Number(Math.round(Number(roundedNum + "e" + i)) + "e-" + i);
+    }
+    return roundedNum;
+}
+
+/**
+ * Converts a file size in bytes to a human-friendly string. For example,
+ * `toFileSizeString(2048)` will return `"2.00KB"`.
+ */
+function toFileSizeString(n, precision) {
+    if (precision === void 0) { precision = 2; }
+    if (n > Number.MAX_SAFE_INTEGER) {
+        throw new Error("Number is greater than MAX_SAFE_INTEGER; "
+            + "toFileSizeString does not support orders of magnitude "
+            + "higher than petabytes for this reason until BigInt "
+            + "achieves broad browser support.");
+    }
+    var magnitude = Math.min(Math.floor(Math.log(n) / Math.log(1024)), 5);
+    var unit = ["B",
+        "KB",
+        "MB",
+        "GB",
+        "TB",
+        "PB"][magnitude];
+    var decimalPlaces = magnitude ? precision : 0;
+    return decimalRound(n / (Math.pow(1024, magnitude)), decimalPlaces).toFixed(decimalPlaces) + unit;
+}
+
+/**
+ * Converts a path to crumbs.
+ *  For example:
+ *  "a.b[0].c" -> ["a", "b", "0", "c"]
+ */
+function crumblePath(path) {
+    return typeof path === "string" ? path.match(/[^.[\]]+/g) || [] : [].concat(path);
+}
+
+/**
+ * Copy a property from one object to another using its property descriptor.
+ * In other words, if it's a getter/setter on `sourceObject` it'll be the same
+ * getter/setter on `destObject`. If it's just a value it'll be just a value.
+ */
+function copyProperty(propName, sourceObject, destObject) {
+    Object.defineProperty(destObject, propName, Object.getOwnPropertyDescriptor(sourceObject, propName));
+}
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** `Object#toString` result references. */
+var objectTag = '[object Object]';
+
+/**
+ * Checks if `value` is a host object in IE < 9.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+ */
+function isHostObject(value) {
+  // Many host objects are `Object` objects that can coerce to strings
+  // despite having improperly defined `toString` methods.
+  var result = false;
+  if (value != null && typeof value.toString != 'function') {
+    try {
+      result = !!(value + '');
+    } catch (e) {}
+  }
+  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));
+  };
+}
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+    objectProto = Object.prototype;
+
+/** 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 infer the `Object` constructor. */
+var objectCtorString = funcToString.call(Object);
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/** Built-in value references. */
+var getPrototype = overArg(Object.getPrototypeOf, Object);
+
+/**
+ * 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 && typeof value == 'object';
+}
+
+/**
+ * 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) ||
+      objectToString.call(value) != objectTag || isHostObject(value)) {
+    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);
+}
+
+var lodash_isplainobject = isPlainObject;
+
+var __values$a = (undefined && undefined.__values) || 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.");
+};
+/*
+ * Recursive Object.freeze on plain objects and arrays
+ */
+function deepFreeze(obj) {
+    var e_1, _a;
+    Object.freeze(obj);
+    try {
+        for (var _b = __values$a(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var key = _c.value;
+            var val = obj[key];
+            if (lodash_isplainobject(val) || Array.isArray(val)) {
+                deepFreeze(val);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+
+var __read$3 = (undefined && undefined.__read) || 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: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray$1 = (undefined && undefined.__spreadArray) || 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));
+};
+var __values$9 = (undefined && undefined.__values) || 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.");
+};
+var DiffChange;
+(function (DiffChange) {
+    DiffChange[DiffChange["ADDITION"] = 0] = "ADDITION";
+    DiffChange[DiffChange["DELETION"] = 1] = "DELETION";
+    DiffChange[DiffChange["ALTERATION"] = 2] = "ALTERATION";
+})(DiffChange || (DiffChange = {}));
+function diff(o1, o2, parentPath) {
+    var e_1, _a;
+    if (parentPath === void 0) { parentPath = []; }
+    var d = [];
+    try {
+        for (var _b = __values$9(new Set(__spreadArray$1(__spreadArray$1([], __read$3(Object.keys(o1)), false), __read$3(Object.keys(o2)), false))), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var key = _c.value;
+            var o1HasKey = Object.prototype.hasOwnProperty.call(o1, key);
+            var o2HasKey = Object.prototype.hasOwnProperty.call(o2, key);
+            if (o1HasKey && !o2HasKey) {
+                d.push({
+                    type: DiffChange.DELETION,
+                    key: key,
+                    parentPath: parentPath,
+                    objects: [o1, o2],
+                });
+            }
+            else if (!o1HasKey && o2HasKey) {
+                d.push({
+                    type: DiffChange.ADDITION,
+                    key: key,
+                    parentPath: parentPath,
+                    objects: [o1, o2],
+                });
+            }
+            else if ((lodash_isplainobject(o1[key]) && lodash_isplainobject(o2[key]))
+                || (Array.isArray(o1[key]) && Array.isArray(o2[key]))) {
+                d = d.concat(diff(o1[key], o2[key], __spreadArray$1(__spreadArray$1([], __read$3(parentPath), false), [key], false)));
+            }
+            else if (o1[key] !== o2[key]) {
+                d.push({
+                    type: DiffChange.ALTERATION,
+                    key: key,
+                    parentPath: parentPath,
+                    objects: [o1, o2],
+                });
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return d;
+}
+
+var __values$8 = (undefined && undefined.__values) || 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.");
+};
+/**
+ * Recursively navigate a nested object & call `fn` for each key/value pair
+ */
+function forEachEntryDeep(object, fn) {
+    var e_1, _a;
+    try {
+        for (var _b = __values$8(Object.keys(object)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var key = _c.value;
+            var value = object[key];
+            if (lodash_isplainobject(value) || Array.isArray(value)) {
+                forEachEntryDeep(value, fn);
+            }
+            else {
+                fn(key, value, object);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+
+var __values$7 = (undefined && undefined.__values) || 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.");
+};
+/**
+ * Recursively navigate a nested object & call `fn` for each subobject
+ */
+function forEachNestedObject(object, fn, path) {
+    var e_1, _a;
+    if (path === void 0) { path = []; }
+    fn(path, object);
+    try {
+        for (var _b = __values$7(Object.keys(object)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var key = _c.value;
+            var value = object[key];
+            if (lodash_isplainobject(value) || Array.isArray(value)) {
+                var newPath = path.concat(key);
+                forEachNestedObject(value, fn, newPath);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+
+/**
+ * lodash 4.0.0 (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <https://lodash.com/license>
+ */
+
+/**
+ * Checks if `value` is `null` or `undefined`.
+ *
+ * @static
+ * @memberOf _
+ * @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$1(value) {
+  return value == null;
+}
+
+var lodash_isnil = isNil$1;
+
+var isNilImport = /*#__PURE__*/Object.freeze(/*#__PURE__*/_mergeNamespaces({
+    __proto__: null,
+    'default': lodash_isnil
+}, [lodash_isnil]));
+
+var lodash_isempty$1 = {exports: {}};
+
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+(function (module, exports) {
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER = 9007199254740991;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    funcTag = '[object Function]',
+    genTag = '[object GeneratorFunction]',
+    mapTag = '[object Map]',
+    objectTag = '[object Object]',
+    promiseTag = '[object Promise]',
+    setTag = '[object Set]',
+    weakMapTag = '[object WeakMap]';
+
+var dataViewTag = '[object DataView]';
+
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** 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;
+
+/**
+ * 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 : object[key];
+}
+
+/**
+ * Checks if `value` is a host object in IE < 9.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+ */
+function isHostObject(value) {
+  // Many host objects are `Object` objects that can coerce to strings
+  // despite having improperly defined `toString` methods.
+  var result = false;
+  if (value != null && typeof value.toString != 'function') {
+    try {
+      result = !!(value + '');
+    } catch (e) {}
+  }
+  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));
+  };
+}
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+    objectProto = Object.prototype;
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData = root['__core-js_shared__'];
+
+/** 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 decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/** 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 ? root.Buffer : undefined,
+    propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
+    nativeKeys = overArg(Object.keys, Object);
+
+/* Built-in method references that are verified to be native. */
+var DataView = getNative(root, 'DataView'),
+    Map = getNative(root, 'Map'),
+    Promise = getNative(root, 'Promise'),
+    Set = getNative(root, 'Set'),
+    WeakMap = getNative(root, 'WeakMap');
+
+/** Detect if properties shadowing those on `Object.prototype` are non-enumerable. */
+var nonEnumShadows = !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf');
+
+/** Used to detect maps, sets, and weakmaps. */
+var dataViewCtorString = toSource(DataView),
+    mapCtorString = toSource(Map),
+    promiseCtorString = toSource(Promise),
+    setCtorString = toSource(Set),
+    weakMapCtorString = toSource(WeakMap);
+
+/**
+ * The base implementation of `getTag`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag(value) {
+  return objectToString.call(value);
+}
+
+/**
+ * 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) || isHostObject(value)) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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,
+// for data views in Edge < 14, and promises in Node.js.
+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 = objectToString.call(value),
+        Ctor = result == objectTag ? value.constructor : undefined,
+        ctorString = Ctor ? toSource(Ctor) : undefined;
+
+    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;
+  };
+}
+
+/**
+ * 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 `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;
+}
+
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to process.
+ * @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 '';
+}
+
+/**
+ * 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
+ */
+function isArguments(value) {
+  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
+  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
+    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
+}
+
+/**
+ * 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 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 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 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 (isArrayLike(value) &&
+      (isArray(value) || typeof value == 'string' ||
+        typeof value.splice == 'function' || isBuffer(value) || isArguments(value))) {
+    return !value.length;
+  }
+  var tag = getTag(value);
+  if (tag == mapTag || tag == setTag) {
+    return !value.size;
+  }
+  if (nonEnumShadows || isPrototype(value)) {
+    return !nativeKeys(value).length;
+  }
+  for (var key in value) {
+    if (hasOwnProperty.call(value, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * 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) {
+  // The use of `Object#toString` avoids issues with the `typeof` operator
+  // in Safari 8-9 which returns 'object' for typed array and other constructors.
+  var tag = isObject(value) ? objectToString.call(value) : '';
+  return tag == funcTag || tag == genTag;
+}
+
+/**
+ * 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 && (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 && typeof value == 'object';
+}
+
+/**
+ * This method returns `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {boolean} Returns `false`.
+ * @example
+ *
+ * _.times(2, _.stubFalse);
+ * // => [false, false]
+ */
+function stubFalse() {
+  return false;
+}
+
+module.exports = isEmpty;
+}(lodash_isempty$1, lodash_isempty$1.exports));
+
+var lodash_isempty = lodash_isempty$1.exports;
+
+var isEmptyImport = /*#__PURE__*/Object.freeze(/*#__PURE__*/_mergeNamespaces({
+    __proto__: null,
+    'default': lodash_isempty
+}, [lodash_isempty$1.exports]));
+
+var __values$6 = (undefined && undefined.__values) || 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.");
+};
+var __read$2 = (undefined && undefined.__read) || 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: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var isNil = lodash_isnil || isNilImport;
+var isEmpty$1 = lodash_isempty || isEmptyImport;
+/**
+ * Get the value at `path` starting from `object`.
+ * Allows optional chaining, e.g. `get(obj, 'a.b?.c')`
+ */
+function getPath(object, path, defaultValue, allOptional) {
+    var e_1, _a, _b;
+    if (allOptional === void 0) { allOptional = false; }
+    if (isEmpty$1(path)) {
+        return object;
+    }
+    var value = object;
+    try {
+        for (var _c = __values$6(crumblePath(path)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var crumb = _d.value;
+            var key = crumb;
+            var optional = void 0;
+            if (typeof crumb === "string") {
+                _b = __read$2(/^([^?]+)(\?)?$/.exec(crumb), 3), key = _b[1], optional = _b[2];
+            }
+            value = value[key];
+            if (isNil(value) && (optional || allOptional)) {
+                return defaultValue;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return isNil(value) ? defaultValue : value;
+}
+
+var __values$5 = (undefined && undefined.__values) || 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.");
+};
+/*
+ * Return a copy of `obj` without the key `key`
+ */
+function omit(obj) {
+    var e_1, _a;
+    var keys = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        keys[_i - 1] = arguments[_i];
+    }
+    var keySet = new Set(keys);
+    var result = {};
+    try {
+        for (var _b = __values$5(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var k = _c.value;
+            if (!keySet.has(k)) {
+                result[k] = obj[k];
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return result;
+}
+
+var __values$4 = (undefined && undefined.__values) || 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.");
+};
+var isEmpty = lodash_isempty || isEmptyImport;
+/** Set the value at `path` on `object`. */
+function setPath(object, path, newValue) {
+    var e_1, _a;
+    if (typeof object !== "object") {
+        throw new Error("object is required");
+    }
+    if (isEmpty(path)) {
+        throw new Error("path is required");
+    }
+    var crumbs = crumblePath(path);
+    var finalCrumb = crumbs.splice(crumbs.length - 1, 1)[0];
+    var current = object;
+    try {
+        for (var crumbs_1 = __values$4(crumbs), crumbs_1_1 = crumbs_1.next(); !crumbs_1_1.done; crumbs_1_1 = crumbs_1.next()) {
+            var crumb = crumbs_1_1.value;
+            current = current[crumb];
+            if (typeof current !== "object") {
+                throw new Error("Cannot set value at given path: Path deadends at " + String(crumb));
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (crumbs_1_1 && !crumbs_1_1.done && (_a = crumbs_1.return)) _a.call(crumbs_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    current[finalCrumb] = newValue;
+}
+
+var __generator = (undefined && undefined.__generator) || 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 };
+    }
+};
+var __values$3 = (undefined && undefined.__values) || 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.");
+};
+/** Generator for iterating down a path on an object. */
+function traversePath(object, path) {
+    var obj, _a, _b, crumb, e_1_1;
+    var e_1, _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0: return [4 /*yield*/, object];
+            case 1:
+                _d.sent();
+                obj = object;
+                _d.label = 2;
+            case 2:
+                _d.trys.push([2, 7, 8, 9]);
+                _a = __values$3(crumblePath(path)), _b = _a.next();
+                _d.label = 3;
+            case 3:
+                if (!!_b.done) return [3 /*break*/, 6];
+                crumb = _b.value;
+                obj = obj[crumb];
+                return [4 /*yield*/, obj];
+            case 4:
+                _d.sent();
+                _d.label = 5;
+            case 5:
+                _b = _a.next();
+                return [3 /*break*/, 3];
+            case 6: return [3 /*break*/, 9];
+            case 7:
+                e_1_1 = _d.sent();
+                e_1 = { error: e_1_1 };
+                return [3 /*break*/, 9];
+            case 8:
+                try {
+                    if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                }
+                finally { if (e_1) throw e_1.error; }
+                return [7 /*endfinally*/];
+            case 9: return [2 /*return*/];
+        }
+    });
+}
+
+var __values$2 = (undefined && undefined.__values) || 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.");
+};
+/**
+ * Recursive merge of any number of objects
+ */
+function mergeDeep() {
+    var e_1, _a, e_2, _b;
+    var objectsToMerge = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        objectsToMerge[_i] = arguments[_i];
+    }
+    var result = {};
+    try {
+        for (var objectsToMerge_1 = __values$2(objectsToMerge), objectsToMerge_1_1 = objectsToMerge_1.next(); !objectsToMerge_1_1.done; objectsToMerge_1_1 = objectsToMerge_1.next()) {
+            var mergee = objectsToMerge_1_1.value;
+            try {
+                for (var _c = (e_2 = void 0, __values$2(Object.keys(mergee))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var key = _d.value;
+                    if (Object.prototype.hasOwnProperty.call(result, key)
+                        && Object.getOwnPropertyDescriptor(result, key).writable
+                        && lodash_isplainobject(result[key])) {
+                        result[key] = mergeDeep(result[key], mergee[key]);
+                    }
+                    else if (lodash_isplainobject(mergee[key])) {
+                        result[key] = mergeDeep({}, mergee[key]);
+                    }
+                    else {
+                        result[key] = mergee[key];
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (objectsToMerge_1_1 && !objectsToMerge_1_1.done && (_a = objectsToMerge_1.return)) _a.call(objectsToMerge_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return result;
+}
+
+var __values$1 = (undefined && undefined.__values) || 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.");
+};
+/**
+ * Recursive merge of any number of objects using `copyProperty()` rather than assignment
+ */
+function mergePropertiesDeep() {
+    var e_1, _a, e_2, _b;
+    var objectsToMerge = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        objectsToMerge[_i] = arguments[_i];
+    }
+    var result = {};
+    try {
+        for (var objectsToMerge_1 = __values$1(objectsToMerge), objectsToMerge_1_1 = objectsToMerge_1.next(); !objectsToMerge_1_1.done; objectsToMerge_1_1 = objectsToMerge_1.next()) {
+            var mergee = objectsToMerge_1_1.value;
+            try {
+                for (var _c = (e_2 = void 0, __values$1(Object.keys(mergee))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var key = _d.value;
+                    if (Object.prototype.hasOwnProperty.call(result, key)
+                        && Object.getOwnPropertyDescriptor(result, key).writable
+                        && lodash_isplainobject(result[key])) {
+                        result[key] = mergePropertiesDeep(result[key], mergee[key]);
+                    }
+                    else if (lodash_isplainobject(mergee[key])) {
+                        result[key] = mergePropertiesDeep({}, mergee[key]);
+                    }
+                    else {
+                        copyProperty(key, mergee, result);
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (objectsToMerge_1_1 && !objectsToMerge_1_1.done && (_a = objectsToMerge_1.return)) _a.call(objectsToMerge_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return result;
+}
+
+var __values = (undefined && undefined.__values) || 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.");
+};
+/** Returns the values of an object. */
+function values(object) {
+    var e_1, _a;
+    var vals = [];
+    try {
+        for (var _b = __values(Object.keys(object)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var key = _c.value;
+            vals.push(object[key]);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return vals;
+}
+
+var __read$1 = (undefined && undefined.__read) || 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: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (undefined && undefined.__spreadArray) || 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));
+};
+/** Template tag function for making strings containing code blocks easier to deal with. */
+function code(strings) {
+    var interpolations = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        interpolations[_i - 1] = arguments[_i];
+    }
+    var s = strings.reduce(function (a, b, i) { return "" + a + (i <= interpolations.length ? String(interpolations[i - 1]) : "") + b; });
+    var leadingWhitespace = Math.min.apply(Math, __spreadArray([], __read$1(s.split(/[\r\n]/)
+        .filter(function (l) { return l.trim(); })
+        .map(function (l) { return (/^ */.exec(l))[0].length; })), false));
+    return s.replace(new RegExp("^ {" + leadingWhitespace + "}", "gm"), "").trim();
+}
+
+var __read = (undefined && undefined.__read) || 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: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+/**
+ * Parses a string as a file size and returns the size in bytes. For example,
+ * `parseFileSize("2KB")` will return `2048`.
+ */
+function parseFileSize(fileSize) {
+    var unitMatch = /[A-Z]?B$/.exec(fileSize);
+    if (!unitMatch) {
+        throw new Error("Input to parseFileSize (\"" + fileSize + "\") doesn't seem like a file size; "
+            + "cannot identify a unit (e.g. KB, GB)");
+    }
+    var _a = __read(unitMatch, 1), unit = _a[0];
+    var num = Number(fileSize.replace(unit, ""));
+    if (Number.isNaN(num)) {
+        throw new Error("Could not parse a number out of input to parseFileSize (\"" + fileSize + "\")");
+    }
+    var magnitude = ["B",
+        "KB",
+        "MB",
+        "GB",
+        "TB",
+        "PB"].indexOf(unit);
+    if (magnitude === -1) {
+        throw new Error("parseFileSize does not support units above PB");
+    }
+    return Math.ceil(num * (Math.pow(1024, magnitude)));
+}
+
+var REGEX_REPLACEMENT = /(<%=|{{)(.+?)(%>|}})/g;
+var REGEX_IF = /<%\?(.+?)%>(.+?)<\/%>/g;
+var SYMBOL_TEMPLATE_SOURCE = Symbol("sps.utils.templateSrc");
+/**
+ *  Every string templating thing out there whether lodash, doT, handlebars, etc
+ *  is extremely complicated to cover a variety of use cases. This just has two
+ *  very simple features and great caution should be exercised in making it any more
+ *  complex than that. A value can be interpolated like so:
+ *  `<%= foo.bar %>`
+ *  And a basic "if" conditional can be used like so:
+ *  `<%? a?.b?.c %>This part will only appear if a.b.c is truthy!</%>`
+ *  You can put interpolations inside a conditional, as you'd expect. That's it.
+ */
+function template(string) {
+    var fn = function (data) { return string
+        .replace(REGEX_IF, function (match, pathToCheck, content) { return (getPath(data, pathToCheck.trim()) ? content : ""); })
+        .replace(REGEX_REPLACEMENT, function (match, _, pathToInterpolate) { return getPath(data, pathToInterpolate.trim(), ""); }); };
+    fn[SYMBOL_TEMPLATE_SOURCE] = string;
+    return fn;
+}
+function isTemplate(x) {
+    return typeof x === "string" && (REGEX_REPLACEMENT.test(x) || REGEX_IF.test(x));
+}
+function isTemplateFn(x) {
+    return typeof x === "function" && Object.prototype.hasOwnProperty.call(x, SYMBOL_TEMPLATE_SOURCE);
+}
+
+export { CustomEvent, DiffChange, EDI_DOCUMENT_TYPE, Op, castToNumber, code, constrain, copyProperty, crumblePath, debounce, debounced, decimalRound, deepFreeze, diff, flatten, forEachEntryDeep, forEachNestedObject, getPath, isSubset, isTemplate, isTemplateFn, lockToAnimationFrames, lockedToAnimationFrames, mergeDeep, mergePropertiesDeep, omit, onNextTick, parseFileSize, range, setPath, simpleMetadataDecoratorApplicator, template, tickDelay, toFileSizeString, traversePath, values };